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, 04:45 UTC
| 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 | }) |