Open History to see the last commit
1import { assert, describe, it } from "@effect/vitest"
2import { Effect, Layer, Schema } from "effect"
3import * as PersistedCacheTest from "effect-test/persistence/PersistedCacheTest"
4import * as PersistedQueueSqlTest from "effect-test/persistence/PersistedQueueSqlTest"
5import * as PersistedQueueTest from "effect-test/persistence/PersistedQueueTest"
6import * as SqlCleanupTest from "effect-test/persistence/SqlCleanupTest"
7import * as Arr from "effect/Array"
8import { PersistedQueue, Persistence } from "effect/persistence"
9import { SqlClient } from "effect/sql"
10import { TestClock } from "effect/testing"
11import { MysqlContainer } from "./utils.ts"
12
13it.layer(MysqlContainer.layerClient, { timeout: "90 seconds" })("Persistence", (it) => {
14 PersistedCacheTest.suiteWith("sql-mysql2-multi", Persistence.layerSqlMultiTable, it)
15
16 PersistedQueueTest.suiteWith("sql-mysql2", PersistedQueue.layerStoreSql(), it)
17
18 PersistedQueueSqlTest.suiteWith(it)
19
20 // elements are stored in a MEDIUMTEXT column, so payloads must survive the
21 // 64KB TEXT limit
22 it.effect("round-trips queue payloads larger than 64KB", () =>
23 Effect.gen(function*() {
24 const store = yield* PersistedQueue.makeStoreSql({
25 tableName: "effect_queue_large_payload",
26 pollInterval: "10 millis"
27 })
28 const factory = yield* PersistedQueue.makeFactory.pipe(
29 Effect.provideService(PersistedQueue.PersistedQueueStore, store)
30 )
31 const queue = yield* factory.make({ name: "large-payload", schema: Schema.String })
32
33 const payload = "x".repeat(200_000)
34 yield* queue.offer(payload)
35 const value = yield* queue.take(Effect.succeed)
36 assert.strictEqual(value, payload)
37 }).pipe(TestClock.withLive), { timeout: 30000 })
38
39 describe("single-table persistence", { concurrent: false }, () => {
40 PersistedCacheTest.suiteWith("sql-mysql2-single", Persistence.layerSql, it)
41
42 it.effect("deletes expired entries in batches", () =>
43 Effect.gen(function*() {
44 const sql = (yield* SqlClient.SqlClient).withoutTransforms()
45 const table = sql("effect_persistence")
46 const expiredCount = sql<{ readonly count: number }>`
47 SELECT COUNT(*) AS count FROM ${table} WHERE store_id = 'expired'
48 `.pipe(Effect.map((rows) => Number(rows[0].count)))
49 // Reset the table left by the single-table cache suite so cleanup builds its own schema and index.
50 yield* sql`DROP TABLE IF EXISTS ${table}`
51 yield* sql`
52 CREATE TABLE ${table} (
53 store_id VARCHAR(191) NOT NULL,
54 id VARCHAR(191) NOT NULL,
55 value TEXT NOT NULL,
56 expires BIGINT,
57 PRIMARY KEY (store_id, id)
58 )
59 `
60
61 const entries = Array.from({ length: SqlCleanupTest.expiredEntryCount }, (_, i) => ({
62 store_id: "expired",
63 id: String(i),
64 value: "{}",
65 expires: SqlCleanupTest.expiredAtEpoch
66 }))
67 assert(Arr.isArrayNonEmpty(entries))
68 yield* sql`INSERT INTO ${table} ${sql.insert(entries)}`.unprepared
69 yield* sql`
70 INSERT INTO ${table} (store_id, id, value, expires)
71 VALUES ('live', 'live', '{}', NULL), ('live', 'future', '{}', ${SqlCleanupTest.futureExpiresAt})
72 `
73
74 yield* Layer.build(Persistence.layerBackingSql).pipe(TestClock.withLive)
75
76 const expired = yield* SqlCleanupTest.waitForCount(expiredCount, (count) => count === 0)
77 assert.strictEqual(expired, 0)
78 const live = yield* sql<{ readonly count: number }>`
79 SELECT COUNT(*) AS count FROM ${table} WHERE store_id = 'live'
80 `
81 assert.strictEqual(Number(live[0].count), 2)
82
83 const indexes = yield* sql<{ readonly count: number }>`
84 SELECT COUNT(*) AS count FROM information_schema.statistics
85 WHERE table_schema = DATABASE()
86 AND table_name = 'effect_persistence'
87 AND index_name = 'effect_persistence_expires_idx'
88 `
89 assert.strictEqual(Number(indexes[0].count), 1)
90 }), { timeout: SqlCleanupTest.testTimeout })
91 })
92})