effect-distributed-lock 0.0.9 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-distributed-lock",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "A distributed semaphore library for Effect with pluggable backends",
   "license": "MIT",
   "repository": {

package/src/Backing.ts

@@ -74,8 +74,7 @@ export interface DistributedSemaphoreBacking {
   /**
    * Optional: Stream of notifications when permits MAY be available.
    *
-   * If provided, the semaphore layer uses this for efficient waiting instead
-   * of polling. The stream emits a signal whenever permits are released.
+   * If provided, the semaphore layer uses this in addition to polling. The stream emits a signal whenever permits are released.
    *
    * Notes:
    * - Multiple waiters may race for permits after a notification

package/src/DistributedSemaphore.ts

@@ -153,7 +153,11 @@ export interface DistributedSemaphore {
     options?: AcquireOptions
   ) => <A, E, R>(
     effect: Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E | LockLostError | SemaphoreBackingError | LockNotAcquiredError, R>;
+  ) => Effect.Effect<
+    A,
+    E | LockLostError | SemaphoreBackingError | LockNotAcquiredError,
+    R
+  >;
 
   /**
    * Run an effect only if the specified permits are immediately available.
@@ -402,7 +406,7 @@ export const make = (
           return maybeAcquired.value;
         }).pipe(
           Effect.retry({
-            while: (e) => e._tag === "LockNotAcquiredError",
+            while: (e) => e._tag === "LockNotAcquiredError" && !resolvedOptions.acquiredExternally,
             schedule: acquireRetryPolicy,
           })
         );
@@ -412,30 +416,31 @@ export const make = (
         }
 
         // Push-based acquire: run both poll-based and push-based acquire in parallel, and return the first one to complete
-        const pushBasedAcquire = backing.onPermitsReleased
-          ? Effect.gen(function* () {
-              if (!backing.onPermitsReleased) {
-                // SAFETY: We know that onPermitsReleased is provided because we checked it above
-                return yield* Effect.dieMessage(
-                  "Invariant violated: `onPermitsReleased` is not provided"
-                );
-              }
-              return yield* backing.onPermitsReleased(key).pipe(
-                Stream.runFoldWhileEffect(
-                  Option.none<
-                    Fiber.Fiber<never, LockLostError | SemaphoreBackingError>
-                  >(),
-                  Option.isNone, // keep folding while we haven't acquired
-                  () =>
-                    tryTake(permits, resolvedOptions).pipe(
-                      acquireSemaphore.withPermitsIfAvailable(1),
-                      Effect.map(Option.flatten)
-                    )
-                ),
-                Effect.map(Option.getOrThrow)
-              );
-            })
-          : Effect.never;
+        const pushBasedAcquire = Effect.gen(function* () {
+          if (!backing.onPermitsReleased) {
+            // SAFETY: We know that onPermitsReleased is provided because we checked it above
+            return yield* Effect.dieMessage(
+              "Invariant violated: `onPermitsReleased` is not provided when it was expected"
+            );
+          }
+          return yield* backing.onPermitsReleased(key).pipe(
+            Stream.runFoldWhileEffect(
+              Option.none<
+                Fiber.Fiber<never, LockLostError | SemaphoreBackingError>
+              >(),
+              Option.isNone, // keep folding while we haven't acquired
+              () =>
+                tryTake(permits, resolvedOptions).pipe(
+                  acquireSemaphore.withPermitsIfAvailable(1),
+                  Effect.map(Option.flatten)
+                )
+            ),
+            Effect.flatMap(Option.match({
+              onSome: Effect.succeed,
+              onNone: () => Effect.dieMessage("Invariant violated: the stream should never return `None`")
+            }))
+          );
+        });
 
         // first to succeed (acquire permits) wins
         return yield* Effect.race(pollBasedAcquire, pushBasedAcquire);
@@ -446,7 +451,11 @@ export const make = (
       (permits: number, options?: AcquireOptions) =>
       <A, E, R>(
         effect: Effect.Effect<A, E, R>
-      ): Effect.Effect<A, E | LockLostError | SemaphoreBackingError | LockNotAcquiredError, R> =>
+      ): Effect.Effect<
+        A,
+        E | LockLostError | SemaphoreBackingError | LockNotAcquiredError,
+        R
+      > =>
         Effect.scoped(
           Effect.gen(function* () {
             const keepAliveFiber = yield* take(permits, options);

package/src/RedisBacking.ts

@@ -333,10 +333,10 @@ export const layer = (
       );
     }).pipe(
       Stream.retry(pushStreamRetrySchedule),
+      // If we continue to error, and the schedule has completed,
+      // just return a stream that will never emit
       Stream.catchTag("SemaphoreBackingError", () =>
-        Stream.dieMessage(
-          "Invariant violated: `onPermitsReleased` should never error because it should be retried forever"
-        )
+        Stream.never
       )
     );