@effect/cluster 0.36.3 → 0.37.1

package/src/Message.ts

@@ -1,7 +1,7 @@
 /**
  * @since 1.0.0
  */
-import type * as Rpc from "@effect/rpc/Rpc"
+import * as Rpc from "@effect/rpc/Rpc"
 import type { Context } from "effect/Context"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
@@ -10,8 +10,10 @@ import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
 import type { PersistenceError } from "./ClusterError.js"
 import { MalformedMessage } from "./ClusterError.js"
+import type { EntityAddress } from "./EntityAddress.js"
 import * as Envelope from "./Envelope.js"
 import type * as Reply from "./Reply.js"
+import type { Snowflake } from "./Snowflake.js"
 
 /**
  * @since 1.0.0
@@ -99,7 +101,27 @@ export class OutgoingRequest<R extends Rpc.Any> extends Data.TaggedClass("Outgoi
 export class OutgoingEnvelope extends Data.TaggedClass("OutgoingEnvelope")<{
   readonly envelope: Envelope.AckChunk | Envelope.Interrupt
   readonly rpc: Rpc.AnyWithProps
-}> {}
+}> {
+  /**
+   * @since 1.0.0
+   */
+  static interrupt(options: {
+    readonly address: EntityAddress
+    readonly id: Snowflake
+    readonly requestId: Snowflake
+  }): OutgoingEnvelope {
+    return new OutgoingEnvelope({
+      envelope: new Envelope.Interrupt(options),
+      rpc: neverRpc
+    })
+  }
+}
+
+const neverRpc = Rpc.make("Never", {
+  success: Schema.Never as any,
+  error: Schema.Never,
+  payload: {}
+})
 
 /**
  * @since 1.0.0

package/src/MessageStorage.ts

@@ -52,6 +52,11 @@ export class MessageStorage extends Context.Tag("@effect/cluster/MessageStorage"
     reply: Reply.ReplyWithContext<R>
   ) => Effect.Effect<void, PersistenceError | MalformedMessage>
 
+  /**
+   * Clear the `Reply`s for the given request id.
+   */
+  readonly clearReplies: (requestId: Snowflake.Snowflake) => Effect.Effect<void, PersistenceError>
+
   /**
    * Retrieves the replies for the specified requests.
    *
@@ -62,6 +67,24 @@ export class MessageStorage extends Context.Tag("@effect/cluster/MessageStorage"
     requests: Iterable<Message.OutgoingRequest<R>>
   ) => Effect.Effect<Array<Reply.Reply<R>>, PersistenceError | MalformedMessage>
 
+  /**
+   * Retrieves the encoded replies for the specified request ids.
+   */
+  readonly repliesForUnfiltered: <R extends Rpc.Any>(
+    requestIds: Iterable<Snowflake.Snowflake>
+  ) => Effect.Effect<Array<Reply.ReplyEncoded<R>>, PersistenceError | MalformedMessage>
+
+  /**
+   * Retrieves the request id for the specified primary key.
+   */
+  readonly requestIdForPrimaryKey: (
+    options: {
+      readonly address: EntityAddress
+      readonly tag: string
+      readonly id: string
+    }
+  ) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>
+
   /**
    * For locally sent messages, register a handler to process the replies.
    */
