import { NodeFileSystem } from "@effect/platform-node" import { SqliteClient } from "@effect/sql-sqlite-node" import { assert, describe, it } from "@effect/vitest" import { Cause, Deferred, Duration, Effect, Exit, Fiber, FileSystem, Option, References } from "effect" import { Reactivity } from "effect/reactivity" import { ConnectionError, SqlError } from "effect/sql/SqlError" import { TestClock } from "effect/testing" import { DatabaseSync } from "node:sqlite" const makeClient = Effect.gen(function*() { const fs = yield* FileSystem.FileSystem const dir = yield* fs.makeTempDirectoryScoped() return yield* SqliteClient.make({ filename: dir + "/test.db" }) }).pipe(Effect.provide([NodeFileSystem.layer, Reactivity.layer])) const makeClients = Effect.gen(function*() { const fs = yield* FileSystem.FileSystem const dir = yield* fs.makeTempDirectoryScoped() const filename = dir + "/test.db" return { client: yield* SqliteClient.make({ filename }), contender: yield* SqliteClient.make({ filename }) } }).pipe(Effect.provide([NodeFileSystem.layer, Reactivity.layer])) const makeLockedDatabase = Effect.gen(function*() { const fs = yield* FileSystem.FileSystem const dir = yield* fs.makeTempDirectoryScoped() const filename = dir + "/test.db" const lock = yield* Effect.acquireRelease( Effect.sync(() => new DatabaseSync(filename)), (db) => Effect.sync(() => db.close()) ) lock.exec("BEGIN IMMEDIATE") return { filename, unlock: () => lock.exec("ROLLBACK") } }).pipe(Effect.provide(NodeFileSystem.layer)) // node:sqlite blocks the Vitest worker; concurrent tests would share a running // timeout while waiting for each other's queries. describe("Client", { concurrent: false }, () => { it.effect("should disable query-only transforms", () => Effect.gen(function*() { const sql = yield* SqliteClient.make({ filename: ":memory:", transformQueryNames: (name) => name === "firstName" ? "first_name" : name }).pipe(Effect.provide(Reactivity.layer)) const withoutTransforms = sql.withoutTransforms() yield* sql`CREATE TABLE test (first_name TEXT, "firstName" TEXT)` yield* sql`INSERT INTO test (first_name, "firstName") VALUES ('John', 'Jane')` const select = withoutTransforms`SELECT ${withoutTransforms("firstName")} FROM test` assert.deepStrictEqual(yield* select, [{ firstName: "Jane" }]) })) it.effect("releases completed nested savepoints", () => Effect.gen(function*() { const sql = yield* makeClient yield* sql`CREATE TABLE savepoint_release (value INTEGER)` yield* sql.withTransaction(Effect.gen(function*() { for (const rollback of [false, true]) { yield* sql.withTransaction( sql`INSERT INTO savepoint_release VALUES (1)`.pipe( Effect.andThen(rollback ? Effect.fail("rollback") : Effect.void) ) ).pipe(Effect.ignore) const error = yield* sql`RELEASE SAVEPOINT effect_sql_1`.unprepared.pipe(Effect.flip) assert.strictEqual(error._tag, "SqlError") } })) assert.deepStrictEqual(yield* sql`SELECT value FROM savepoint_release`, [{ value: 1 }]) const error = yield* sql.withTransaction( sql.withTransaction(sql`INSERT INTO savepoint_release VALUES (2)`).pipe( Effect.andThen(Effect.fail("outer rollback")) ) ).pipe(Effect.flip) assert.strictEqual(error, "outer rollback") assert.deepStrictEqual(yield* sql`SELECT value FROM savepoint_release`, [{ value: 1 }]) })) it.effect("should work", () => Effect.gen(function*() { const sql = yield* makeClient let response response = yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)` assert.deepStrictEqual(response, []) response = yield* sql`INSERT INTO test (name) VALUES ('hello')` assert.deepStrictEqual(response, []) response = yield* sql`SELECT * FROM test` assert.deepStrictEqual(response, [{ id: 1, name: "hello" }]) response = yield* sql`SELECT * FROM test`.valuesUnprepared assert.deepStrictEqual(response, [[1, "hello"]]) response = yield* sql`INSERT INTO test (name) VALUES ('world')`.pipe(sql.withTransaction) assert.deepStrictEqual(response, []) response = yield* sql`SELECT * FROM test` assert.deepStrictEqual(response, [ { id: 1, name: "hello" }, { id: 2, name: "world" } ]) response = yield* sql`INSERT INTO test (name) VALUES ('unprepared')`.valuesUnprepared assert.deepStrictEqual(response, []) assert.deepStrictEqual(yield* sql`SELECT * FROM test WHERE id = 3`, [{ id: 3, name: "unprepared" }]) })) it.effect.each(["rows", "values"] as const)( "returns cached INSERT %s across count_changes OFF → ON → OFF", (mode) => Effect.gen(function*() { const sql = yield* makeClient yield* sql`CREATE TABLE count_changes (value INTEGER)` yield* sql`PRAGMA count_changes = OFF` const insert = sql`INSERT INTO count_changes VALUES (1)` const execute = mode === "values" ? insert.values : insert assert.deepStrictEqual(yield* execute, []) yield* sql`PRAGMA count_changes = ON` // Node may omit fields after recompilation; check only the row count. assert.lengthOf(yield* execute, 1) yield* sql`PRAGMA count_changes = OFF` assert.deepStrictEqual(yield* execute, []) assert.deepStrictEqual(yield* sql`SELECT COUNT(*) AS count FROM count_changes`, [{ count: 3 }]) }) ) it.effect.each(["rows", "values"] as const)( "retries %s queries after a missing table is created", (mode) => Effect.gen(function*() { const sql = yield* makeClient const select = sql`SELECT value FROM created_later` const execute: Effect.Effect, SqlError> = mode === "values" ? select.values : select const error = yield* Effect.flip(execute) assert.strictEqual(error._tag, "SqlError") yield* sql`CREATE TABLE created_later (value INTEGER)` yield* sql`INSERT INTO created_later VALUES (1)` assert.deepStrictEqual(yield* execute, mode === "values" ? [[1]] : [{ value: 1 }]) }) ) it.effect("should work with raw", () => Effect.gen(function*() { const sql = yield* makeClient let response response = yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)`.raw assert.deepStrictEqual(response, { changes: 0, lastInsertRowid: 0 }) response = yield* sql`INSERT INTO test (name) VALUES ('hello')`.raw assert.deepStrictEqual(response, { changes: 1, lastInsertRowid: 1 }) response = yield* sql`SELECT * FROM test`.raw assert.deepStrictEqual(response, [{ id: 1, name: "hello" }]) response = yield* sql`INSERT INTO test (name) VALUES ('world')`.raw.pipe(sql.withTransaction) assert.deepStrictEqual(response, { changes: 1, lastInsertRowid: 2 }) response = yield* sql`SELECT * FROM test` assert.deepStrictEqual(response, [ { id: 1, name: "hello" }, { id: 2, name: "world" } ]) })) for (const mode of ["unprepared", "valuesUnprepared"] as const) { it.effect(`captures ${mode} preparation errors`, () => Effect.gen(function*() { const sql = yield* makeClient yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY)` const statement = sql`CREATE TABLE test (id INTEGER PRIMARY KEY)` const execution = mode === "unprepared" ? Effect.as(statement.unprepared, false) : Effect.as(statement.valuesUnprepared, false) const recovered = yield* execution.pipe(Effect.catchTag("SqlError", () => Effect.succeed(true))) assert.isTrue(recovered) })) } it.effect("withTransaction", () => Effect.gen(function*() { const sql = yield* makeClient yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)` yield* sql.withTransaction(sql`INSERT INTO test (name) VALUES ('hello')`) const rows = yield* sql`SELECT * FROM test` assert.deepStrictEqual(rows, [{ id: 1, name: "hello" }]) })) it.effect("keeps a fiber that outlives its transaction out of another transaction", () => Effect.gen(function*() { const sql = yield* makeClient yield* sql`CREATE TABLE t (who TEXT)` const go = yield* Deferred.make() const done = yield* Deferred.make() const idle = yield* Deferred.make() const stale = yield* sql.withTransaction(Effect.forkChild( Effect.all([ Effect.andThen(Deferred.await(go), Effect.flip(sql`INSERT INTO t VALUES ('stale fiber')`)).pipe( Effect.ensuring(Deferred.succeed(done, undefined)) ), // On an idle connection, a stale SAVEPOINT would start a transaction and block the next BEGIN. Effect.andThen(Deferred.await(idle), Effect.flip(sql.withTransaction(Effect.void))) ]) )) const other = yield* Effect.forkChild(Effect.exit(sql.withTransaction(Effect.gen(function*() { yield* sql`INSERT INTO t VALUES ('other transaction')` yield* Deferred.succeed(go, undefined) yield* Deferred.await(done) return yield* Effect.fail("rollback") })))) yield* Fiber.join(other) yield* Deferred.succeed(idle, undefined) const errors = yield* Fiber.join(stale) for (const error of errors) { assert.deepStrictEqual( [error.reason._tag, error.reason.message, error.isRetryable], ["UnknownError", "SqlClient: the transaction has already ended", false] ) } assert.deepStrictEqual(yield* sql`SELECT who FROM t`, []) // The connection is still usable for new transactions. yield* sql.withTransaction(sql`INSERT INTO t VALUES ('after')`) assert.deepStrictEqual(yield* sql`SELECT who FROM t`, [{ who: "after" }]) })) it.effect.each(["ABORT", "ROLLBACK", "nested ROLLBACK"] as const)( "preserves a typed constraint failure and reuses the connection after %s", (mode) => Effect.gen(function*() { const sql = yield* SqliteClient.make({ filename: ":memory:" }).pipe(Effect.provide(Reactivity.layer)) yield* sql`CREATE TABLE items (id INTEGER PRIMARY KEY)` yield* sql`INSERT INTO items VALUES (1)` const insert = mode === "ABORT" ? sql`INSERT INTO items VALUES (1)` : sql`INSERT OR ROLLBACK INTO items VALUES (1)` const transaction = sql.withTransaction( mode === "nested ROLLBACK" ? sql.withTransaction(insert) : insert ) const exit = yield* Effect.exit(transaction) assert.isTrue(Exit.isFailure(exit)) if (!Exit.isFailure(exit)) return assert.isFalse( Cause.hasDies(exit.cause), `expected only a typed constraint failure:\n${Cause.pretty(exit.cause)}` ) const error = Option.getOrThrow(Cause.findErrorOption(exit.cause)) assert.strictEqual(error._tag, "SqlError") assert.strictEqual(error.reason._tag, "ConstraintError") const recovered = yield* transaction.pipe( Effect.as(false), Effect.catchTag("SqlError", () => Effect.succeed(true)) ) assert.isTrue(recovered) yield* sql.withTransaction(sql`INSERT INTO items VALUES (2)`) assert.deepStrictEqual(yield* sql`SELECT id FROM items ORDER BY id`, [{ id: 1 }, { id: 2 }]) }) ) it.effect.each(["missing savepoint", "unrelated cleanup error"] as const)( "keeps a %s as a defect and rolls back the outer transaction", (mode) => Effect.gen(function*() { const sql = yield* SqliteClient.make({ filename: ":memory:" }).pipe(Effect.provide(Reactivity.layer)) yield* sql`CREATE TABLE items (id INTEGER PRIMARY KEY)` const error = new SqlError({ reason: new ConnectionError({ message: "injected cleanup failure", operation: "rollback", cause: new Error("injected cleanup failure") }) }) if (mode === "unrelated cleanup error") { const conn = yield* Effect.scoped(sql.reserve) const executeUnprepared = conn.executeUnprepared Object.defineProperty(conn, "executeUnprepared", { configurable: true, value: (...args: Parameters) => args[0].startsWith("ROLLBACK TO SAVEPOINT") ? Effect.fail(error) : executeUnprepared(...args) }) } const exit = yield* Effect.exit(sql.withTransaction( sql.withTransaction(Effect.gen(function*() { yield* sql`INSERT INTO items VALUES (1)` if (mode === "missing savepoint") { yield* sql`RELEASE SAVEPOINT effect_sql_1`.unprepared } return yield* Effect.fail(error) })).pipe(Effect.catchTag("SqlError", () => Effect.void)) )) assert.deepStrictEqual(yield* sql`SELECT id FROM items`, []) assert.isTrue(Exit.isFailure(exit)) if (!Exit.isFailure(exit)) return assert.isTrue(Cause.hasDies(exit.cause)) assert.match( Cause.pretty(exit.cause), mode === "missing savepoint" ? /no such savepoint/i : /injected cleanup failure/i ) }) ) it.effect("recovers a failed deferred commit without losing an in-memory database", () => Effect.gen(function*() { const sql = yield* SqliteClient.make({ filename: ":memory:" }).pipe(Effect.provide(Reactivity.layer)) yield* sql`PRAGMA foreign_keys = ON` yield* sql`CREATE TABLE parent (id INTEGER PRIMARY KEY)` yield* sql`CREATE TABLE child (parent_id INTEGER REFERENCES parent(id) DEFERRABLE INITIALLY DEFERRED)` yield* sql`INSERT INTO parent VALUES (1)` const failedCommit = yield* Effect.exit(sql.withTransaction(sql`INSERT INTO child VALUES (999)`)) assert.isTrue(Exit.isFailure(failedCommit)) if (!Exit.isFailure(failedCommit)) return assert.match(Cause.pretty(failedCommit.cause), /foreign key constraint failed/i) assert.deepStrictEqual(yield* sql`SELECT * FROM parent`, [{ id: 1 }]) assert.deepStrictEqual(yield* sql`SELECT * FROM child`, []) yield* sql.withTransaction(sql`INSERT INTO child VALUES (1)`) assert.deepStrictEqual(yield* sql`SELECT * FROM child`, [{ parent_id: 1 }]) })) it.effect("poisons the connection when failed-commit cleanup fails", () => Effect.gen(function*() { const sql = yield* makeClient yield* sql`PRAGMA foreign_keys = ON` yield* sql`CREATE TABLE parent (id INTEGER PRIMARY KEY)` yield* sql`CREATE TABLE child (parent_id INTEGER REFERENCES parent(id) DEFERRABLE INITIALLY DEFERRED)` yield* sql`INSERT INTO parent VALUES (1)` // Reserve lends the same SQLite connection used by transactions. Fail only // the cleanup ROLLBACK, leaving the deferred constraint failure real. const conn = yield* Effect.scoped(sql.reserve) const executeUnprepared = conn.executeUnprepared let failRollback = true Object.defineProperty(conn, "executeUnprepared", { configurable: true, value: (...args: Parameters) => { if (args[0] === "ROLLBACK" && failRollback) { return Effect.fail( new SqlError({ reason: new ConnectionError({ message: "injected rollback failure", operation: "rollback", cause: new Error("injected rollback failure") }) }) ) } return executeUnprepared(...args) } }) const failedCommit = yield* Effect.exit(sql.withTransaction(sql`INSERT INTO child VALUES (999)`)) assert.isTrue(Exit.isFailure(failedCommit)) if (!Exit.isFailure(failedCommit)) return const cause = Cause.pretty(failedCommit.cause) assert.match(cause, /foreign key constraint failed/i) assert.match(cause, /injected rollback failure/i) const query = yield* Effect.exit(sql`SELECT * FROM parent`) assert.isTrue(Exit.isFailure(query)) if (Exit.isFailure(query)) { assert.match(Cause.pretty(query.cause), /cannot be reused after failed COMMIT cleanup/i) } const transaction = yield* Effect.exit(sql.withTransaction(Effect.die("transaction body ran"))) assert.isTrue(Exit.isFailure(transaction)) const queryAfterTransaction = yield* Effect.exit(sql`SELECT * FROM parent`) assert.isTrue(Exit.isFailure(queryAfterTransaction)) // Retry cleanup after the transient failure clears, without replacing the database. failRollback = false assert.deepStrictEqual(yield* sql`SELECT * FROM parent`, [{ id: 1 }]) assert.deepStrictEqual(yield* sql`SELECT * FROM child`, []) yield* sql`INSERT INTO child VALUES (1)` assert.deepStrictEqual(yield* sql`SELECT * FROM child`, [{ parent_id: 1 }]) })) it.effect("does not poison a connection already rolled back before failed commit cleanup", () => Effect.gen(function*() { const sql = yield* makeClient yield* sql`CREATE TABLE items (id INTEGER PRIMARY KEY)` const failedCommit = yield* Effect.exit(sql.withTransaction(Effect.gen(function*() { yield* sql`INSERT INTO items VALUES (1)` const insert = yield* Effect.exit(sql`INSERT OR ROLLBACK INTO items VALUES (1)`) assert.isTrue(Exit.isFailure(insert)) }))) assert.isTrue(Exit.isFailure(failedCommit)) if (Exit.isFailure(failedCommit)) { assert.match(Cause.pretty(failedCommit.cause), /no transaction is active/i) } assert.deepStrictEqual(yield* sql`SELECT * FROM items`, []) })) it.effect("withTransaction rollback", () => Effect.gen(function*() { const sql = yield* makeClient yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)` yield* sql`INSERT INTO test (name) VALUES ('hello')`.pipe( Effect.andThen(Effect.fail("boom")), sql.withTransaction, Effect.ignore ) const rows = yield* sql`SELECT * FROM test` assert.deepStrictEqual(rows, []) })) it.effect("keeps a plain write out of another fiber's rolled back transaction", () => Effect.gen(function*() { // Sweep the acquisition/execution gap without relying on one scheduler offset. for (let delay = 0; delay < 31; delay++) { yield* Effect.scoped(Effect.gen(function*() { const sql = yield* makeClient yield* sql`CREATE TABLE race (kind TEXT NOT NULL)` const plain = yield* sql`INSERT INTO race VALUES ('plain')`.pipe( Effect.provideService(References.MaxOpsBeforeYield, 3), Effect.forkChild ) for (let i = 0; i < delay; i++) yield* Effect.yieldNow const transaction = yield* sql.withTransaction(Effect.gen(function*() { yield* sql`INSERT INTO race VALUES ('rolled back')` for (let i = 0; i < 1000; i++) yield* Effect.yieldNow return yield* Effect.fail("rollback") })).pipe(Effect.ignore, Effect.forkChild) yield* Fiber.join(plain) yield* Fiber.join(transaction) assert.deepStrictEqual(yield* sql`SELECT kind FROM race`, [{ kind: "plain" }]) })) } }), { timeout: 30_000 }) it.effect("releases the connection when a queued transaction is interrupted", () => Effect.gen(function*() { // Sweep the interrupt across the gap between taking the connection and registering its release. for (let delay = 0; delay < 31; delay++) { yield* Effect.scoped(Effect.gen(function*() { const sql = yield* SqliteClient.make({ filename: ":memory:" }).pipe(Effect.provide(Reactivity.layer)) const holder = yield* Effect.forkChild(sql`SELECT 1`) const queued = yield* sql.withTransaction(sql`SELECT 2`).pipe( Effect.provideService(References.MaxOpsBeforeYield, 3), Effect.forkChild ) for (let i = 0; i < delay; i++) yield* Effect.yieldNow yield* Fiber.interrupt(queued) yield* Fiber.join(holder) const next = yield* Effect.forkChild(sql`SELECT 3`, { startImmediately: true }) assert.isDefined(next.pollUnsafe(), `connection leaked at delay ${delay}`) })) } })) it.effect("uses a 5 second busy timeout", () => Effect.gen(function*() { const sql = yield* makeClient assert.deepStrictEqual(yield* sql`PRAGMA busy_timeout`, [{ timeout: 5000 }]) const custom = yield* SqliteClient.make({ filename: ":memory:", busyTimeout: "1 second" }).pipe( Effect.provide(Reactivity.layer) ) assert.deepStrictEqual(yield* custom`PRAGMA busy_timeout`, [{ timeout: 1000 }]) const infinite = yield* SqliteClient.make({ filename: ":memory:", busyTimeout: Duration.infinity }).pipe( Effect.provide(Reactivity.layer) ) assert.deepStrictEqual(yield* infinite`PRAGMA busy_timeout`, [{ timeout: 2_147_483_647 }]) })) it.effect("starts transactions immediately", () => Effect.gen(function*() { const { client, contender } = yield* makeClients yield* contender`PRAGMA busy_timeout = 1` yield* client.withTransaction( Effect.gen(function*() { const error = yield* Effect.flip(contender`BEGIN IMMEDIATE`) assert.strictEqual(error._tag, "SqlError") assert(error.reason.cause instanceof Error) assert.match(error.reason.cause.message, /database is locked/i) }) ) })) it.effect("fails a contended transaction with a typed error", () => Effect.gen(function*() { const { client, contender } = yield* makeClients yield* contender`PRAGMA busy_timeout = 1` const exit = yield* client.withTransaction( Effect.exit(contender.withTransaction(Effect.void)) ) assert.isTrue(Exit.isFailure(exit)) if (!Exit.isFailure(exit)) { return } // `BEGIN IMMEDIATE` cannot take the write lock, so it fails before a // transaction exists. The failure has to stay a typed, retryable // `SqlError` instead of being replaced by a rollback defect. assert.isFalse( Cause.hasDies(exit.cause), `expected a typed failure but the cause contains a defect:\n${Cause.pretty(exit.cause)}` ) const error = Option.getOrThrow(Cause.findErrorOption(exit.cause)) assert.strictEqual(error._tag, "SqlError") assert(error.reason.cause instanceof Error) assert.match(error.reason.cause.message, /database is locked/i) })) it.effect("supports transactions on readonly clients", () => Effect.gen(function*() { const fs = yield* FileSystem.FileSystem const dir = yield* fs.makeTempDirectoryScoped() const filename = dir + "/test.db" yield* Effect.scoped( Effect.gen(function*() { const sql = yield* SqliteClient.make({ filename }) yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY)` }) ) const sql = yield* SqliteClient.make({ filename, readonly: true }) yield* sql`PRAGMA query_only = ON` assert.deepStrictEqual(yield* sql.withTransaction(sql`SELECT * FROM test`), []) }).pipe(Effect.provide([NodeFileSystem.layer, Reactivity.layer]))) it.effect("supports backup and export", () => Effect.gen(function*() { const sql = yield* makeClient yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)` yield* sql`INSERT INTO test (name) VALUES ('hello')` const metadata = yield* sql.backup(sql.config.filename + ".backup") assert(metadata.totalPages > 0) assert.strictEqual(metadata.remainingPages, 0) })) it.effect("retries enabling WAL while the database is locked", () => Effect.gen(function*() { const { filename, unlock } = yield* makeLockedDatabase const fiber = yield* SqliteClient.make({ filename }).pipe(Effect.forkChild({ startImmediately: true })) unlock() yield* TestClock.adjust("10 millis") const sql = yield* Fiber.join(fiber) assert.deepStrictEqual(yield* sql`PRAGMA journal_mode`, [{ journal_mode: "wal" }]) }).pipe(Effect.provide(Reactivity.layer))) it.effect("fails to enable WAL with a typed error after busyTimeout", () => Effect.gen(function*() { const { filename } = yield* makeLockedDatabase const fiber = yield* SqliteClient.make({ filename, busyTimeout: "1 second" }).pipe( Effect.forkChild({ startImmediately: true }) ) yield* TestClock.adjust("2 seconds") const error = yield* Effect.flip(Fiber.join(fiber)) assert.strictEqual(error.reason._tag, "LockTimeoutError") }).pipe(Effect.provide(Reactivity.layer))) it.effect("does not enable WAL on readonly clients", () => Effect.gen(function*() { const fs = yield* FileSystem.FileSystem const dir = yield* fs.makeTempDirectoryScoped() const filename = dir + "/test.db" yield* Effect.scoped( Effect.gen(function*() { const sql = yield* SqliteClient.make({ filename, disableWAL: true }) yield* sql`CREATE TABLE test (id INTEGER PRIMARY KEY)` }) ) const sql = yield* SqliteClient.make({ filename, readonly: true }) assert.deepStrictEqual(yield* sql`PRAGMA journal_mode`, [{ journal_mode: "delete" }]) }).pipe(Effect.provide([NodeFileSystem.layer, Reactivity.layer]))) it.effect("works when node:sqlite does not provide enableLoadExtension", () => Effect.gen(function*() { const prototype: Partial> = DatabaseSync.prototype const descriptor = Object.getOwnPropertyDescriptor(prototype, "enableLoadExtension") yield* Effect.acquireRelease( Effect.sync(() => delete prototype.enableLoadExtension), () => Effect.sync(() => { if (descriptor) Object.defineProperty(prototype, "enableLoadExtension", descriptor) }) ) const sql = yield* makeClient assert.deepStrictEqual(yield* sql`SELECT 1 AS value`, [{ value: 1 }]) const error = yield* Effect.flip(sql.loadExtension(sql.config.filename + ".missing-extension")) assert.strictEqual(error._tag, "SqlError") }), { concurrent: false }) })