The best way to control Claude Code, Codex and more from any computer or phone
| 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 | }) |