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

main
ts 184 lines 6.73 KB
Raw
1 import { D1Client } from "@effect/sql-d1"
2 import { assert, describe, it } from "@effect/vitest"
3 import { Cause, Effect } from "effect"
4 import * as Arr from "effect/Array"
5 import * as Schema from "effect/Schema"
6 import { SqlError, SqlResolver } from "effect/sql"
7 import { D1Miniflare } from "./utils.ts"
8
9 const seededClient = Effect.gen(function*() {
10 const sql = yield* D1Client.D1Client
11 yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)`
12 yield* sql`INSERT INTO test ${
13 sql.insert([
14 { id: 1, name: "name1" },
15 { id: 2, name: "name2" },
16 { id: 3, name: "name3" },
17 { id: 100, name: "name100" }
18 ])
19 }`
20 return sql
21 })
22
23 // Each test starts its own Miniflare instance. Concurrent startups compete for
24 // CPU and share one running timeout, so run them one at a time.
25 describe("Resolver", { concurrent: false, timeout: 30_000 }, () => {
26 describe("ordered", () => {
27 it.effect("insert", () =>
28 Effect.gen(function*() {
29 const batches: Array<Array<string>> = []
30 const sql = yield* seededClient
31 const Insert = SqlResolver.ordered({
32 Request: Schema.String,
33 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
34 execute: (names) => {
35 batches.push(names)
36 return sql`INSERT INTO test ${sql.insert(Arr.map(names, (name) => ({ name })))} RETURNING *`
37 }
38 })
39 const execute = SqlResolver.request(Insert)
40 assert.deepStrictEqual(
41 yield* Effect.all({
42 one: execute("one"),
43 two: SqlResolver.request("two", Insert)
44 }, { concurrency: "unbounded" }),
45 {
46 one: { id: 101, name: "one" },
47 two: { id: 102, name: "two" }
48 }
49 )
50 assert.deepStrictEqual(batches, [["one", "two"]])
51 }).pipe(Effect.provide(D1Miniflare.layerClient)))
52
53 it.effect("result length mismatch", () =>
54 Effect.gen(function*() {
55 const batches: Array<Array<number>> = []
56 const sql = yield* seededClient
57 const Select = SqlResolver.ordered({
58 Request: Schema.Number,
59 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
60 execute: (ids) => {
61 batches.push(ids)
62 return sql`SELECT * FROM test WHERE id IN ${sql.in(ids)}`
63 }
64 })
65 const execute = SqlResolver.request(Select)
66 const error = yield* Effect.all([
67 execute(1),
68 execute(2),
69 execute(3),
70 execute(101)
71 ], { concurrency: "unbounded" }).pipe(
72 Effect.flip
73 )
74 assert(error instanceof SqlError.ResultLengthMismatch)
75 assert.strictEqual(error.actual, 3)
76 assert.strictEqual(error.expected, 4)
77 assert.deepStrictEqual(batches, [[1, 2, 3, 101]])
78 }).pipe(Effect.provide(D1Miniflare.layerClient)))
79 })
80
81 describe("grouped", () => {
82 it.effect("find by name", () =>
83 Effect.gen(function*() {
84 const sql = yield* seededClient
85 const FindByName = SqlResolver.grouped({
86 Request: Schema.String,
87 RequestGroupKey: (name) => name,
88 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
89 ResultGroupKey: (result) => result.name,
90 execute: (names) => sql`SELECT * FROM test WHERE name IN ${sql.in(names)}`
91 })
92 const execute = SqlResolver.request(FindByName)
93 yield* sql`INSERT INTO test ${sql.insert({ name: "name1" })}`
94 assert.deepStrictEqual(
95 yield* Effect.all({
96 one: execute("name1"),
97 two: execute("name2"),
98 three: Effect.flip(execute("name0"))
99 }, { concurrency: "unbounded" }),
100 {
101 one: [{ id: 1, name: "name1" }, { id: 101, name: "name1" }],
102 two: [{ id: 2, name: "name2" }],
103 three: new Cause.NoSuchElementError()
104 }
105 )
106 }).pipe(Effect.provide(D1Miniflare.layerClient)))
107
108 it.effect("using raw rows", () =>
109 Effect.gen(function*() {
110 const sql = yield* seededClient
111 const FindByName = SqlResolver.grouped({
112 Request: Schema.String,
113 RequestGroupKey: (name) => name,
114 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
115 ResultGroupKey: (_, result: any) => result.name,
116 execute: (names) => sql`SELECT * FROM test WHERE name IN ${sql.in(names)}`
117 })
118 const execute = SqlResolver.request(FindByName)
119 yield* sql`INSERT INTO test ${sql.insert({ name: "name1" })}`
120 assert.deepStrictEqual(
121 yield* Effect.all({
122 one: execute("name1"),
123 two: execute("name2"),
124 three: Effect.flip(execute("name0"))
125 }, { concurrency: "unbounded" }),
126 {
127 one: [{ id: 1, name: "name1" }, { id: 101, name: "name1" }],
128 two: [{ id: 2, name: "name2" }],
129 three: new Cause.NoSuchElementError()
130 }
131 )
132 }).pipe(Effect.provide(D1Miniflare.layerClient)))
133 })
134
135 describe("findById", () => {
136 it.effect("find by id", () =>
137 Effect.gen(function*() {
138 const sql = yield* seededClient
139 const FindById = SqlResolver.findById({
140 Id: Schema.Number,
141 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
142 ResultId: (result) => result.id,
143 execute: (ids) => sql`SELECT * FROM test WHERE id IN ${sql.in(ids)}`
144 })
145 const execute = SqlResolver.request(FindById)
146 assert.deepStrictEqual(
147 yield* Effect.all({
148 one: execute(1),
149 two: execute(2),
150 three: Effect.flip(execute(101))
151 }, { concurrency: "unbounded" }),
152 {
153 one: { id: 1, name: "name1" },
154 two: { id: 2, name: "name2" },
155 three: new Cause.NoSuchElementError()
156 }
157 )
158 }).pipe(Effect.provide(D1Miniflare.layerClient)))
159
160 it.effect("using raw rows", () =>
161 Effect.gen(function*() {
162 const sql = yield* seededClient
163 const FindById = SqlResolver.findById({
164 Id: Schema.Number,
165 Result: Schema.Struct({ id: Schema.Number, name: Schema.String }),
166 ResultId: (_, result: any) => result.id,
167 execute: (ids) => sql`SELECT * FROM test WHERE id IN ${sql.in(ids)}`
168 })
169 const execute = SqlResolver.request(FindById)
170 assert.deepStrictEqual(
171 yield* Effect.all({
172 one: execute(1),
173 two: execute(2),
174 three: Effect.flip(execute(101))
175 }, { concurrency: "unbounded" }),
176 {
177 one: { id: 1, name: "name1" },
178 two: { id: 2, name: "name2" },
179 three: new Cause.NoSuchElementError()
180 }
181 )
182 }).pipe(Effect.provide(D1Miniflare.layerClient)))
183 })
184 })