@@ -103,6 +126,13 @@ export class MessageStorage extends Context.Tag("@effect/cluster/MessageStorage"
   readonly resetAddress: (
     address: EntityAddress
   ) => Effect.Effect<void, PersistenceError>
+
+  /**
+   * Clear all messages and replies for the provided address.
+   */
+  readonly clearAddress: (
+    address: EntityAddress
+  ) => Effect.Effect<void, PersistenceError>
 }>() {}
 
 /**
@@ -194,6 +224,18 @@ export type Encoded = {
     reply: Reply.ReplyEncoded<any>
   ) => Effect.Effect<void, PersistenceError>
 
+  /**
+   * Remove the replies for the specified request.
+   */
+  readonly clearReplies: (requestId: Snowflake.Snowflake) => Effect.Effect<void, PersistenceError>
+
+  /**
+   * Retrieves the request id for the specified primary key.
+   */
+  readonly requestIdForPrimaryKey: (
+    primaryKey: string
+  ) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>
+
   /**
    * Retrieves the replies for the specified requests.
    *
@@ -205,6 +247,14 @@ export type Encoded = {
     PersistenceError
   >
 
+  /**
+   * Retrieves the replies for the specified request ids.
+   */
+  readonly repliesForUnfiltered: (requestIds: Array<string>) => Effect.Effect<
+    Array<Reply.ReplyEncoded<any>>,
+    PersistenceError
+  >
+
   /**
    * Retrieves the unprocessed messages for the given shards.
    *
@@ -247,6 +297,13 @@ export type Encoded = {
     address: EntityAddress
   ) => Effect.Effect<void, PersistenceError>
 
+  /**
+   * Clear all messages and replies for the provided address.
+   */
+  readonly clearAddress: (
+    address: EntityAddress
+  ) => Effect.Effect<void, PersistenceError>
+
   /**
    * Reset the mailbox state for the provided shards.
    */
@@ -362,6 +419,7 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
         Effect.asVoid
       ),
     saveReply: (reply) => Effect.flatMap(Reply.serialize(reply), encoded.saveReply),
+    clearReplies: encoded.clearReplies,
     repliesFor: Effect.fnUntraced(function*(messages) {
       const requestIds = Arr.empty<string>()
       const map = new Map<string, Message.OutgoingRequest<any>>()
@@ -374,6 +432,11 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
       const encodedReplies = yield* encoded.repliesFor(requestIds)
       return yield* decodeReplies(map, encodedReplies)
     }),
+    repliesForUnfiltered: (ids) => encoded.repliesForUnfiltered(Array.from(ids, String)),
+    requestIdForPrimaryKey(options) {
+      const primaryKey = Envelope.primaryKeyByAddress(options)
+      return encoded.requestIdForPrimaryKey(primaryKey)
+    },
     unprocessedMessages: (shardIds) => {
       const shards = Array.from(shardIds)
       if (shards.length === 0) return Effect.succeed([])
@@ -390,7 +453,8 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
         decodeMessages
       )
     },
-    resetAddress: (address) => encoded.resetAddress(address),
+    resetAddress: encoded.resetAddress,
+    clearAddress: encoded.clearAddress,
     resetShards: (shardIds) => encoded.resetShards(Array.from(shardIds))
   })
 
@@ -506,10 +570,14 @@ export const noop: MessageStorage["Type"] = globalValue(
       saveRequest: () => Effect.succeed(SaveResult.Success()),
       saveEnvelope: () => Effect.void,
       saveReply: () => Effect.void,
+      clearReplies: () => Effect.void,
       repliesFor: () => Effect.succeed([]),
+      repliesForUnfiltered: () => Effect.succeed([]),
+      requestIdForPrimaryKey: () => Effect.succeedNone,
       unprocessedMessages: () => Effect.succeed([]),
       unprocessedMessagesById: () => Effect.succeed([]),
       resetAddress: () => Effect.void,
+      clearAddress: () => Effect.void,
       resetShards: () => Effect.void
     }))
 )
