effect 4.0.0-beta.99 → 4.0.0-rc.109

package/src/unstable/persistence/KeyValueStore.ts

@@ -355,7 +355,12 @@ export const layerMemory: Layer.Layer<KeyValueStore> = Layer.sync(KeyValueStore)
  *
  * **Details**
  *
- * The directory is created if needed, and each key is encoded as a file name.
+ * The directory is created if needed, and each key is percent-encoded as a
+ * single file name. Empty keys, `.` and `..` are rejected. Keys are only
+ * guaranteed to be distinct on case-sensitive file systems.
+ *
+ * `clear` removes the directory recursively, so it must not be shared with
+ * unrelated data.
  *
  * @category layers
  * @since 4.0.0
@@ -366,7 +371,20 @@ export const layerFileSystem = (
   Layer.effect(KeyValueStore)(Effect.gen(function*() {
     const fs = yield* FileSystem.FileSystem
     const path = yield* Path.Path
-    const keyPath = (key: string) => path.join(directory, encodeURIComponent(key))
+    const withKeyPath = <A>(
+      method: string,
+      key: string,
+      f: (path: string) => Effect.Effect<A, KeyValueStoreError>
+    ): Effect.Effect<A, KeyValueStoreError> =>
+      key.length === 0 || key === "." || key === ".."
+        ? Effect.fail(
+          new KeyValueStoreError({
+            method,
+            key,
+            message: `Invalid key ${key}`
+          })
+        )
+        : f(path.join(directory, encodeURIComponent(key)))
 
     if (!(yield* fs.exists(directory))) {
       yield* fs.makeDirectory(directory, { recursive: true })
@@ -374,60 +392,65 @@ export const layerFileSystem = (
 
     return make({
       get: (key: string) =>
-        Effect.catchTag(
-          fs.readFileString(keyPath(key)),
-          "PlatformError",
-          (cause) =>
-            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
-              new KeyValueStoreError({
-                method: "get",
-                key,
-                message: `Unable to get item with key ${key}`,
-                cause
-              })
-            )
-        ),
+        withKeyPath("get", key, (path) =>
+          Effect.catchTag(
+            fs.readFileString(path),
+            "PlatformError",
+            (cause) =>
+              cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
+                new KeyValueStoreError({
+                  method: "get",
+                  key,
+                  message: `Unable to get item with key ${key}`,
+                  cause
+                })
+              )
+          )),
       getUint8Array: (key: string) =>
-        Effect.catchTag(
-          fs.readFile(keyPath(key)),
-          "PlatformError",
-          (cause) =>
-            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
+        withKeyPath("getUint8Array", key, (path) =>
+          Effect.catchTag(
+            fs.readFile(path),
+            "PlatformError",
+            (cause) =>
+              cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
+                new KeyValueStoreError({
+                  method: "getUint8Array",
+                  key,
+                  message: `Unable to get item with key ${key}`,
+                  cause
+                })
+              )
+          )),
+      set: (key: string, value: string | Uint8Array) =>
+        withKeyPath("set", key, (path) =>
+          Effect.mapError(
+            typeof value === "string" ? fs.writeFileString(path, value) : fs.writeFile(path, value),
+            (cause) =>
               new KeyValueStoreError({
-                method: "getUint8Array",
+                method: "set",
                 key,
-                message: `Unable to get item with key ${key}`,
+                message: `Unable to set item with key ${key}`,
                 cause
               })
-            )
-        ),
-      set: (key: string, value: string | Uint8Array) =>
-        Effect.mapError(
-          typeof value === "string" ? fs.writeFileString(keyPath(key), value) : fs.writeFile(keyPath(key), value),
-          (cause) =>
+          )),
+      remove: (key: string) =>
+        withKeyPath("remove", key, (path) =>
+          Effect.mapError(fs.remove(path), (cause) =>
             new KeyValueStoreError({
-              method: "set",
+              method: "remove",
               key,
-              message: `Unable to set item with key ${key}`,
+              message: `Unable to remove item with key ${key}`,
               cause
-            })
-        ),
-      remove: (key: string) =>
-        Effect.mapError(fs.remove(keyPath(key)), (cause) =>
-          new KeyValueStoreError({
-            method: "remove",
-            key,
-            message: `Unable to remove item with key ${key}`,
-            cause
-          })),
+            }))),
       has: (key: string) =>
-        Effect.mapError(fs.exists(keyPath(key)), (cause) =>
-          new KeyValueStoreError({
-            method: "has",
-            key,
-            message: `Unable to check existence of item with key ${key}`,
-            cause
-          })),
+        withKeyPath("has", key, (path) =>
+          Effect.mapError(fs.exists(path), (cause) =>
+            new KeyValueStoreError({
+              method: "has",
+              key,
+              message: `Unable to check existence of item with key ${key}`,
+              cause
+            }))),
       clear: Effect.mapError(
         Effect.andThen(
           fs.remove(directory, { recursive: true }),
@@ -692,7 +715,7 @@ const SchemaStoreTypeId = "~effect/persistence/KeyValueStore/SchemaStore" as con
 /**
  * Schema-aware view of a `KeyValueStore` that stores values as encoded JSON.
  *
- * @category SchemaStore
+ * @category models
  * @since 4.0.0
  */
 export interface SchemaStore<S extends Schema.Constraint> {
@@ -753,7 +776,7 @@ export interface SchemaStore<S extends Schema.Constraint> {
 /**
  * Adapts a `KeyValueStore` into a `SchemaStore` using the schema's JSON codec.
  *
- * @category SchemaStore
+ * @category converting
  * @since 4.0.0
  */
 export const toSchemaStore = <S extends Schema.Constraint>(self: KeyValueStore, schema: S): SchemaStore<S> => {

package/src/unstable/persistence/Persistable.ts

@@ -10,6 +10,7 @@
 import type * as Duration from "../../Duration.ts"
 import type * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
+import * as InternalRecord from "../../internal/record.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import * as Request from "../../Request.ts"
 import * as Schema from "../../Schema.ts"
@@ -55,7 +56,7 @@ export type Any = Persistable<Schema.Constraint, Schema.Constraint>
 /**
  * Extracts the success schema from a persistable request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type SuccessSchema<A extends Any> = A["~effect/persistence/Persistable"]["success"]
@@ -63,7 +64,7 @@ export type SuccessSchema<A extends Any> = A["~effect/persistence/Persistable"][
 /**
  * Extracts the success value type from a persistable request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type Success<A extends Any> = A["~effect/persistence/Persistable"]["success"]["Type"]
@@ -71,7 +72,7 @@ export type Success<A extends Any> = A["~effect/persistence/Persistable"]["succe
 /**
  * Extracts the error schema from a persistable request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type ErrorSchema<A extends Any> = A["~effect/persistence/Persistable"]["error"]
@@ -79,7 +80,7 @@ export type ErrorSchema<A extends Any> = A["~effect/persistence/Persistable"]["e
 /**
  * Extracts the error value type from a persistable request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type Error<A extends Any> = A["~effect/persistence/Persistable"]["error"]["Type"]
@@ -88,7 +89,7 @@ export type Error<A extends Any> = A["~effect/persistence/Persistable"]["error"]
  * Services required to decode a persisted success or error value for the
  * request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type DecodingServices<A extends Any> =
@@ -98,7 +99,7 @@ export type DecodingServices<A extends Any> =
 /**
  * Services required to encode a success or error value for persistence.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type EncodingServices<A extends Any> =
@@ -109,7 +110,7 @@ export type EncodingServices<A extends Any> =
  * All schema services required to encode and decode a persistable request
  * result.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type Services<A extends Any> =
@@ -122,7 +123,7 @@ export type Services<A extends Any> =
  * Computes the time to live for a persisted result from the result `Exit` and
  * request value.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type TimeToLiveFn<K extends Any> = (exit: Exit.Exit<Success<K>, Error<K>>, request: K) => Duration.Input
@@ -179,10 +180,10 @@ export const Class = <
     | ("requires" extends keyof Config ? Config["requires"] : never)
   > =>
 {
-  function Persistable(this: any, props: any) {
+  function Persistable(this: any, props: object | undefined) {
     this._tag = tag
     if (props) {
-      Object.assign(this, props)
+      InternalRecord.assignProperties(this, props)
     }
   }
   Persistable.prototype = {

package/src/unstable/persistence/PersistedQueue.ts

@@ -27,6 +27,7 @@ import * as RcMap from "../../RcMap.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
+import * as Migrator from "../sql/Migrator.ts"
 import * as SqlClient from "../sql/SqlClient.ts"
 import type { SqlError } from "../sql/SqlError.ts"
 import * as Redis from "./Redis.ts"
@@ -217,7 +218,7 @@ export type ErrorTypeId = "~@effect/experimental/PersistedQueue/PersistedQueueEr
  * @category errors
  * @since 4.0.0
  */
-export class PersistedQueueError extends Schema.ErrorClass<PersistedQueueError>(
+export class PersistedQueueError extends Schema.Error<PersistedQueueError>(
   "effect/persistence/PersistedQueue/PersistedQueueError"
 )({
   _tag: Schema.tag("PersistedQueueError"),
@@ -245,7 +246,7 @@ export class PersistedQueueError extends Schema.ErrorClass<PersistedQueueError>(
  * The store persists offered elements and returns taken elements in a scope so
  * the finalizer can complete or retry them based on the processing exit.
  *
- * @category store
+ * @category services
  * @since 4.0.0
  */
 export class PersistedQueueStore extends Context.Service<
@@ -283,7 +284,7 @@ export class PersistedQueueStore extends Context.Service<
  * The store is process-local and volatile; failed takes are requeued until the
  * configured maximum attempts is reached.
  *
- * @category store
+ * @category layers
  * @since 4.0.0
  */
 export const layerStoreMemory: Layer.Layer<
@@ -294,9 +295,9 @@ export const layerStoreMemory: Layer.Layer<
     attempts: number
     readonly element: unknown
   }
-  const ids = new Set<string>()
   const queues = new Map<string, {
     latch: Latch.Latch
+    ids: Set<string>
     items: Set<Entry>
   }>()
   const getOrCreateQueue = (name: string) => {
@@ -304,6 +305,7 @@ export const layerStoreMemory: Layer.Layer<
     if (!queue) {
       queue = {
         latch: Latch.makeUnsafe(false),
+        ids: new Set(),
         items: new Set()
       }
       queues.set(name, queue)
@@ -314,9 +316,9 @@ export const layerStoreMemory: Layer.Layer<
   return PersistedQueueStore.of({
     offer: (options) =>
       Effect.sync(() => {
-        if (ids.has(options.id)) return
-        ids.add(options.id)
         const queue = getOrCreateQueue(options.name)
+        if (queue.ids.has(options.id)) return
+        queue.ids.add(options.id)
         queue.items.add({ id: options.id, attempts: 0, element: options.element })
         queue.latch.openUnsafe()
       }),
@@ -357,7 +359,7 @@ export const layerStoreMemory: Layer.Layer<
  * refreshes locks while items are being processed, and moves exhausted items
  * to a failed queue.
  *
- * @category store
+ * @category constructors
  * @since 4.0.0
  */
 export const makeStoreRedis = Effect.fnUntraced(function*(
@@ -720,7 +722,7 @@ end
 /**
  * Provides a Redis-backed `PersistedQueueStore` using `makeStoreRedis`.
  *
- * @category store
+ * @category layers
  * @since 4.0.0
  */
 export const layerStoreRedis: (
@@ -745,7 +747,7 @@ export const layerStoreRedis: (
  * per-worker locks, refreshes active locks while scoped takes are running, and
  * retries or completes rows according to the processing exit.
  *
- * @category store
+ * @category constructors
  * @since 4.0.0
  */
 export const makeStoreSql: (
@@ -778,6 +780,13 @@ export const makeStoreSql: (
   const lockExpirationSql = sql.literal(Math.ceil(Duration.toSeconds(lockExpiration)).toString())
   const workerId = crypto.randomUUID()
 
+  yield* Effect.orDie(
+    Migrator.make({})({
+      loader: sqlMigrations(tableName),
+      table: `${tableName}_migrations`
+    })
+  )
+
   const sqlNow = sql.onDialectOrElse({
     mssql: () => sql.literal("GETDATE()"),
     mysql: () => sql.literal("NOW()"),
@@ -793,108 +802,12 @@ export const makeStoreSql: (
     orElse: () => sql`datetime(${sqlNow}, '-${lockExpirationSql} seconds')`
   })
 
-  yield* sql.onDialectOrElse({
-    mysql: () =>
-      sql`CREATE TABLE IF NOT EXISTS ${tableNameSql} (
-        sequence BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
-        id VARCHAR(36) NOT NULL,
-        queue_name VARCHAR(100) NOT NULL,
-        element TEXT NOT NULL,
-        completed BOOLEAN NOT NULL,
-        attempts INT NOT NULL DEFAULT 0,
-        last_failure TEXT NULL,
-        acquired_at DATETIME NULL,
-        acquired_by VARCHAR(36) NULL,
-        created_at DATETIME NOT NULL,
-        updated_at DATETIME NOT NULL
-      )`,
-    pg: () =>
-      sql`CREATE TABLE IF NOT EXISTS ${tableNameSql} (
-        sequence SERIAL PRIMARY KEY,
-        id VARCHAR(36) NOT NULL,
-        queue_name VARCHAR(100) NOT NULL,
-        element TEXT NOT NULL,
-        completed BOOLEAN NOT NULL,
-        attempts INTEGER NOT NULL DEFAULT 0,
-        last_failure TEXT NULL,
-        acquired_at TIMESTAMP NULL,
-        acquired_by UUID NULL,
-        created_at TIMESTAMP NOT NULL,
-        updated_at TIMESTAMP NOT NULL
-      )`,
-    mssql: () =>
-      sql`IF NOT EXISTS (SELECT * FROM sysobjects WHERE name=${tableNameSql} AND xtype='U')
-      CREATE TABLE ${tableNameSql} (
-        sequence INT IDENTITY(1,1) PRIMARY KEY,
-        id NVARCHAR(36) NOT NULL,
-        queue_name NVARCHAR(100) NOT NULL,
-        element NVARCHAR(MAX) NOT NULL,
-        completed BIT NOT NULL,
-        attempts INT NOT NULL DEFAULT 0,
-        last_failure NVARCHAR(MAX) NULL,
-        acquired_at DATETIME2 NULL,
-        acquired_by UNIQUEIDENTIFIER NULL,
-        created_at DATETIME2 NOT NULL,
-        updated_at DATETIME2 NOT NULL
-      )`,
-    // sqlite
-    orElse: () =>
-      sql`CREATE TABLE IF NOT EXISTS ${tableNameSql} (
-        sequence INTEGER PRIMARY KEY AUTOINCREMENT,
-        id TEXT NOT NULL,
-        queue_name TEXT NOT NULL,
-        element TEXT NOT NULL,
-        completed BOOLEAN NOT NULL,
-        attempts INTEGER NOT NULL DEFAULT 0,
-        last_failure TEXT NULL,
-        acquired_at DATETIME NULL,
-        acquired_by TEXT NULL,
-        created_at DATETIME NOT NULL,
-        updated_at DATETIME NOT NULL
-      )`
-  })
-
-  yield* sql.onDialectOrElse({
-    mssql: () =>
-      sql`IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = N'idx_${tableName}_id')
-        CREATE UNIQUE INDEX idx_${tableNameSql}_id ON ${tableNameSql} (id)`,
-    mysql: () => sql`CREATE UNIQUE INDEX ${sql(`idx_${tableName}_id`)} ON ${tableNameSql} (id)`.pipe(Effect.ignore),
-    orElse: () => sql`CREATE UNIQUE INDEX IF NOT EXISTS ${sql(`idx_${tableName}_id`)} ON ${tableNameSql} (id)`
-  })
-
-  yield* sql.onDialectOrElse({
-    mssql: () =>
-      sql`IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = N'idx_${tableName}_take')
-        CREATE INDEX idx_${tableNameSql}_take ON ${tableNameSql} (queue_name, completed, attempts, acquired_at)`,
-    mysql: () =>
-      sql`CREATE INDEX ${
-        sql(`idx_${tableName}_take`)
-      } ON ${tableNameSql} (queue_name, completed, attempts, acquired_at)`
-        .pipe(Effect.ignore),
-    orElse: () =>
-      sql`CREATE INDEX IF NOT EXISTS ${
-        sql(`idx_${tableName}_take`)
-      } ON ${tableNameSql} (queue_name, completed, attempts, acquired_at)`
-  })
-
-  yield* sql.onDialectOrElse({
-    mssql: () =>
-      sql`IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = N'idx_${tableName}_update')
-        CREATE INDEX ${sql(`idx_${tableName}_update`)} ON ${tableNameSql} (sequence, acquired_by)`,
-    mysql: () =>
-      sql`CREATE INDEX ${sql(`idx_${tableName}_update`)} ON ${tableNameSql} (sequence, acquired_by)`.pipe(
-        Effect.ignore
-      ),
-    orElse: () =>
-      sql`CREATE INDEX IF NOT EXISTS ${sql(`idx_${tableName}_update`)} ON ${tableNameSql} (sequence, acquired_by)`
-  })
-
   const offer = sql.onDialectOrElse({
     pg: () => (id: string, name: string, element: string) =>
       sql`
         INSERT INTO ${tableNameSql} (id, queue_name, element, completed, attempts, created_at, updated_at)
         VALUES (${id}, ${name}, ${element}, FALSE, 0, ${sqlNow}, ${sqlNow})
-        ON CONFLICT (id) DO NOTHING
+        ON CONFLICT (id, queue_name) DO NOTHING
       `,
     mysql: () => (id: string, name: string, element: string) =>
       sql`
@@ -903,7 +816,7 @@ export const makeStoreSql: (
       `,
     mssql: () => (id: string, name: string, element: string) =>
       sql`
-        IF NOT EXISTS (SELECT 1 FROM ${tableNameSql} WHERE id = ${id})
+        IF NOT EXISTS (SELECT 1 FROM ${tableNameSql} WHERE id = ${id} AND queue_name = ${name})
         BEGIN
           INSERT INTO ${tableNameSql} (id, queue_name, element, completed, attempts, created_at, updated_at)
           VALUES (${id}, ${name}, ${element}, 0, 0, ${sqlNow}, ${sqlNow})
@@ -1173,6 +1086,114 @@ export const makeStoreSql: (
   })
 })
 
+const sqlMigrations = (tableName: string) =>
+  Migrator.fromRecord({
+    "0001_create_table": Effect.gen(function*() {
+      const sql = (yield* SqlClient.SqlClient).withoutTransforms()
+      const tableNameSql = sql(tableName)
+
+      yield* sql.onDialectOrElse({
+        mysql: () =>
+          sql`CREATE TABLE IF NOT EXISTS ${tableNameSql} (
+            sequence BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+            id VARCHAR(36) NOT NULL,
+            queue_name VARCHAR(100) NOT NULL,
+            element TEXT NOT NULL,
+            completed BOOLEAN NOT NULL,
+            attempts INT NOT NULL DEFAULT 0,
+            last_failure TEXT NULL,
+            acquired_at DATETIME NULL,
+            acquired_by VARCHAR(36) NULL,
+            created_at DATETIME NOT NULL,
+            updated_at DATETIME NOT NULL
+          )`,
+        pg: () =>
+          sql`CREATE TABLE IF NOT EXISTS ${tableNameSql} (
+            sequence SERIAL PRIMARY KEY,
+            id VARCHAR(36) NOT NULL,
+            queue_name VARCHAR(100) NOT NULL,
+            element TEXT NOT NULL,
+            completed BOOLEAN NOT NULL,
+            attempts INTEGER NOT NULL DEFAULT 0,
+            last_failure TEXT NULL,
+            acquired_at TIMESTAMP NULL,
+            acquired_by UUID NULL,
+            created_at TIMESTAMP NOT NULL,
+            updated_at TIMESTAMP NOT NULL
+          )`,
+        mssql: () =>
+          sql`IF NOT EXISTS (SELECT * FROM sysobjects WHERE name=${tableNameSql} AND xtype='U')
+          CREATE TABLE ${tableNameSql} (
+            sequence INT IDENTITY(1,1) PRIMARY KEY,
+            id NVARCHAR(36) NOT NULL,
+            queue_name NVARCHAR(100) NOT NULL,
+            element NVARCHAR(MAX) NOT NULL,
+            completed BIT NOT NULL,
+            attempts INT NOT NULL DEFAULT 0,
+            last_failure NVARCHAR(MAX) NULL,
+            acquired_at DATETIME2 NULL,
+            acquired_by UNIQUEIDENTIFIER NULL,
+            created_at DATETIME2 NOT NULL,
+            updated_at DATETIME2 NOT NULL
+          )`,
+        // sqlite
+        orElse: () =>
+          sql`CREATE TABLE IF NOT EXISTS ${tableNameSql} (
+            sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+            id TEXT NOT NULL,
+            queue_name TEXT NOT NULL,
+            element TEXT NOT NULL,
+            completed BOOLEAN NOT NULL,
+            attempts INTEGER NOT NULL DEFAULT 0,
+            last_failure TEXT NULL,
+            acquired_at DATETIME NULL,
+            acquired_by TEXT NULL,
+            created_at DATETIME NOT NULL,
+            updated_at DATETIME NOT NULL
+          )`
+      })
+
+      yield* sql.onDialectOrElse({
+        mssql: () =>
+          sql`IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = N'idx_${tableName}_id')
+            CREATE UNIQUE INDEX idx_${tableNameSql}_id ON ${tableNameSql} (id, queue_name)`,
+        mysql: () =>
+          sql`CREATE UNIQUE INDEX ${sql(`idx_${tableName}_id`)} ON ${tableNameSql} (id, queue_name)`.pipe(
+            Effect.ignore
+          ),
+        orElse: () =>
+          sql`CREATE UNIQUE INDEX IF NOT EXISTS ${sql(`idx_${tableName}_id`)} ON ${tableNameSql} (id, queue_name)`
+      })
+
+      yield* sql.onDialectOrElse({
+        mssql: () =>
+          sql`IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = N'idx_${tableName}_take')
+            CREATE INDEX idx_${tableNameSql}_take ON ${tableNameSql} (queue_name, completed, attempts, acquired_at)`,
+        mysql: () =>
+          sql`CREATE INDEX ${
+            sql(`idx_${tableName}_take`)
+          } ON ${tableNameSql} (queue_name, completed, attempts, acquired_at)`
+            .pipe(Effect.ignore),
+        orElse: () =>
+          sql`CREATE INDEX IF NOT EXISTS ${
+            sql(`idx_${tableName}_take`)
+          } ON ${tableNameSql} (queue_name, completed, attempts, acquired_at)`
+      })
+
+      yield* sql.onDialectOrElse({
+        mssql: () =>
+          sql`IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = N'idx_${tableName}_update')
+            CREATE INDEX ${sql(`idx_${tableName}_update`)} ON ${tableNameSql} (sequence, acquired_by)`,
+        mysql: () =>
+          sql`CREATE INDEX ${sql(`idx_${tableName}_update`)} ON ${tableNameSql} (sequence, acquired_by)`.pipe(
+            Effect.ignore
+          ),
+        orElse: () =>
+          sql`CREATE INDEX IF NOT EXISTS ${sql(`idx_${tableName}_update`)} ON ${tableNameSql} (sequence, acquired_by)`
+      })
+    })
+  })
+
 class QueueKey extends Data.Class<{
   readonly name: string
   readonly maxAttempts: number
@@ -1181,7 +1202,7 @@ class QueueKey extends Data.Class<{
 /**
  * Provides a SQL-backed `PersistedQueueStore` using `makeStoreSql`.
  *
- * @category store
+ * @category layers
  * @since 4.0.0
  */
 export const layerStoreSql: (