@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 173 lines 6.58 KB
Raw
1 import type * as Arr from "effect/Array";
2 import * as Effect from "effect/Effect";
3 import type * as HttpServerRequest from "effect/http/HttpServerRequest";
4 import * as HttpServerResponse from "effect/http/HttpServerResponse";
5 import * as Sql from "effect/sql/SqlClient";
6
7 /**
8 * Dialect-agnostic route handlers exercising the full `SqlClient` constructor
9 * surface through an alchemy `SQL.*` client (a `proxyChain`-wrapped client,
10 * so every helper call below also regression-tests deferred-proxy replay —
11 * nested fragments used to be handed to the driver as opaque proxies).
12 *
13 * Each fixture worker defines an init effect that pulls its own bindings,
14 * builds the clients, and calls {@link makeSqlRoutes} to get the handler
15 * interface; `fetch` just delegates to it.
16 */
17 export interface SqlRoutesOptions {
18 /** The `proxyChain`-wrapped client under test. */
19 readonly sql: Sql.SqlClient;
20 /**
21 * The users service built against the generic `SqlClient` tag with
22 * `SQL.D1Layer` / `SQL.PostgresLayer` provided (see {@link makeLayerUsers})
23 * — proves the Layer wiring end-to-end.
24 */
25 readonly layerUsers: LayerUsers;
26 /** Dialect-specific `CREATE TABLE IF NOT EXISTS` DDL for {@link table}. */
27 readonly ddl: string;
28 /** Users table name — always referenced via the `sql(table)` identifier helper. */
29 readonly table: string;
30 }
31
32 export type UserRow = {
33 id: number;
34 name: string;
35 email: string;
36 };
37
38 export interface LayerUsers {
39 readonly list: Effect.Effect<ReadonlyArray<UserRow>, unknown>;
40 }
41
42 /**
43 * A tiny cloud-agnostic service written against the generic `SqlClient` tag —
44 * the idiomatic consumer of `SQL.D1Layer` / `SQL.PostgresLayer`. Fixtures
45 * build it with the dialect's layer provided:
46 *
47 * ```typescript
48 * const layerUsers = yield* makeLayerUsers(TABLE).pipe(
49 * Effect.provide(SQL.D1Layer(d1)),
50 * );
51 * ```
52 */
53 export const makeLayerUsers = (table: string): Effect.Effect<LayerUsers, never, Sql.SqlClient> =>
54 Effect.gen(function* () {
55 const sql = yield* Sql.SqlClient;
56 return {
57 list: sql<UserRow>`SELECT id, name, email FROM ${sql(table)} ORDER BY id`,
58 };
59 });
60
61 export interface SqlRoutes {
62 /**
63 * Handle one request against the shared route table. Returns the response,
64 * or `undefined` when the route is not part of the shared surface (so the
65 * caller can fall through to its own routes / 404).
66 */
67 readonly handle: (
68 request: HttpServerRequest.HttpServerRequest,
69 ) => Effect.Effect<HttpServerResponse.HttpServerResponse | undefined, unknown>;
70 }
71
72 export const makeSqlRoutes = (options: SqlRoutesOptions): SqlRoutes => {
73 const { sql, layerUsers, ddl, table } = options;
74
75 return {
76 handle: Effect.fn(function* (request) {
77 const [path, query] = request.url.split("?") as [string, string | undefined];
78 const params = new URLSearchParams(query);
79
80 // POST /init — `sql.unsafe` (raw DDL, no params).
81 if (request.method === "POST" && path === "/init") {
82 yield* sql.unsafe(ddl);
83 return yield* HttpServerResponse.json({ ok: true });
84 }
85
86 // POST /reset — identifier helper `sql(table)`.
87 if (request.method === "POST" && path === "/reset") {
88 yield* sql`DELETE FROM ${sql(table)}`;
89 return yield* HttpServerResponse.json({ ok: true });
90 }
91
92 // POST /users — single-row `sql.insert(row)` nested in an outer template
93 // (the original proxyChain regression), read back with `sql.and` over
94 // nested `sql\`...\`` fragments.
95 if (request.method === "POST" && path === "/users") {
96 const row = (yield* request.json) as UserRow;
97 yield* sql`INSERT INTO ${sql(table)} ${sql.insert(row)}`;
98 const rows = yield* sql`
99 SELECT id, name, email FROM ${sql(table)}
100 WHERE ${sql.and([sql`name = ${row.name}`, sql`email = ${row.email}`])}
101 `;
102 return yield* HttpServerResponse.json({ rows });
103 }
104
105 // POST /users/batch — multi-row `sql.insert(rows)`, counted back with
106 // `sql.literal` (raw select-list text).
107 if (request.method === "POST" && path === "/users/batch") {
108 const rows = (yield* request.json) as Arr.NonEmptyReadonlyArray<UserRow>;
109 yield* sql`INSERT INTO ${sql(table)} ${sql.insert(rows)}`;
110 const [count] = yield* sql<{
111 n: number;
112 }>`SELECT ${sql.literal("COUNT(*) AS n")} FROM ${sql(table)}`;
113 return yield* HttpServerResponse.json({ count: Number(count!.n) });
114 }
115
116 // PUT /users — single-row `sql.update(row, omit)` keyed by a bound id.
117 if (request.method === "PUT" && path === "/users") {
118 const row = (yield* request.json) as UserRow;
119 yield* sql`
120 UPDATE ${sql(table)}
121 SET ${sql.update(row, ["id"])}
122 WHERE id = ${row.id}
123 `;
124 const rows = yield* sql`SELECT id, name, email FROM ${sql(table)} WHERE id = ${row.id}`;
125 return yield* HttpServerResponse.json({ rows });
126 }
127
128 // GET /users/in?ids=1,2 — `sql.in(column, values)`.
129 if (request.method === "GET" && path === "/users/in") {
130 const ids = (params.get("ids") ?? "").split(",").map(Number);
131 const rows = yield* sql`
132 SELECT id, name, email FROM ${sql(table)}
133 WHERE ${sql.in("id", ids)}
134 ORDER BY id
135 `;
136 return yield* HttpServerResponse.json({ rows });
137 }
138
139 // GET /users/filter?name=&email=&id= — `sql.or` over a nested `sql.and`
140 // and a plain fragment (fragments nested two levels deep in arrays).
141 if (request.method === "GET" && path === "/users/filter") {
142 const rows = yield* sql`
143 SELECT id, name, email FROM ${sql(table)}
144 WHERE ${sql.or([
145 sql.and([sql`name = ${params.get("name")}`, sql`email = ${params.get("email")}`]),
146 sql`id = ${Number(params.get("id"))}`,
147 ])}
148 ORDER BY id
149 `;
150 return yield* HttpServerResponse.json({ rows });
151 }
152
153 // GET /users/ordered — prefix-form `sql.csv("ORDER BY", ...)` mixing a
154 // raw-string clause with a fragment clause.
155 if (request.method === "GET" && path === "/users/ordered") {
156 const rows = yield* sql`
157 SELECT id, name FROM ${sql(table)}
158 ${sql.csv("ORDER BY", [sql`name DESC`, "id ASC"])}
159 `;
160 return yield* HttpServerResponse.json({ rows });
161 }
162
163 // GET /layer/users — the same table through the generic `SqlClient`
164 // service (see makeLayerUsers).
165 if (request.method === "GET" && path === "/layer/users") {
166 const rows = yield* layerUsers.list;
167 return yield* HttpServerResponse.json({ rows });
168 }
169
170 return undefined;
171 }),
172 };
173 };