@@ -567,9 +635,31 @@ export class MemoryDriver extends Effect.Service<MemoryDriver>()("@effect/cluste
 
     const replyLatch = yield* Effect.makeLatch()
 
+    function repliesFor(requestIds: Array<string>) {
+      const replies = Arr.empty<Reply.ReplyEncoded<any>>()
+      for (const requestId of requestIds) {
+        const request = requests.get(requestId)
+        if (!request) continue
+        else if (Option.isNone(request.lastReceivedChunk)) {
+          // eslint-disable-next-line no-restricted-syntax
+          replies.push(...request.replies)
+          continue
+        }
+        const sequence = request.lastReceivedChunk.value.sequence
+        for (const reply of request.replies) {
+          if (reply._tag === "Chunk" && reply.sequence <= sequence) {
+            continue
+          }
+          replies.push(reply)
+        }
+      }
+      return replies
+    }
+
     const encoded: Encoded = {
-      saveEnvelope: ({ envelope, primaryKey }) =>
+      saveEnvelope: ({ envelope: envelope_, primaryKey }) =>
         Effect.sync(() => {
+          const envelope = JSON.parse(JSON.stringify(envelope_)) as Envelope.Envelope.Encoded
           const existing = primaryKey
             ? requestsByPrimaryKey.get(primaryKey)
             : envelope._tag === "Request" && requests.get(envelope.requestId)
@@ -598,8 +688,9 @@ export class MemoryDriver extends Effect.Service<MemoryDriver>()("@effect/cluste
           journal.push(envelope)
           return SaveResultEncoded.Success()
         }),
-      saveReply: (reply) =>
+      saveReply: (reply_) =>
         Effect.sync(() => {
+          const reply = JSON.parse(JSON.stringify(reply_)) as Reply.ReplyEncoded<any>
           const entry = requests.get(reply.requestId)
           if (!entry || replyIds.has(reply.id)) return
           if (reply._tag === "WithExit") {
@@ -609,27 +700,22 @@ export class MemoryDriver extends Effect.Service<MemoryDriver>()("@effect/cluste
           replyIds.add(reply.id)
           replyLatch.unsafeOpen()
         }),
-      repliesFor: (requestIds) =>
+      clearReplies: (id) =>
         Effect.sync(() => {
-          const replies = Arr.empty<Reply.ReplyEncoded<any>>()
-          for (const requestId of requestIds) {
-            const request = requests.get(requestId)
-            if (!request) continue
-            else if (Option.isNone(request.lastReceivedChunk)) {
-              // eslint-disable-next-line no-restricted-syntax
-              replies.push(...request.replies)
-              continue
-            }
-            const sequence = request.lastReceivedChunk.value.sequence
-            for (const reply of request.replies) {
-              if (reply._tag === "Chunk" && reply.sequence <= sequence) {
-                continue
-              }
-              replies.push(reply)
-            }
-          }
-          return replies
+          const entry = requests.get(String(id))
+          if (!entry) return
+          entry.replies = []
+          entry.lastReceivedChunk = Option.none()
+          unprocessed.add(entry.envelope)
         }),
+      requestIdForPrimaryKey: (primaryKey) =>
+        Effect.sync(() => {
+          const entry = requestsByPrimaryKey.get(primaryKey)
+          return Option.fromNullable(entry?.envelope.requestId).pipe(Option.map(Snowflake.Snowflake))
+        }),
+      repliesFor: (requestIds) => Effect.sync(() => repliesFor(requestIds)),
+      repliesForUnfiltered: (requestIds) =>
+        Effect.sync(() => requestIds.flatMap((id) => requests.get(String(id))?.replies ?? [])),
       unprocessedMessages: (shardIds) =>
         Effect.sync(() => {
           if (unprocessed.size === 0) return []
@@ -667,6 +753,20 @@ export class MemoryDriver extends Effect.Service<MemoryDriver>()("@effect/cluste
           return unprocessedWith((envelope) => envelopeIds.has(envelope.requestId))
         }),
       resetAddress: () => Effect.void,
+      clearAddress: (address) =>
+        Effect.sync(() => {
+          for (let i = journal.length - 1; i >= 0; i--) {
+            const envelope = journal[i]
+            const sameAddress = address.entityType === envelope.address.entityType &&
+              address.entityId === envelope.address.entityId
+            if (!sameAddress || envelope._tag !== "Request") {
+              continue
+            }
+            unprocessed.delete(envelope)
+            requests.delete(envelope.requestId)
+            journal.splice(i, 1)
+          }
+        }),
       resetShards: () => Effect.void
     }
 

package/src/Reply.ts

@@ -8,6 +8,7 @@ import * as Context from "effect/Context"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
+import * as FiberId from "effect/FiberId"
 import * as FiberRef from "effect/FiberRef"
 import { identity } from "effect/Function"
 import type * as Option from "effect/Option"
@@ -68,6 +69,23 @@ export class ReplyWithContext<R extends Rpc.Any> extends Data.TaggedClass("Reply
       rpc: neverRpc
     })
   }
+  /**
+   * @since 1.0.0
+   */
+  static interrupt(options: {
+    readonly id: Snowflake
+    readonly requestId: Snowflake
+  }): ReplyWithContext<any> {
+    return new ReplyWithContext({
+      reply: new WithExit({
+        requestId: options.requestId,
+        id: options.id,
+        exit: Exit.interrupt(FiberId.none)
+      }),
+      context: Context.empty() as any,
+      rpc: neverRpc
+    })
+  }
 }
 
 const neverRpc = Rpc.make("Never", {

package/src/Runners.ts

@@ -312,7 +312,7 @@ export const make: (options: Omit<Runners["Type"], "sendLocal" | "notifyLocal">)
     notify(options_) {
       const { discard, message } = options_
       return notifyWith(message, (message, duplicate) => {
-        if (message._tag === "OutgoingEnvelope") {
+        if (discard || message._tag === "OutgoingEnvelope") {
           return options.notify(options_)
         } else if (!duplicate && options_.address._tag === "Some") {
           return Effect.catchAll(
@@ -328,7 +328,7 @@ export const make: (options: Omit<Runners["Type"], "sendLocal" | "notifyLocal">)
             }
           )
         }
-        return discard ? options.notify(options_) : options.notify(options_).pipe(
+        return options.notify(options_).pipe(
           Effect.andThen(replyFromStorage(message))
         )
       })

package/src/Sharding.ts

@@ -35,7 +35,7 @@ import {
   EntityNotManagedByRunner,
   RunnerUnavailable
 } from "./ClusterError.js"
-import { Persisted } from "./ClusterSchema.js"
+import { Persisted, Uninterruptible } from "./ClusterSchema.js"
 import type { CurrentAddress, CurrentRunnerAddress, Entity, HandlersFrom } from "./Entity.js"
 import { EntityAddress } from "./EntityAddress.js"
 import { EntityId } from "./EntityId.js"
@@ -126,6 +126,17 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
     EntityNotManagedByRunner | EntityNotAssignedToRunner | MailboxFull | AlreadyProcessingMessage
   >
 
+  /**
+   * Sends an outgoing message
+   */
+  readonly sendOutgoing: (
+    message: Message.Outgoing<any>,
+    discard: boolean
+  ) => Effect.Effect<
+    void,
+    EntityNotManagedByRunner | MailboxFull | AlreadyProcessingMessage | PersistenceError
+  >
+
   /**
    * Notify sharding that a message has been persisted to storage.
    */
@@ -134,6 +145,11 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
     EntityNotManagedByRunner | EntityNotAssignedToRunner | AlreadyProcessingMessage
   >
 
+  /**
+   * Reset the state of a message
+   */
+  readonly reset: (requestId: Snowflake.Snowflake) => Effect.Effect<boolean>
+
   /**
    * Retrieves the active entity count for the current runner.
    */
@@ -247,7 +263,7 @@ const make = Effect.gen(function*() {
       Effect.forkIn(shardingScope)
     )
 
-    // refresh the shard locks every 10s
+    // refresh the shard locks every 4s
     yield* Effect.suspend(() =>
       shardStorage.refresh(selfAddress, [
         ...acquiredShards,
@@ -270,14 +286,14 @@ const make = Effect.gen(function*() {
       }),
       Effect.retry({
         times: 5,
-        schedule: Schedule.spaced(250)
+        schedule: Schedule.spaced(50)
       }),
       Effect.catchAllCause((cause) =>
         Effect.logError("Could not refresh shard locks", cause).pipe(
           Effect.andThen(clearSelfShards)
         )
       ),
-      Effect.delay("10 seconds"),
+      Effect.delay("4 seconds"),
       Effect.forever,
       Effect.interruptible,
       Effect.forkIn(shardingScope)
@@ -384,6 +400,11 @@ const make = Effect.gen(function*() {
 
   let storageAlreadyProcessed = (_message: Message.IncomingRequest<any>) => true
 
+  // keep track of the last sent request ids to avoid duplicates
+  // we only keep the last 30 sets to avoid memory leaks
+  const sentRequestIds = new Set<Snowflake.Snowflake>()
+  const sentRequestIdSets = new Set<Set<Snowflake.Snowflake>>()
+
   if (storageEnabled && Option.isSome(config.runnerAddress)) {
     const selfAddress = config.runnerAddress.value
 
@@ -391,10 +412,8 @@ const make = Effect.gen(function*() {
       yield* Effect.logDebug("Starting")
       yield* Effect.addFinalizer(() => Effect.logDebug("Shutting down"))
 
-      // keep track of the last sent request ids to avoid duplicates
-      // we only keep the last 30 sets to avoid memory leaks
-      const sentRequestIds = new Set<Snowflake.Snowflake>()
-      const sentRequestIdSets = new Set<Set<Snowflake.Snowflake>>()
+      sentRequestIds.clear()
+      sentRequestIdSets.clear()
 
       storageAlreadyProcessed = (message: Message.IncomingRequest<any>) => {
         if (!sentRequestIds.has(message.envelope.requestId)) {
@@ -755,6 +774,17 @@ const make = Effect.gen(function*() {
     )
   }
 
+  const reset: Sharding["Type"]["reset"] = Effect.fnUntraced(
+    function*(requestId) {
+      yield* storage.clearReplies(requestId)
+      sentRequestIds.delete(requestId)
+    },
+    Effect.matchCause({
+      onSuccess: () => true,
+      onFailure: () => false
+    })
+  )
+
   // --- Shard Manager sync ---
 
   const shardManagerTimeoutFiber = yield* FiberHandle.make().pipe(
@@ -903,6 +933,7 @@ const make = Effect.gen(function*() {
     never
   > = yield* ResourceMap.make(Effect.fnUntraced(function*(entity: Entity<any>) {
     const client = yield* RpcClient.makeNoSerialization(entity.protocol, {
+      spanPrefix: `${entity.type}.client`,
       supportsAck: true,
       generateRequestId: () => RequestId(snowflakeGen.unsafeNext()),
       onFromClient(options): Effect.Effect<
@@ -968,6 +999,9 @@ const make = Effect.gen(function*() {
             const entry = clientRequests.get(requestId)!
             if (!entry) return Effect.void
             clientRequests.delete(requestId)
+            if (Context.get(entry.rpc.annotations, Uninterruptible)) {
+              return Effect.void
+            }
             // for durable messages, we ignore interrupts on shutdown or as a
             // result of a shard being resassigned
             const isTransientInterrupt = MutableRef.get(isShutdown) ||
@@ -1148,8 +1182,10 @@ const make = Effect.gen(function*() {
     registerSingleton,
     makeClient,
     send: sendLocal,
+    sendOutgoing: (message, discard) => sendOutgoing(message, discard),
     notify: (message) => notifyLocal(message, false),
-    activeEntityCount
+    activeEntityCount,
+    reset
   })
 
   return sharding

package/src/Snowflake.ts

@@ -145,7 +145,7 @@ export const makeGenerator: Effect.Effect<Snowflake.Generator> = Effect.gen(func
   const clock = yield* Effect.clock
 
   let sequence = 0
-  let sequenceAt = clock.unsafeCurrentTimeMillis()
+  let sequenceAt = Math.floor(clock.unsafeCurrentTimeMillis())
 
   return identity<Snowflake.Generator>({
     setMachineId: (newMachineId) =>
@@ -153,7 +153,7 @@ export const makeGenerator: Effect.Effect<Snowflake.Generator> = Effect.gen(func
         machineId = newMachineId
       }),
     unsafeNext() {
-      let now = clock.unsafeCurrentTimeMillis()
+      let now = Math.floor(clock.unsafeCurrentTimeMillis())
 
       // account for clock drift, only allow time to move forward
       if (now < sequenceAt) {

package/src/SqlMessageStorage.ts

@@ -663,6 +663,28 @@ export const make = Effect.fnUntraced(function*(options?: {
         PersistenceError.refail
       ),
 
+    clearReplies: Effect.fnUntraced(
+      function*(requestId) {
+        yield* sql`DELETE FROM ${repliesTableSql} WHERE request_id = ${String(requestId)}`
+        yield* sql`UPDATE ${messagesTableSql} SET processed = ${sqlFalse}, last_reply_id = NULL, last_read = NULL WHERE request_id = ${
+          String(requestId)
+        }`
+      },
+      sql.withTransaction,
+      PersistenceError.refail
+    ),
+
+    requestIdForPrimaryKey: (primaryKey) =>
+      sql<{ id: string | bigint }>`SELECT id FROM ${messagesTableSql} WHERE message_id = ${primaryKey}`.pipe(
+        Effect.map((rows) =>
+          Option.fromNullable(rows[0]?.id).pipe(
+            Option.map(Snowflake.Snowflake)
+          )
+        ),
+        Effect.provideService(SqlClient.SafeIntegers, true),
+        PersistenceError.refail
+      ),
+
     repliesFor: (requestIds) =>
       // replies where:
       // - the request is in the list
@@ -682,22 +704,20 @@ export const make = Effect.fnUntraced(function*(options?: {
         ORDER BY rowid ASC
       `.unprepared.pipe(
         Effect.provideService(SqlClient.SafeIntegers, true),
-        Effect.map(Arr.map((row): Reply.ReplyEncoded<any> =>
-          Number(row.kind) === replyKind.WithExit ?
-            ({
-              _tag: "WithExit",
-              id: String(row.id),
-              requestId: String(row.request_id),
-              exit: JSON.parse(row.payload)
-            }) :
-            {
-              _tag: "Chunk",
-              id: String(row.id),
-              requestId: String(row.request_id),
-              values: JSON.parse(row.payload),
-              sequence: Number(row.sequence!)
-            }
-        )),
+        Effect.map(Arr.map(replyFromRow)),
+        PersistenceError.refail,
+        withTracerDisabled
+      ),
+
+    repliesForUnfiltered: (requestIds) =>
+      sql<ReplyRow>`
+        SELECT id, kind, request_id, payload, sequence
+        FROM ${repliesTableSql}
+        WHERE request_id IN (${sql.literal(requestIds.join(","))})
+        ORDER BY rowid ASC
+      `.unprepared.pipe(
+        Effect.provideService(SqlClient.SafeIntegers, true),
+        Effect.map(Arr.map(replyFromRow)),
         PersistenceError.refail,
         withTracerDisabled
       ),
@@ -761,6 +781,28 @@ export const make = Effect.fnUntraced(function*(options?: {
         withTracerDisabled
       ),
 
+    clearAddress: (address) =>
+      sql`
+        DELETE FROM ${repliesTableSql}
+        WHERE request_id IN (
+          SELECT id FROM ${messagesTableSql}
+          WHERE entity_type = ${address.entityType}
+          AND entity_id = ${address.entityId}
+        )
+      `.pipe(
+        Effect.andThen(
+          sql`
+            DELETE FROM ${messagesTableSql}
+            WHERE entity_type = ${address.entityType}
+            AND entity_id = ${address.entityId}
+          `
+        ),
+        sql.withTransaction,
+        Effect.asVoid,
+        PersistenceError.refail,
+        withTracerDisabled
+      ),
+
     resetShards: (shardIds) =>
       sql`
         UPDATE ${messagesTableSql}
@@ -814,6 +856,22 @@ const replyKind = {
   "Chunk": null
 } as const satisfies Record<Reply.Reply<any>["_tag"], number | null>
 
+const replyFromRow = (row: ReplyRow): Reply.ReplyEncoded<any> =>
+  Number(row.kind) === replyKind.WithExit ?
+    {
+      _tag: "WithExit",
+      id: String(row.id),
+      requestId: String(row.request_id),
+      exit: JSON.parse(row.payload)
+    } :
+    {
+      _tag: "Chunk",
+      id: String(row.id),
+      requestId: String(row.request_id),
+      values: JSON.parse(row.payload),
+      sequence: Number(row.sequence!)
+    }
+
 type MessageRow = {
   readonly id: string | bigint
   readonly message_id: string | null

package/src/SqlShardStorage.ts

@@ -143,10 +143,10 @@ export const make = Effect.fnUntraced(function*(options?: {
   const sqlNow = sql.literal(sqlNowString)
 
   const lockExpiresAt = sql.onDialectOrElse({
-    pg: () => sql`${sqlNow} - INTERVAL '15 seconds'`,
-    mysql: () => sql`DATE_SUB(${sqlNow}, INTERVAL 15 SECOND)`,
-    mssql: () => sql`DATEADD(SECOND, -15, ${sqlNow})`,
-    orElse: () => sql`datetime(${sqlNow}, '-15 seconds')`
+    pg: () => sql`${sqlNow} - INTERVAL '5 seconds'`,
+    mysql: () => sql`DATE_SUB(${sqlNow}, INTERVAL 5 SECOND)`,
+    mssql: () => sql`DATEADD(SECOND, -5, ${sqlNow})`,
+    orElse: () => sql`datetime(${sqlNow}, '-5 seconds')`
   })
 
   const acquireLock = sql.onDialectOrElse({
@@ -170,7 +170,7 @@ export const make = Effect.fnUntraced(function*(options?: {
         MERGE ${locksTableSql} WITH (HOLDLOCK) AS target
         USING (SELECT * FROM (VALUES ${sql.csv(values)})) AS source (shard_id, address, acquired_at)
         ON target.shard_id = source.shard_id
-        WHEN MATCHED AND (target.address = source.address OR DATEDIFF(SECOND, target.acquired_at, ${sqlNow}) > 15) THEN
+        WHEN MATCHED AND (target.address = source.address OR DATEDIFF(SECOND, target.acquired_at, ${sqlNow}) > 5) THEN
           UPDATE SET address = source.address, acquired_at = source.acquired_at
         WHEN NOT MATCHED THEN
           INSERT (shard_id, address, acquired_at)
@@ -187,7 +187,7 @@ export const make = Effect.fnUntraced(function*(options?: {
           SELECT 1 FROM ${locksTableSql}
           WHERE shard_id = source.shard_id
           AND address != ${address}
-          AND (strftime('%s', ${sqlNow}) - strftime('%s', acquired_at)) <= 15
+          AND (strftime('%s', ${sqlNow}) - strftime('%s', acquired_at)) <= 5
         )
         ON CONFLICT(shard_id) DO UPDATE
         SET address = ${address}, acquired_at = ${sqlNow}

package/src/index.ts

@@ -13,6 +13,11 @@ export * as ClusterMetrics from "./ClusterMetrics.js"
  */
 export * as ClusterSchema from "./ClusterSchema.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as ClusterWorkflowEngine from "./ClusterWorkflowEngine.js"
+
 /**
  * @since 1.0.0
  */