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