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

main
ts 249 lines 10.1 KB
Raw
1 import type { D1Result } from "@cloudflare/workers-types"
2 import { D1Client } from "@effect/sql-d1"
3 import { assert, describe, it } from "@effect/vitest"
4 import { Cause, Effect, Tracer } from "effect"
5 import * as Reactivity from "effect/reactivity/Reactivity"
6 import { Statement } from "effect/sql"
7 import { D1Miniflare } from "./utils.ts"
8
9 // Each test starts its own Miniflare instance. Concurrent startups compete for
10 // CPU and share one running timeout, so run them one at a time.
11 describe("Client", { concurrent: false, timeout: 30_000 }, () => {
12 it.effect("raw preserves the native result envelope", () =>
13 Effect.gen(function*() {
14 const sql = yield* D1Client.D1Client
15 yield* sql`CREATE TABLE raw_test (id INTEGER PRIMARY KEY, name TEXT)`
16 const raw = (yield* sql`INSERT INTO raw_test (name) VALUES (${"effect"})`.raw) as D1Result
17 assert.strictEqual(raw.success, true)
18 assert.deepStrictEqual(raw.results, [])
19 assert.strictEqual(raw.meta.changes, 1)
20 assert.strictEqual(raw.meta.last_row_id, 1)
21 }).pipe(Effect.provide(D1Miniflare.layerClient)))
22
23 it.effect("classifies native errors without stable sqlite codes as UnknownError", () =>
24 Effect.gen(function*() {
25 const failingDb = {
26 prepare: () => ({
27 bind: () => ({
28 all: async () => {
29 throw new Error("boom")
30 }
31 })
32 })
33 } as any
34
35 const client = yield* D1Client.make({ db: failingDb })
36 const error = yield* Effect.flip(client`SELECT 1`)
37 assert.strictEqual(error.reason._tag, "UnknownError")
38 }).pipe(
39 Effect.scoped,
40 Effect.provide(Reactivity.layer)
41 ))
42
43 it.effect("should handle queries without transactions", () =>
44 Effect.gen(function*() {
45 const sql = yield* D1Client.D1Client
46 yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)`
47 yield* sql`INSERT INTO test (name) VALUES ('hello')`
48 let rows = yield* sql`SELECT * FROM test`
49 assert.deepStrictEqual(rows, [{ id: 1, name: "hello" }])
50 yield* sql`INSERT INTO test (name) VALUES ('world')`
51 rows = yield* sql`SELECT * FROM test`
52 assert.deepStrictEqual(rows, [
53 { id: 1, name: "hello" },
54 { id: 2, name: "world" }
55 ])
56 }).pipe(Effect.provide(D1Miniflare.layerClient)))
57
58 it.effect("should handle queries with params without transactions", () =>
59 Effect.gen(function*() {
60 const sql = yield* D1Client.D1Client
61 yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)`
62 yield* sql`INSERT INTO test ${sql.insert({ name: "hello" })}`
63 const rows = yield* sql`SELECT * FROM test WHERE name = ${"hello"}`
64 assert.deepStrictEqual(rows, [{ id: 1, name: "hello" }])
65 }).pipe(Effect.provide(D1Miniflare.layerClient)))
66
67 it.effect("should execute statements in a batch", () =>
68 Effect.gen(function*() {
69 const sql = yield* D1Client.D1Client
70 yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)`
71
72 const results: readonly [
73 ReadonlyArray<{ id: number; name: string }>,
74 ReadonlyArray<{ id: number; name: string }>,
75 ReadonlyArray<{ count: number }>
76 ] = yield* sql.batch(
77 [
78 sql<{ id: number; name: string }>`INSERT INTO test (name) VALUES (${"hello"}) RETURNING *`,
79 sql<{ id: number; name: string }>`INSERT INTO test (name) VALUES (${"world"}) RETURNING *`,
80 sql<{ count: number }>`SELECT COUNT(*) AS count FROM test`
81 ] as const
82 )
83
84 assert.deepStrictEqual(results, [
85 [{ id: 1, name: "hello" }],
86 [{ id: 2, name: "world" }],
87 [{ count: 2 }]
88 ])
89 }).pipe(Effect.provide(D1Miniflare.layerClient)))
90
91 it.effect("should apply result transforms to batch results", () =>
92 Effect.gen(function*() {
93 const sql = yield* D1Client.D1Client
94 yield* sql`CREATE TABLE test (first_name TEXT, "firstName" TEXT)`
95 yield* sql`INSERT INTO test (first_name, "firstName") VALUES ('John', 'Jane')`
96
97 yield* Effect.gen(function*() {
98 const transformed = yield* D1Client.make({
99 db: sql.config.db,
100 transformQueryNames: (name) => name === "firstName" ? "first_name" : name,
101 transformResultNames: (name) => name === "first_name" ? "firstName" : name
102 })
103 const [rows] = yield* transformed.batch([
104 transformed<{ firstName: string }>`SELECT ${transformed("firstName")} FROM test`
105 ])
106 assert.deepStrictEqual(rows, [{ firstName: "John" }])
107
108 const withoutTransforms = transformed.withoutTransforms()
109 const [rawRows] = yield* withoutTransforms.batch([
110 withoutTransforms<{ firstName: string }>`SELECT ${withoutTransforms("firstName")} FROM test`
111 ])
112 assert.deepStrictEqual(rawRows, [{ firstName: "Jane" }])
113
114 const [rawRowsFromTransformedBatch] = yield* transformed.batch([
115 withoutTransforms<{ first_name: string }>`SELECT ${withoutTransforms("first_name")} FROM test`
116 ])
117 assert.deepStrictEqual(rawRowsFromTransformedBatch, [{ first_name: "John" }])
118
119 const [transformedRowsFromRawBatch] = yield* withoutTransforms.batch([
120 transformed<{ firstName: string }>`SELECT ${transformed("firstName")} FROM test`
121 ])
122 assert.deepStrictEqual(transformedRowsFromRawBatch, [{ firstName: "John" }])
123 }).pipe(
124 Effect.scoped,
125 Effect.provide(Reactivity.layer)
126 )
127 }).pipe(Effect.provide(D1Miniflare.layerClient)))
128
129 it.effect("should disable query-only transforms", () =>
130 Effect.gen(function*() {
131 const sql = yield* D1Client.D1Client
132 yield* sql`CREATE TABLE test (first_name TEXT, "firstName" TEXT)`
133 yield* sql`INSERT INTO test (first_name, "firstName") VALUES ('John', 'Jane')`
134
135 yield* Effect.gen(function*() {
136 const transformed = yield* D1Client.make({
137 db: sql.config.db,
138 transformQueryNames: (name) => name === "firstName" ? "first_name" : name
139 })
140 const [transformedRows] = yield* transformed.batch([
141 transformed<{ first_name: string }>`SELECT ${transformed("firstName")} FROM test`
142 ])
143 assert.deepStrictEqual(transformedRows, [{ first_name: "John" }])
144
145 const withoutTransforms = transformed.withoutTransforms()
146 const [rawRows] = yield* withoutTransforms.batch([
147 withoutTransforms<{ firstName: string }>`SELECT ${withoutTransforms("firstName")} FROM test`
148 ])
149 assert.deepStrictEqual(rawRows, [{ firstName: "Jane" }])
150 }).pipe(
151 Effect.scoped,
152 Effect.provide(Reactivity.layer)
153 )
154 }).pipe(Effect.provide(D1Miniflare.layerClient)))
155
156 it.effect("should roll back a failed batch", () =>
157 Effect.gen(function*() {
158 const sql = yield* D1Client.D1Client
159 yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT UNIQUE)`
160
161 const error = yield* sql.batch([
162 sql`INSERT INTO test (name) VALUES (${"duplicate"})`,
163 sql`INSERT INTO test (name) VALUES (${"duplicate"})`
164 ]).pipe(Effect.flip)
165
166 assert.strictEqual(error.reason._tag, "UnknownError")
167 assert.strictEqual(error.reason.operation, "execute")
168 const rows = yield* sql`SELECT * FROM test`
169 assert.deepStrictEqual(rows, [])
170 }).pipe(Effect.provide(D1Miniflare.layerClient)))
171
172 it.effect("should support an empty batch", () =>
173 Effect.gen(function*() {
174 const sql = yield* D1Client.D1Client
175 const results: readonly [] = yield* sql.batch([])
176 assert.deepStrictEqual(results, [])
177 }).pipe(Effect.provide(D1Miniflare.layerClient)))
178
179 it.effect("should apply statement transformers in a batch", () =>
180 Effect.gen(function*() {
181 const sql = yield* D1Client.D1Client
182 const queries: Array<string> = []
183
184 const results = yield* sql.batch([
185 sql`SELECT ${1} AS value`,
186 sql`SELECT ${2} AS value`
187 ]).pipe(
188 Effect.provideService(Statement.CurrentTransformer, (statement, sql) =>
189 Effect.sync(() => {
190 queries.push(statement.compile()[0])
191 }).pipe(Effect.as(sql`SELECT ${3} AS value`)))
192 )
193
194 assert.deepStrictEqual(queries, ["SELECT ? AS value", "SELECT ? AS value"])
195 assert.deepStrictEqual(results, [[{ value: 3 }], [{ value: 3 }]])
196 }).pipe(Effect.provide(D1Miniflare.layerClient)))
197
198 it.effect("should defect on transactions", () =>
199 Effect.gen(function*() {
200 const sql = yield* D1Client.D1Client
201 yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)`
202 const res = yield* sql`INSERT INTO test ${sql.insert({ name: "hello" })}`.pipe(
203 sql.withTransaction,
204 Effect.sandbox,
205 Effect.flip
206 )
207 const rows = yield* sql`SELECT * FROM test`
208 assert.deepStrictEqual(rows, [])
209 assert.equal(Cause.hasDies(res), true)
210 }).pipe(Effect.provide(D1Miniflare.layerClient)))
211
212 it.effect("names batches with the configured target", () =>
213 Effect.gen(function*() {
214 const db = {
215 prepare: () => ({ bind: () => ({}) }),
216 batch: async (statements: Array<unknown>) => statements.map(() => ({ results: [] }))
217 } as any
218 const sql = yield* D1Client.make({ db, spanAttributes: { "db.namespace": "app" } })
219 const spans: Array<Tracer.Span> = []
220 const tracer = Tracer.make({
221 span: (options) => {
222 const span = new Tracer.NativeSpan(options)
223 spans.push(span)
224 return span
225 }
226 })
227 yield* sql.batch([sql`SELECT 1`, sql`SELECT 2`]).pipe(Effect.withTracer(tracer))
228 assert.deepStrictEqual(spans.map((span) => span.name), ["BATCH app"])
229 }).pipe(
230 Effect.scoped,
231 Effect.provide(Reactivity.layer)
232 ))
233
234 it.effect("should defect when batching in a transaction", () =>
235 Effect.gen(function*() {
236 const sql = yield* D1Client.D1Client
237 yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)`
238 const res = yield* sql.batch([
239 sql`INSERT INTO test ${sql.insert({ name: "hello" })}`
240 ]).pipe(
241 sql.withTransaction,
242 Effect.sandbox,
243 Effect.flip
244 )
245 const rows = yield* sql`SELECT * FROM test`
246 assert.deepStrictEqual(rows, [])
247 assert.equal(Cause.hasDies(res), true)
248 }).pipe(Effect.provide(D1Miniflare.layerClient)))
249 })