@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 163 lines 5.9 KB
Raw
1 import { assert, describe, it } from "@effect/vitest"
2 import { Deferred, Effect, Exit, Fiber, Option } from "effect"
3 import { Reactivity } from "effect/reactivity"
4 import { TestClock } from "effect/testing"
5 import { vi } from "vitest"
6
7 const state = vi.hoisted(() => ({ vfsCloseCalls: 0 }))
8
9 vi.mock("@effect/wa-sqlite/dist/wa-sqlite.mjs", () => ({ default: async () => ({}) }))
10 vi.mock("@effect/wa-sqlite/src/examples/AccessHandlePoolVFS.js", () => ({
11 AccessHandlePoolVFS: {
12 create: async () => ({
13 close: async () => {
14 state.vfsCloseCalls++
15 }
16 })
17 }
18 }))
19 vi.mock("@effect/wa-sqlite", () => ({
20 SQLITE_ROW: 100,
21 Factory: () => ({
22 bind_collection() {},
23 close() {},
24 column_names: (statement: { readonly columns: ReadonlyArray<string> }) => statement.columns,
25 open_v2: () => 1,
26 row: (statement: { readonly index: number; readonly rows: ReadonlyArray<ReadonlyArray<number>> }) =>
27 statement.rows[statement.index],
28 *statements(_db: number, sql: string) {
29 if (sql !== "SELECT 1 AS first; SELECT 2 AS second, 3 AS third") {
30 throw new Error(`Unexpected SQL: ${sql}`)
31 }
32 yield { columns: ["first"], index: -1, rows: [[1]] }
33 yield { columns: ["second", "third"], index: -1, rows: [[2, 3]] }
34 },
35 step(statement: { index: number; readonly rows: ReadonlyArray<ReadonlyArray<number>> }) {
36 return ++statement.index < statement.rows.length ? 100 : 101
37 },
38 vfs_register() {}
39 })
40 }))
41
42 import { OpfsWorker, SqliteClient } from "@effect/sql-sqlite-wasm"
43
44 class FakePort extends EventTarget {
45 close() {}
46
47 postMessage(message: ReadonlyArray<unknown>): void {
48 if (message[0] === "ready") {
49 queueMicrotask(() => this.dispatchEvent(new MessageEvent("message", { data: ["close"] })))
50 }
51 }
52 }
53
54 class FakeWorker extends EventTarget {
55 onerror: unknown = null
56
57 constructor(readonly queryPosted: Deferred.Deferred<void>) {
58 super()
59 }
60
61 override addEventListener(
62 type: string,
63 listener: EventListenerOrEventListenerObject | null,
64 options?: unknown
65 ): void {
66 super.addEventListener(type, listener, options as boolean)
67 if (type === "message") {
68 queueMicrotask(() => this.dispatchEvent(new MessageEvent("message", { data: ["ready"] })))
69 }
70 }
71
72 postMessage(message: ReadonlyArray<unknown>): void {
73 if (typeof message[0] === "number") {
74 Effect.runFork(Deferred.succeed(this.queryPosted, undefined))
75 }
76 }
77 }
78
79 // A MessagePort only delivers queued messages once `start()` is called.
80 class GatedPort extends EventTarget {
81 private queued: Array<ReadonlyArray<unknown>> = []
82 private started = false
83
84 start(): void {
85 this.started = true
86 for (const data of this.queued.splice(0)) {
87 this.dispatchEvent(new MessageEvent("message", { data }))
88 }
89 }
90
91 deliver(data: ReadonlyArray<unknown>): void {
92 if (this.started) this.dispatchEvent(new MessageEvent("message", { data }))
93 else this.queued.push(data)
94 }
95
96 postMessage(): void {}
97 close(): void {}
98 }
99
100 const settled = Effect.fnUntraced(function*<A, E>(effect: Effect.Effect<A, E>) {
101 const fiber = yield* effect.pipe(Effect.exit, Effect.timeoutOption("100 millis"), Effect.forkChild)
102 yield* TestClock.adjust("100 millis")
103 return yield* Fiber.join(fiber)
104 })
105
106 describe("Client", () => {
107 it.effect("should work", () => Effect.void)
108
109 it.effect("closes the OPFS VFS when the worker loop closes", () =>
110 Effect.gen(function*() {
111 yield* OpfsWorker.run({ port: new FakePort(), dbName: "test.db" })
112 assert.strictEqual(state.vfsCloseCalls, 1)
113 }))
114
115 it.effect("keeps columns scoped to each statement", () =>
116 Effect.gen(function*() {
117 const channel = new MessageChannel()
118 yield* Effect.addFinalizer(() => Effect.sync(() => channel.port2.close()))
119 yield* Effect.forkChild(OpfsWorker.run({ port: channel.port1, dbName: "test.db" }))
120 const sql = yield* SqliteClient.make({ worker: Effect.succeed(channel.port2) })
121
122 const rows = yield* sql`SELECT 1 AS first; SELECT 2 AS second, 3 AS third`
123
124 assert.deepStrictEqual(rows, [{ first: 1 }, { second: 2, third: 3 }])
125 }).pipe(Effect.provide(Reactivity.layer)))
126
127 it.effect("settles an in-flight query when the worker errors and reconnects", () =>
128 Effect.gen(function*() {
129 const queryPosted = yield* Deferred.make<void>()
130 const worker = new FakeWorker(queryPosted)
131 const sql = yield* SqliteClient.make({ worker: Effect.succeed(worker as unknown as Worker) })
132 const fiber = yield* Effect.forkChild(sql`SELECT 1`)
133
134 yield* Deferred.await(queryPosted)
135 worker.dispatchEvent(new Event("error"))
136
137 const joinFiber = yield* Fiber.join(fiber).pipe(Effect.exit, Effect.timeoutOption("100 millis"), Effect.forkChild)
138 yield* TestClock.adjust("100 millis")
139 const result = yield* Fiber.join(joinFiber)
140 assert(Option.isSome(result), "the request remained pending after worker replacement")
141 assert(Exit.isFailure(result.value))
142 }).pipe(Effect.provide(Reactivity.layer)))
143
144 it.effect("starts a MessagePort transport so the ready message arrives", () =>
145 Effect.gen(function*() {
146 const port = new GatedPort()
147 port.deliver(["ready", undefined, undefined])
148 const fiber = yield* Effect.forkChild(SqliteClient.make({ worker: Effect.succeed(port as unknown as Worker) }))
149 const result = yield* settled(Fiber.join(fiber))
150 assert(Option.isSome(result), "the ready message was never delivered")
151 assert(Exit.isSuccess(result.value))
152 }).pipe(Effect.provide(Reactivity.layer)))
153
154 it.effect("starts a MessagePort port so worker requests are consumed", () =>
155 Effect.gen(function*() {
156 const port = new GatedPort()
157 port.deliver(["close"])
158 const fiber = yield* Effect.forkChild(OpfsWorker.run({ port, dbName: "test.db" }))
159 const result = yield* settled(Fiber.join(fiber))
160 assert(Option.isSome(result), "the queued request was never consumed")
161 assert(Exit.isSuccess(result.value))
162 }))
163 })