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

main
ts 264 lines 9.92 KB
Raw
1 import { NodeFileSystem } from "@effect/platform-node"
2 import { SqliteClient } from "@effect/sql-sqlite-node"
3 import { assert, describe, it } from "@effect/vitest"
4 import { Cause, Context, Effect, Fiber, FileSystem, Iterable, Schema } from "effect"
5 import * as Arr from "effect/Array"
6 import { Reactivity } from "effect/reactivity"
7 import { SqlClient, SqlError, SqlResolver } from "effect/sql"
8
9 const makeClient = Effect.gen(function*() {
10 const fs = yield* FileSystem.FileSystem
11 const dir = yield* fs.makeTempDirectoryScoped()
12 return yield* SqliteClient.make({
13 filename: dir + "/test.db"
14 })
15 }).pipe(Effect.provide([NodeFileSystem.layer, Reactivity.layer]))
16
17 const seededClient = Effect.gen(function*() {
18 const sql = yield* makeClient
19 yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)`
20 const rows = Array.from(Iterable.range(1, 100), (id) => ({ id, name: `name${id}` }))
21 assert(Arr.isArrayNonEmpty(rows))
22 yield* sql`INSERT INTO test ${sql.insert(rows)}`
23 return sql
24 })
25
26 // node:sqlite blocks the Vitest worker; concurrent tests would share a running
27 // timeout while waiting for each other's queries.
28 describe("Resolver", { concurrent: false }, () => {
29 describe("ordered", () => {
30 it.effect("insert", () =>
31 Effect.gen(function*() {
32 const batches: Array<Array<string>> = []
33 const sql = yield* seededClient
34 const Insert = SqlResolver.ordered({
35 Request: Schema.String,
36 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
37 execute: (names) => {
38 batches.push(names)
39 return sql`INSERT INTO test ${sql.insert(Arr.map(names, (name) => ({ name })))} RETURNING *`
40 }
41 })
42 const execute = SqlResolver.request(Insert)
43 assert.deepStrictEqual(
44 yield* Effect.all({
45 one: execute("one"),
46 two: execute("two")
47 }, { concurrency: "unbounded" }),
48 {
49 one: { id: 101, name: "one" },
50 two: { id: 102, name: "two" }
51 }
52 )
53 assert.deepStrictEqual(batches, [["one", "two"]])
54 }))
55
56 it.effect("result length mismatch", () =>
57 Effect.gen(function*() {
58 const batches: Array<Array<number>> = []
59 const sql = yield* seededClient
60 const Select = SqlResolver.ordered({
61 Request: Schema.Number,
62 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
63 execute: (ids) => {
64 batches.push(ids)
65 return sql`SELECT * FROM test WHERE id IN ${sql.in(ids)}`
66 }
67 })
68 const execute = SqlResolver.request(Select)
69 const error = yield* Effect.all([
70 execute(1),
71 execute(2),
72 execute(3),
73 execute(101)
74 ], { concurrency: "unbounded" })
75 .pipe(Effect.flip)
76 assert(error instanceof SqlError.ResultLengthMismatch)
77 assert.strictEqual(error.actual, 3)
78 assert.strictEqual(error.expected, 4)
79 assert.deepStrictEqual(batches, [[1, 2, 3, 101]])
80 }))
81 })
82
83 describe("grouped", () => {
84 it.effect("find by name", () =>
85 Effect.gen(function*() {
86 const sql = yield* seededClient
87 const FindByName = SqlResolver.grouped({
88 Request: Schema.String,
89 RequestGroupKey: (name) => name,
90 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
91 ResultGroupKey: (result) => result.name,
92 execute: (names) => sql`SELECT * FROM test WHERE name IN ${sql.in(names)}`
93 })
94 yield* sql`INSERT INTO test ${sql.insert({ name: "name1" })}`
95 const execute = SqlResolver.request(FindByName)
96 assert.deepStrictEqual(
97 yield* Effect.all({
98 one: execute("name1"),
99 two: execute("name2"),
100 three: Effect.flip(execute("name0"))
101 }, { concurrency: "unbounded" }),
102 {
103 one: [{ id: 1, name: "name1" }, { id: 101, name: "name1" }],
104 two: [{ id: 2, name: "name2" }],
105 three: new Cause.NoSuchElementError()
106 }
107 )
108 }))
109
110 it.effect("using raw rows", () =>
111 Effect.gen(function*() {
112 const sql = yield* seededClient
113 const FindByName = SqlResolver.grouped({
114 Request: Schema.String,
115 RequestGroupKey: (name) => name,
116 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
117 ResultGroupKey: (_, result: any) => result.name,
118 execute: (names) => sql`SELECT * FROM test WHERE name IN ${sql.in(names)}`
119 })
120 yield* sql`INSERT INTO test ${sql.insert({ name: "name1" })}`
121 const execute = SqlResolver.request(FindByName)
122 assert.deepStrictEqual(
123 yield* Effect.all({
124 one: execute("name1"),
125 two: execute("name2"),
126 three: Effect.flip(execute("name0"))
127 }, { concurrency: "unbounded" }),
128 {
129 one: [{ id: 1, name: "name1" }, { id: 101, name: "name1" }],
130 two: [{ id: 2, name: "name2" }],
131 three: new Cause.NoSuchElementError()
132 }
133 )
134 }))
135 })
136
137 describe("findById", () => {
138 it.effect("find by id", () =>
139 Effect.gen(function*() {
140 const sql = yield* seededClient
141 const FindById = SqlResolver.findById({
142 Id: Schema.Number,
143 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
144 ResultId: (result) => result.id,
145 execute: (ids) => sql`SELECT * FROM test WHERE id IN ${sql.in(ids)}`
146 })
147 const execute = SqlResolver.request(FindById)
148 assert.deepStrictEqual(
149 yield* Effect.all({
150 one: execute(1),
151 two: execute(2),
152 three: Effect.flip(execute(101))
153 }, { concurrency: "unbounded" }),
154 {
155 one: { id: 1, name: "name1" },
156 two: { id: 2, name: "name2" },
157 three: new Cause.NoSuchElementError()
158 }
159 )
160 }))
161
162 it.effect("using raw rows", () =>
163 Effect.gen(function*() {
164 const sql = yield* seededClient
165 const FindById = SqlResolver.findById({
166 Id: Schema.Number,
167 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
168 ResultId: (_, result: any) => result.id,
169 execute: (ids) => sql`SELECT * FROM test WHERE id IN ${sql.in(ids)}`
170 })
171 const execute = SqlResolver.request(FindById)
172 assert.deepStrictEqual(
173 yield* Effect.all({
174 one: execute(1),
175 two: execute(2),
176 three: Effect.flip(execute(101))
177 }, { concurrency: "unbounded" }),
178 {
179 one: { id: 1, name: "name1" },
180 two: { id: 2, name: "name2" },
181 three: new Cause.NoSuchElementError()
182 }
183 )
184 }))
185 })
186
187 describe("void", () => {
188 it.effect("keeps requests outside a transaction out of its batch", () =>
189 Effect.gen(function*() {
190 const batches: Array<Array<number>> = []
191 const sql = yield* makeClient
192 const other = yield* makeClient
193 yield* sql`CREATE TABLE writes (id INTEGER PRIMARY KEY)`
194 const insert = SqlResolver.request(SqlResolver.void({
195 Request: Schema.Number,
196 execute: (ids) => {
197 batches.push(ids)
198 return sql`INSERT INTO writes ${sql.insert(Arr.map(ids, (id) => ({ id })))}`
199 }
200 }))
201 yield* Effect.all([
202 Effect.exit(sql.withTransaction(
203 Effect.andThen(
204 Effect.all([insert(1), insert(3)], { concurrency: "unbounded" }),
205 Effect.fail("rollback")
206 )
207 )),
208 insert(2)
209 ], { concurrency: "unbounded" }).pipe(Effect.provideService(SqlClient.SqlClient, other))
210 assert.deepStrictEqual(batches, [[1, 3], [2]])
211 assert.deepStrictEqual(yield* sql`SELECT * FROM writes`, [{ id: 2 }])
212 }))
213
214 it.effect("keeps requests in another client's transaction out of its batch", () =>
215 Effect.gen(function*() {
216 const batches: Array<Array<number>> = []
217 const sql = yield* makeClient
218 const other = yield* makeClient
219 yield* sql`CREATE TABLE writes (id INTEGER PRIMARY KEY)`
220 const insert = SqlResolver.request(SqlResolver.void({
221 Request: Schema.Number,
222 execute: (ids) => {
223 batches.push(ids)
224 return sql`INSERT INTO writes ${sql.insert(Arr.map(ids, (id) => ({ id })))}`
225 }
226 }))
227 yield* other.withTransaction(Effect.all([
228 Effect.exit(sql.withTransaction(Effect.andThen(insert(1), Effect.fail("rollback")))).pipe(
229 Effect.provideService(SqlClient.SqlClient, other)
230 ),
231 insert(2)
232 ], { concurrency: "unbounded" }))
233 assert.deepStrictEqual(batches, [[1], [2]])
234 assert.deepStrictEqual(yield* sql`SELECT * FROM writes`, [{ id: 2 }])
235 }))
236
237 it.effect("keeps requests without the transaction service out of its batch", () =>
238 Effect.gen(function*() {
239 const batches: Array<Array<number>> = []
240 const sql = yield* makeClient
241 yield* sql`CREATE TABLE writes (id INTEGER PRIMARY KEY)`
242 const insert = SqlResolver.request(SqlResolver.void({
243 Request: Schema.Number,
244 execute: (ids) => {
245 batches.push(ids)
246 return sql`INSERT INTO writes ${sql.insert(Arr.map(ids, (id) => ({ id })))}`
247 }
248 }))
249 let outside: Fiber.Fiber<void, unknown> | undefined
250 yield* Effect.exit(sql.withTransaction(Effect.gen(function*() {
251 outside = yield* Effect.forkChild(
252 insert(2).pipe(
253 Effect.updateContext((context: Context.Context<never>) => Context.omit(sql.transactionService)(context))
254 )
255 )
256 yield* insert(1)
257 return yield* Effect.fail("rollback")
258 })))
259 yield* Fiber.join(outside!)
260 assert.deepStrictEqual(batches, [[1], [2]])
261 assert.deepStrictEqual(yield* sql`SELECT * FROM writes`, [{ id: 2 }])
262 }))
263 })
264 })