The best way to control Claude Code, Codex and more from any computer or phone

main
ts 252 lines 10.4 KB
Raw
1 import { NodeFileSystem } from "@effect/platform-node"
2 import { SqliteClient } from "@effect/sql-sqlite-node"
3 import { assert, expect, it } from "@effect/vitest"
4 import { Duration, Effect, FileSystem, Layer } from "effect"
5 import * as PersistedQueueSqlTest from "effect-test/persistence/PersistedQueueSqlTest"
6 import * as PersistedQueueTest from "effect-test/persistence/PersistedQueueTest"
7 import * as SqlCleanupTest from "effect-test/persistence/SqlCleanupTest"
8 import * as Arr from "effect/Array"
9 import { PersistedQueue, Persistence } from "effect/persistence"
10 import { Reactivity } from "effect/reactivity"
11 import * as SqlClient from "effect/sql/SqlClient"
12 import { TestClock } from "effect/testing"
13
14 const ClientLayer = Effect.gen(function*() {
15 const fs = yield* FileSystem.FileSystem
16 const dir = yield* fs.makeTempDirectoryScoped()
17 return SqliteClient.layer({
18 filename: dir + "/test.db"
19 })
20 }).pipe(
21 Layer.unwrap,
22 Layer.provide([NodeFileSystem.layer, Reactivity.layer])
23 )
24
25 const testLayer = (layer: Layer.Layer<Persistence.BackingPersistence, never, SqlClient.SqlClient>) =>
26 layer.pipe(Layer.provideMerge(ClientLayer))
27
28 const suite = (
29 name: string,
30 layer: Layer.Layer<Persistence.BackingPersistence, never, SqlClient.SqlClient>,
31 options: {
32 /**
33 * A crafted `getMany` key which, if request keys are interpolated into SQL
34 * without parameterization, escapes the `IN` list and
35 * reads the `sqli_victim` store's entries from the `sqli_attacker` store.
36 */
37 readonly injectionProbe: string
38 }
39 ) =>
40 it.layer(testLayer(layer))(`Persistence (${name})`, (it) => {
41 it.effect("set + get", () =>
42 Effect.gen(function*() {
43 const persistence = yield* Persistence.BackingPersistence
44 const store = yield* persistence.make("test_store")
45 yield* store.set("key1", { name: "Alice" }, undefined)
46 const value = yield* store.get("key1")
47 expect(value).toEqual({ name: "Alice" })
48
49 // test upsert
50 yield* store.set("key1", { name: "Alice" }, undefined)
51 }))
52
53 it.effect("setMany + getMany", () =>
54 Effect.gen(function*() {
55 const persistence = yield* Persistence.BackingPersistence
56 const store = yield* persistence.make("test_store_2")
57 yield* store.setMany([
58 ["key1", { name: "Alice" }, undefined],
59 ["key2", { name: "Bob" }, undefined],
60 ["key3", { name: "Charlie" }, undefined]
61 ])
62 const values = yield* store.getMany(["key1", "key2", "key3", "key4"])
63 expect(values).toEqual([
64 { name: "Alice" },
65 { name: "Bob" },
66 { name: "Charlie" },
67 undefined
68 ])
69 }))
70
71 it.effect("getMany with duplicate keys", () =>
72 Effect.gen(function*() {
73 const persistence = yield* Persistence.BackingPersistence
74 const store = yield* persistence.make("test_store_duplicate_keys")
75 yield* store.set("key", { value: 1 }, undefined)
76
77 expect(yield* store.getMany(["key", "key"])).toEqual([{ value: 1 }, { value: 1 }])
78 }))
79
80 it.effect("remove", () =>
81 Effect.gen(function*() {
82 const persistence = yield* Persistence.BackingPersistence
83 const store = yield* persistence.make("test_store_2")
84 yield* store.setMany([
85 ["key1", { name: "Alice" }, undefined],
86 ["key2", { name: "Bob" }, undefined],
87 ["key3", { name: "Charlie" }, undefined]
88 ])
89 yield* store.remove("key2")
90 const valuesAfter = yield* store.getMany(["key1", "key2", "key3"])
91 expect(valuesAfter).toEqual([{ name: "Alice" }, undefined, { name: "Charlie" }])
92 }))
93
94 it.effect("expires", () =>
95 Effect.gen(function*() {
96 const persistence = yield* Persistence.BackingPersistence
97 const store = yield* persistence.make("test_store_3")
98 yield* store.setMany([
99 ["key1", { name: "Alice" }, undefined],
100 ["key2", { name: "Bob" }, undefined],
101 ["key3", { name: "Charlie" }, Duration.seconds(10)]
102 ])
103 let values = yield* store.getMany(["key1", "key2", "key3"])
104 expect(values).toEqual([{ name: "Alice" }, { name: "Bob" }, { name: "Charlie" }])
105 yield* TestClock.adjust(Duration.seconds(5))
106 values = yield* store.getMany(["key1", "key2", "key3"])
107 expect(values).toEqual([{ name: "Alice" }, { name: "Bob" }, { name: "Charlie" }])
108 yield* TestClock.adjust(Duration.seconds(5))
109 values = yield* store.getMany(["key1", "key2", "key3"])
110 expect(values).toEqual([{ name: "Alice" }, { name: "Bob" }, undefined])
111 }))
112
113 it.effect("reused get expires", () =>
114 Effect.gen(function*() {
115 const persistence = yield* Persistence.BackingPersistence
116 const store = yield* persistence.make("test_store_reused_get")
117 yield* store.set("key", { name: "Alice" }, Duration.seconds(10))
118 const get = store.get("key")
119
120 assert.deepStrictEqual(yield* get, { name: "Alice" })
121 yield* TestClock.adjust(Duration.seconds(10))
122 assert.strictEqual(yield* get, undefined)
123 }))
124
125 it.effect("reused getMany expires", () =>
126 Effect.gen(function*() {
127 const persistence = yield* Persistence.BackingPersistence
128 const store = yield* persistence.make("test_store_reused_get_many")
129 yield* store.set("key", { name: "Alice" }, Duration.seconds(10))
130 const getMany = store.getMany(["key"])
131
132 assert.deepStrictEqual(yield* getMany, [{ name: "Alice" }])
133 yield* TestClock.adjust(Duration.seconds(10))
134 assert.deepStrictEqual(yield* getMany, [undefined])
135 }))
136
137 it.effect("isolation between stores", () =>
138 Effect.gen(function*() {
139 const persistence = yield* Persistence.BackingPersistence
140 const storeA = yield* persistence.make("test_store_a")
141 const storeB = yield* persistence.make("test_store_b")
142
143 yield* storeA.set("shared-key", { name: "Alice" }, undefined)
144 yield* storeB.set("shared-key", { name: "Bob" }, undefined)
145
146 expect(yield* storeA.get("shared-key")).toEqual({ name: "Alice" })
147 expect(yield* storeB.get("shared-key")).toEqual({ name: "Bob" })
148
149 yield* storeA.clear
150
151 expect(yield* storeA.get("shared-key")).toEqual(undefined)
152 expect(yield* storeB.get("shared-key")).toEqual({ name: "Bob" })
153 }))
154
155 it.effect("getMany treats keys containing single quotes as data", () =>
156 Effect.gen(function*() {
157 const persistence = yield* Persistence.BackingPersistence
158 const store = yield* persistence.make("test_store_quotes")
159 yield* store.set("it's-a-key", { name: "Alice" }, undefined)
160
161 // Keys must be bound as parameters, not
162 // interpolated into the `IN` list as raw string literals.
163 const values = yield* store.getMany(["it's-a-key", "missing'key"])
164 expect(values).toEqual([{ name: "Alice" }, undefined])
165 }))
166
167 it.effect("getMany preserves store isolation for crafted keys", () =>
168 Effect.gen(function*() {
169 const persistence = yield* Persistence.BackingPersistence
170 const victim = yield* persistence.make("sqli_victim")
171 yield* victim.set("secret", { secret: "victim-data" }, undefined)
172
173 const attacker = yield* persistence.make("sqli_attacker")
174 yield* attacker.set("innocent", { name: "Mallory" }, undefined)
175
176 // The probe is a no-op key when keys are parameterized. If keys are
177 // interpolated into raw SQL it escapes the `IN` list and exfiltrates
178 // the victim store's `secret` entry into the attacker's results.
179 const values = yield* attacker.getMany(["secret", options.injectionProbe])
180 expect(values).toEqual([undefined, undefined])
181 expect(yield* attacker.get("secret")).toEqual(undefined)
182 }))
183 })
184
185 suite("table-per-store", Persistence.layerBackingSqlMultiTable, {
186 // Expands to `... WHERE id IN ('secret', '') UNION SELECT id, value FROM
187 // effect_persistence_sqli_victim WHERE ('1'='1') AND (expires IS NULL OR
188 // expires > ?)`, appending every victim row to the attacker's result set.
189 injectionProbe: `') UNION SELECT id, value FROM effect_persistence_sqli_victim WHERE ('1'='1`
190 })
191 suite("single-table", Persistence.layerBackingSql, {
192 // Expands to `... WHERE store_id = 'sqli_attacker' AND id IN ('secret', '')
193 // OR store_id='sqli_victim' AND ('1'='1') AND (expires IS NULL OR expires >
194 // ?)`, bypassing the store isolation filter.
195 injectionProbe: `') OR store_id='sqli_victim' AND ('1'='1`
196 })
197
198 PersistedQueueTest.suite(
199 "sql-sqlite-node",
200 PersistedQueue.layerStoreSql().pipe(Layer.provide(ClientLayer))
201 )
202
203 it.layer(ClientLayer)((it) => PersistedQueueSqlTest.suiteWith(it))
204
205 it.layer(ClientLayer)("Persistence SQL cleanup", (it) => {
206 it.effect("deletes expired entries in batches", () =>
207 Effect.gen(function*() {
208 const sql = (yield* SqlClient.SqlClient).withoutTransforms()
209 const table = sql("effect_persistence")
210 const expiredCount = sql<{ readonly count: number }>`
211 SELECT COUNT(*) AS count FROM ${table} WHERE store_id = 'expired'
212 `.pipe(Effect.map((rows) => rows[0].count))
213 yield* sql`
214 CREATE TABLE ${table} (
215 store_id TEXT NOT NULL,
216 id TEXT NOT NULL,
217 value TEXT NOT NULL,
218 expires INTEGER,
219 PRIMARY KEY (store_id, id)
220 )
221 `
222
223 const entries = Array.from({ length: SqlCleanupTest.expiredEntryCount }, (_, i) => ({
224 store_id: "expired",
225 id: String(i),
226 value: "{}",
227 expires: SqlCleanupTest.expiredAtEpoch
228 }))
229 assert(Arr.isArrayNonEmpty(entries))
230 yield* sql`INSERT INTO ${table} ${sql.insert(entries)}`.unprepared
231 yield* sql`
232 INSERT INTO ${table} (store_id, id, value, expires)
233 VALUES ('live', 'live', '{}', NULL), ('live', 'future', '{}', ${SqlCleanupTest.futureExpiresAt})
234 `
235
236 yield* Layer.build(Persistence.layerBackingSql).pipe(TestClock.withLive)
237
238 const expired = yield* SqlCleanupTest.waitForCount(expiredCount, (count) => count === 0)
239 assert.strictEqual(expired, 0)
240 const live = yield* sql<{ readonly count: number }>`
241 SELECT COUNT(*) AS count FROM ${table} WHERE store_id = 'live'
242 `
243 assert.strictEqual(live[0].count, 2)
244
245 const indexes = yield* sql<{ readonly count: number }>`
246 SELECT COUNT(*) AS count FROM sqlite_master
247 WHERE type = 'index'
248 AND name = 'effect_persistence_expires_idx'
249 `
250 assert.strictEqual(indexes[0].count, 1)
251 }), { timeout: SqlCleanupTest.testTimeout })
252 })