From a22747b174eece0ec31d23b1ab83a8a00974dfcd Mon Sep 17 00:00:00 2001 From: Tyler Gibbs Date: Mon, 16 Nov 2026 10:13:35 -0600 Subject: [PATCH 1/4] Declare SqlEventLogServerEncrypted indexes inline on SQL Server createTable created each compaction index with a separate IF NOT EXISTS (sys.indexes) CREATE INDEX after the CREATE TABLE. Two instances opening the same store could run CREATE INDEX on the same table together, which SQL Server can deadlock and only resolves after its lock monitor picks a victim (up to about 5 s). The indexes are now declared inside the one CREATE TABLE, through a helper shared with MySQL, so the table and its indexes appear together. Index names, columns and the existing retry are unchanged. Closes #10672 Co-Authored-By: Claude Opus 5.5 --- .changeset/eventlog-mssql-inline-indexes.md | 5 ++ .../eventlog/SqlEventLogServerEncrypted.ts | 27 ++++--- ...ventLogServerEncrypted.integration.test.ts | 75 ++++++++++++++++++- 3 files changed, 92 insertions(+), 15 deletions(-) create mode 100644 .changeset/eventlog-mssql-inline-indexes.md diff --git a/.changeset/eventlog-mssql-inline-indexes.md b/.changeset/eventlog-mssql-inline-indexes.md new file mode 100644 index 00000000000..ed995529f92 --- /dev/null +++ b/.changeset/eventlog-mssql-inline-indexes.md @@ -0,0 +1,5 @@ +--- +"effect": patch +--- + +Fix `SqlEventLogServerEncrypted` on SQL Server stalling for seconds when two instances create the same tables at once. diff --git a/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts b/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts index 51180e06ef2..3c389319c17 100644 --- a/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts +++ b/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts @@ -178,21 +178,19 @@ export const makeStorage = (options?: { }) // Two instances can open the same table at once, and PostgreSQL and SQL // Server can fail the loser of a concurrent create, so creation retries. - const createTable = (name: string, columns: string, indexes: ReadonlyArray = []) => - sql.onDialectOrElse({ - mysql: () => { - const definitions = [columns, ...indexes.map((index) => `INDEX (${index})`)].join(", ") - return Effect.asVoid(sql`CREATE TABLE IF NOT EXISTS ${sql(name)} (${sql.literal(definitions)})`) - }, + // MySQL and SQL Server declare the indexes inside the CREATE TABLE: on SQL + // Server, two instances running separate CREATE INDEX statements on the + // same table can deadlock, which stalls the loser for seconds. + const createTable = (name: string, columns: string, indexes: ReadonlyArray = []) => { + const definitions = (index: (columns: Statement.Fragment, name: string) => Statement.Fragment) => + sql.csv([sql.literal(columns), ...indexes.map((cols, i) => index(sql.literal(cols), `${name}_i${i}`))]) + return sql.onDialectOrElse({ + mysql: () => + Effect.asVoid(sql`CREATE TABLE IF NOT EXISTS ${sql(name)} (${definitions((cols) => sql`INDEX (${cols})`)})`), mssql: () => - sql`IF OBJECT_ID(${name}, N'U') IS NULL CREATE TABLE ${sql(name)} (${sql.literal(columns)})`.pipe( - Effect.andThen(Effect.forEach(indexes, (index, i) => { - const indexName = `${name}_i${i}` - return sql` - IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = ${indexName} AND object_id = OBJECT_ID(${name})) - CREATE INDEX ${sql(indexName)} ON ${sql(name)} (${sql.literal(index)})` - }, { discard: true })) - ), + sql`IF OBJECT_ID(${name}, N'U') IS NULL CREATE TABLE ${sql(name)} (${ + definitions((cols, indexName) => sql`INDEX ${sql(indexName)} NONCLUSTERED (${cols})`) + })`, orElse: () => sql`CREATE TABLE IF NOT EXISTS ${sql(name)} (${sql.literal(columns)})`.pipe( Effect.andThen(Effect.forEach( @@ -203,6 +201,7 @@ export const makeStorage = (options?: { )) ) }).pipe(Effect.retry({ times: 3 })) + } const storesTable = `${tablePrefix}_compaction_stores` const bucketsTable = `${tablePrefix}_compaction_buckets` diff --git a/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts b/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts index 970f2c073b2..3bcbf4ff261 100644 --- a/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts +++ b/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts @@ -1,4 +1,5 @@ -import { Layer } from "effect" +import { assert, it } from "@effect/vitest" +import { Deferred, Effect, Fiber, Layer } from "effect" import * as CompactionTest from "effect-test/eventlog/EventLogServerEncryptedCompactionTest" import * as EncryptedTest from "effect-test/eventlog/EventLogServerEncryptedTest" import * as SqlEventLogServerEncryptedStorageTest from "effect-test/eventlog/SqlEventLogServerEncryptedStorageTest" @@ -6,6 +7,7 @@ import * as Digest from "effect/crypto/Digest" import * as EventLogEncryption from "effect/eventlog/EventLogEncryption" import * as SqlEventLogServerEncrypted from "effect/eventlog/SqlEventLogServerEncrypted" import { Reactivity } from "effect/reactivity" +import { SqlClient } from "effect/sql" import { MssqlContainer } from "./utils.ts" EncryptedTest.suite( @@ -24,3 +26,74 @@ CompactionTest.suite( ) SqlEventLogServerEncryptedStorageTest.compactionSuite("mssql", MssqlContainer.layerClient) + +// Succeeds once a request waits on a lock that session `spid` holds. +const blockedBy = Effect.fnUntraced(function*(spid: number) { + const sql = yield* SqlClient.SqlClient + while (true) { + const [row] = yield* sql<{ n: number }>` + SELECT COUNT(*) AS n FROM sys.dm_exec_requests WHERE blocking_session_id = ${spid}` + if (row.n > 0) return "waited" as const + yield* Effect.sleep(20) + } +}) + +it.layer(Layer.mergeAll(Digest.layerWebCrypto, MssqlContainer.layerClient), { + timeout: "60 seconds", + excludeTestServices: true +})( + "SqlEventLogServerEncrypted tables (mssql)", + (it) => { + it.effect("opens a store while another instance is creating an index", () => + Effect.gen(function*() { + const sql = yield* SqlClient.SqlClient + const prefix = `indexing_${crypto.randomUUID().replaceAll("-", "").slice(0, 16)}` + const stores = `${prefix}_compaction_stores` + // Another instance created the stores table and is in the middle of + // creating its index. A statement waiting on that index holds locks the + // index's creation needs next, which SQL Server only breaks as a + // deadlock after up to 5 seconds. + yield* sql`CREATE TABLE ${sql(stores)} (scope NVARCHAR(36) PRIMARY KEY, next_sweep_at BIGINT NULL)` + const indexing = yield* Deferred.make() + const release = yield* Deferred.make() + const other = yield* sql.withTransaction(Effect.gen(function*() { + yield* sql`CREATE INDEX ${sql(`${stores}_i0`)} ON ${sql(stores)} (next_sweep_at)` + const [row] = yield* sql<{ spid: number }>`SELECT @@SPID AS spid` + yield* Deferred.succeed(indexing, row.spid) + yield* Deferred.await(release) + })).pipe(Effect.forkChild) + const spid = yield* Deferred.await(indexing) + + const opened = SqlEventLogServerEncrypted.makeStorage({ + entryTablePrefix: prefix, + remoteIdTable: `${prefix}_remote_id` + }).pipe(Effect.as("opened" as const), Effect.scoped) + const outcome = yield* Effect.race(opened, blockedBy(spid)) + yield* Deferred.succeed(release, undefined) + yield* Fiber.join(other) + + assert.strictEqual(outcome, "opened") + })) + + it.effect("names the indexes it creates with their tables", () => + Effect.gen(function*() { + const sql = yield* SqlClient.SqlClient + const prefix = `indexes_${crypto.randomUUID().replaceAll("-", "").slice(0, 16)}` + yield* SqlEventLogServerEncrypted.makeStorage({ + entryTablePrefix: prefix, + remoteIdTable: `${prefix}_remote_id` + }).pipe(Effect.scoped) + + const rows = yield* sql<{ name: string }>` + SELECT i.name FROM sys.indexes i JOIN sys.tables t ON t.object_id = i.object_id + WHERE t.name LIKE ${`${prefix}_compaction_%`} AND i.is_primary_key = 0 AND i.name IS NOT NULL + ORDER BY i.name` + assert.deepStrictEqual(rows.map((row) => row.name), [ + `${prefix}_compaction_activations_i0`, + `${prefix}_compaction_stages_i0`, + `${prefix}_compaction_stages_i1`, + `${prefix}_compaction_stores_i0` + ]) + })) + } +) From a1d18ead05b25e9ceaaf98cdc37b33308729f388 Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Mon, 16 Nov 2026 20:14:03 +0000 Subject: [PATCH 2/4] Keep inline event log indexes MSSQL-local and focus regression coverage --- .../eventlog/SqlEventLogServerEncrypted.ts | 28 +++++++++---------- ...ventLogServerEncrypted.integration.test.ts | 26 +---------------- 2 files changed, 15 insertions(+), 39 deletions(-) diff --git a/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts b/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts index 3c389319c17..d4ab2b6c932 100644 --- a/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts +++ b/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts @@ -178,19 +178,20 @@ export const makeStorage = (options?: { }) // Two instances can open the same table at once, and PostgreSQL and SQL // Server can fail the loser of a concurrent create, so creation retries. - // MySQL and SQL Server declare the indexes inside the CREATE TABLE: on SQL - // Server, two instances running separate CREATE INDEX statements on the - // same table can deadlock, which stalls the loser for seconds. - const createTable = (name: string, columns: string, indexes: ReadonlyArray = []) => { - const definitions = (index: (columns: Statement.Fragment, name: string) => Statement.Fragment) => - sql.csv([sql.literal(columns), ...indexes.map((cols, i) => index(sql.literal(cols), `${name}_i${i}`))]) - return sql.onDialectOrElse({ - mysql: () => - Effect.asVoid(sql`CREATE TABLE IF NOT EXISTS ${sql(name)} (${definitions((cols) => sql`INDEX (${cols})`)})`), - mssql: () => - sql`IF OBJECT_ID(${name}, N'U') IS NULL CREATE TABLE ${sql(name)} (${ - definitions((cols, indexName) => sql`INDEX ${sql(indexName)} NONCLUSTERED (${cols})`) - })`, + // Inline SQL Server indexes avoid deadlocks between concurrent CREATE INDEX statements. + const createTable = (name: string, columns: string, indexes: ReadonlyArray = []) => + sql.onDialectOrElse({ + mysql: () => { + const definitions = [columns, ...indexes.map((index) => `INDEX (${index})`)].join(", ") + return Effect.asVoid(sql`CREATE TABLE IF NOT EXISTS ${sql(name)} (${sql.literal(definitions)})`) + }, + mssql: () => { + const definitions = sql.csv([ + sql.literal(columns), + ...indexes.map((index, i) => sql`INDEX ${sql(`${name}_i${i}`)} NONCLUSTERED (${sql.literal(index)})`) + ]) + return Effect.asVoid(sql`IF OBJECT_ID(${name}, N'U') IS NULL CREATE TABLE ${sql(name)} (${definitions})`) + }, orElse: () => sql`CREATE TABLE IF NOT EXISTS ${sql(name)} (${sql.literal(columns)})`.pipe( Effect.andThen(Effect.forEach( @@ -201,7 +202,6 @@ export const makeStorage = (options?: { )) ) }).pipe(Effect.retry({ times: 3 })) - } const storesTable = `${tablePrefix}_compaction_stores` const bucketsTable = `${tablePrefix}_compaction_buckets` diff --git a/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts b/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts index 3bcbf4ff261..29444e5080a 100644 --- a/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts +++ b/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts @@ -49,10 +49,7 @@ it.layer(Layer.mergeAll(Digest.layerWebCrypto, MssqlContainer.layerClient), { const sql = yield* SqlClient.SqlClient const prefix = `indexing_${crypto.randomUUID().replaceAll("-", "").slice(0, 16)}` const stores = `${prefix}_compaction_stores` - // Another instance created the stores table and is in the middle of - // creating its index. A statement waiting on that index holds locks the - // index's creation needs next, which SQL Server only breaks as a - // deadlock after up to 5 seconds. + // Hold index creation open to reproduce the old opener's lock wait. yield* sql`CREATE TABLE ${sql(stores)} (scope NVARCHAR(36) PRIMARY KEY, next_sweep_at BIGINT NULL)` const indexing = yield* Deferred.make() const release = yield* Deferred.make() @@ -74,26 +71,5 @@ it.layer(Layer.mergeAll(Digest.layerWebCrypto, MssqlContainer.layerClient), { assert.strictEqual(outcome, "opened") })) - - it.effect("names the indexes it creates with their tables", () => - Effect.gen(function*() { - const sql = yield* SqlClient.SqlClient - const prefix = `indexes_${crypto.randomUUID().replaceAll("-", "").slice(0, 16)}` - yield* SqlEventLogServerEncrypted.makeStorage({ - entryTablePrefix: prefix, - remoteIdTable: `${prefix}_remote_id` - }).pipe(Effect.scoped) - - const rows = yield* sql<{ name: string }>` - SELECT i.name FROM sys.indexes i JOIN sys.tables t ON t.object_id = i.object_id - WHERE t.name LIKE ${`${prefix}_compaction_%`} AND i.is_primary_key = 0 AND i.name IS NOT NULL - ORDER BY i.name` - assert.deepStrictEqual(rows.map((row) => row.name), [ - `${prefix}_compaction_activations_i0`, - `${prefix}_compaction_stages_i0`, - `${prefix}_compaction_stages_i1`, - `${prefix}_compaction_stores_i0` - ]) - })) } ) From 9bded0ff3b97d4805957f027bd23d5de6cf0c70b Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Mon, 16 Nov 2026 20:30:00 +0000 Subject: [PATCH 3/4] Simplify the SQL Server inline index regression --- .../eventlog/SqlEventLogServerEncrypted.ts | 3 +- .../SqlEventLogServerEncryptedStorageTest.ts | 2 +- ...ventLogServerEncrypted.integration.test.ts | 50 +++++++------------ 3 files changed, 22 insertions(+), 33 deletions(-) diff --git a/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts b/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts index d4ab2b6c932..1a222b5d0a0 100644 --- a/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts +++ b/packages/effect/src/eventlog/SqlEventLogServerEncrypted.ts @@ -178,7 +178,8 @@ export const makeStorage = (options?: { }) // Two instances can open the same table at once, and PostgreSQL and SQL // Server can fail the loser of a concurrent create, so creation retries. - // Inline SQL Server indexes avoid deadlocks between concurrent CREATE INDEX statements. + // SQL Server declares its indexes inline, as concurrent CREATE INDEX + // statements can deadlock. const createTable = (name: string, columns: string, indexes: ReadonlyArray = []) => sql.onDialectOrElse({ mysql: () => { diff --git a/packages/effect/test/eventlog/SqlEventLogServerEncryptedStorageTest.ts b/packages/effect/test/eventlog/SqlEventLogServerEncryptedStorageTest.ts index 45561eda9ec..4a4cf7db097 100644 --- a/packages/effect/test/eventlog/SqlEventLogServerEncryptedStorageTest.ts +++ b/packages/effect/test/eventlog/SqlEventLogServerEncryptedStorageTest.ts @@ -24,7 +24,7 @@ const ids = (batches: ReadonlyArray<{ readonly entryIds: ReadonlyArray batch.entryIds.map((id) => Array.from(id).join(","))) // Waits until another connection is blocked on a lock held by an open transaction. -const awaitLockWait = Effect.gen(function*() { +export const awaitLockWait = Effect.gen(function*() { const sql = yield* SqlClient.SqlClient const waiting = sql.onDialectOrElse({ pg: () => diff --git a/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts b/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts index 29444e5080a..8e6d99d8a75 100644 --- a/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts +++ b/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts @@ -1,5 +1,5 @@ import { assert, it } from "@effect/vitest" -import { Deferred, Effect, Fiber, Layer } from "effect" +import { Deferred, Effect, Layer } from "effect" import * as CompactionTest from "effect-test/eventlog/EventLogServerEncryptedCompactionTest" import * as EncryptedTest from "effect-test/eventlog/EventLogServerEncryptedTest" import * as SqlEventLogServerEncryptedStorageTest from "effect-test/eventlog/SqlEventLogServerEncryptedStorageTest" @@ -27,17 +27,6 @@ CompactionTest.suite( SqlEventLogServerEncryptedStorageTest.compactionSuite("mssql", MssqlContainer.layerClient) -// Succeeds once a request waits on a lock that session `spid` holds. -const blockedBy = Effect.fnUntraced(function*(spid: number) { - const sql = yield* SqlClient.SqlClient - while (true) { - const [row] = yield* sql<{ n: number }>` - SELECT COUNT(*) AS n FROM sys.dm_exec_requests WHERE blocking_session_id = ${spid}` - if (row.n > 0) return "waited" as const - yield* Effect.sleep(20) - } -}) - it.layer(Layer.mergeAll(Digest.layerWebCrypto, MssqlContainer.layerClient), { timeout: "60 seconds", excludeTestServices: true @@ -47,27 +36,26 @@ it.layer(Layer.mergeAll(Digest.layerWebCrypto, MssqlContainer.layerClient), { it.effect("opens a store while another instance is creating an index", () => Effect.gen(function*() { const sql = yield* SqlClient.SqlClient - const prefix = `indexing_${crypto.randomUUID().replaceAll("-", "").slice(0, 16)}` + const prefix = "indexing" const stores = `${prefix}_compaction_stores` - // Hold index creation open to reproduce the old opener's lock wait. yield* sql`CREATE TABLE ${sql(stores)} (scope NVARCHAR(36) PRIMARY KEY, next_sweep_at BIGINT NULL)` - const indexing = yield* Deferred.make() - const release = yield* Deferred.make() - const other = yield* sql.withTransaction(Effect.gen(function*() { - yield* sql`CREATE INDEX ${sql(`${stores}_i0`)} ON ${sql(stores)} (next_sweep_at)` - const [row] = yield* sql<{ spid: number }>`SELECT @@SPID AS spid` - yield* Deferred.succeed(indexing, row.spid) - yield* Deferred.await(release) - })).pipe(Effect.forkChild) - const spid = yield* Deferred.await(indexing) - - const opened = SqlEventLogServerEncrypted.makeStorage({ - entryTablePrefix: prefix, - remoteIdTable: `${prefix}_remote_id` - }).pipe(Effect.as("opened" as const), Effect.scoped) - const outcome = yield* Effect.race(opened, blockedBy(spid)) - yield* Deferred.succeed(release, undefined) - yield* Fiber.join(other) + // Hold a separate index creation open, as an older instance would. + const indexing = yield* Deferred.make() + yield* sql`CREATE INDEX ${sql(`${stores}_i0`)} ON ${sql(stores)} (next_sweep_at)`.pipe( + Effect.andThen(Deferred.succeed(indexing, undefined)), + Effect.andThen(Effect.never), + sql.withTransaction, + Effect.forkScoped + ) + yield* Deferred.await(indexing) + + const outcome = yield* Effect.race( + SqlEventLogServerEncrypted.makeStorage({ entryTablePrefix: prefix }).pipe( + Effect.as("opened"), + Effect.scoped + ), + Effect.as(SqlEventLogServerEncryptedStorageTest.awaitLockWait, "waited") + ) assert.strictEqual(outcome, "opened") })) From b04ad2d2bd3ad944c559e555eeb14c0ba0d693b9 Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Mon, 16 Nov 2026 20:55:12 +0000 Subject: [PATCH 4/4] Observe only the holding session in the inline index regression --- .../SqlEventLogServerEncryptedStorageTest.ts | 2 +- ...ventLogServerEncrypted.integration.test.ts | 30 +++++++++++++------ 2 files changed, 22 insertions(+), 10 deletions(-) diff --git a/packages/effect/test/eventlog/SqlEventLogServerEncryptedStorageTest.ts b/packages/effect/test/eventlog/SqlEventLogServerEncryptedStorageTest.ts index 4a4cf7db097..45561eda9ec 100644 --- a/packages/effect/test/eventlog/SqlEventLogServerEncryptedStorageTest.ts +++ b/packages/effect/test/eventlog/SqlEventLogServerEncryptedStorageTest.ts @@ -24,7 +24,7 @@ const ids = (batches: ReadonlyArray<{ readonly entryIds: ReadonlyArray batch.entryIds.map((id) => Array.from(id).join(","))) // Waits until another connection is blocked on a lock held by an open transaction. -export const awaitLockWait = Effect.gen(function*() { +const awaitLockWait = Effect.gen(function*() { const sql = yield* SqlClient.SqlClient const waiting = sql.onDialectOrElse({ pg: () => diff --git a/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts b/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts index 8e6d99d8a75..90078b1ec1f 100644 --- a/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts +++ b/packages/sql/mssql/test/SqlEventLogServerEncrypted.integration.test.ts @@ -27,6 +27,18 @@ CompactionTest.suite( SqlEventLogServerEncryptedStorageTest.compactionSuite("mssql", MssqlContainer.layerClient) +// Succeeds once a request waits on a lock that session `spid` holds. Other +// sessions don't count, as SQL Server's background tasks block each other. +const blockedBy = Effect.fnUntraced(function*(spid: number) { + const sql = yield* SqlClient.SqlClient + while (true) { + const [row] = yield* sql<{ n: number }>` + SELECT COUNT(*) AS n FROM sys.dm_exec_requests WHERE blocking_session_id = ${spid}` + if (row.n > 0) return "waited" + yield* Effect.sleep(20) + } +}) + it.layer(Layer.mergeAll(Digest.layerWebCrypto, MssqlContainer.layerClient), { timeout: "60 seconds", excludeTestServices: true @@ -40,21 +52,21 @@ it.layer(Layer.mergeAll(Digest.layerWebCrypto, MssqlContainer.layerClient), { const stores = `${prefix}_compaction_stores` yield* sql`CREATE TABLE ${sql(stores)} (scope NVARCHAR(36) PRIMARY KEY, next_sweep_at BIGINT NULL)` // Hold a separate index creation open, as an older instance would. - const indexing = yield* Deferred.make() - yield* sql`CREATE INDEX ${sql(`${stores}_i0`)} ON ${sql(stores)} (next_sweep_at)`.pipe( - Effect.andThen(Deferred.succeed(indexing, undefined)), - Effect.andThen(Effect.never), - sql.withTransaction, - Effect.forkScoped - ) - yield* Deferred.await(indexing) + const indexing = yield* Deferred.make() + yield* Effect.gen(function*() { + yield* sql`CREATE INDEX ${sql(`${stores}_i0`)} ON ${sql(stores)} (next_sweep_at)` + const [row] = yield* sql<{ spid: number }>`SELECT @@SPID AS spid` + yield* Deferred.succeed(indexing, row.spid) + return yield* Effect.never + }).pipe(sql.withTransaction, Effect.forkScoped) + const spid = yield* Deferred.await(indexing) const outcome = yield* Effect.race( SqlEventLogServerEncrypted.makeStorage({ entryTablePrefix: prefix }).pipe( Effect.as("opened"), Effect.scoped ), - Effect.as(SqlEventLogServerEncryptedStorageTest.awaitLockWait, "waited") + blockedBy(spid) ) assert.strictEqual(outcome, "opened")