effect-distributed-lock 0.0.6 → 0.0.8

package/examples/push.ts

@@ -0,0 +1,109 @@
+/**
+ * Demonstrates concurrent effects competing for a distributed lock.
+ *
+ * This example runs two scenarios:
+ * 1. With push-based acquisition DISABLED (polling only)
+ * 2. With push-based acquisition ENABLED (pub/sub notifications)
+ *
+ * You'll see how push-based acquisition is faster because waiters are
+ * notified immediately when permits are released, rather than polling.
+ *
+ * Run with: bun run examples/concurrent.ts
+ * Requires REDIS_URL environment variable or local Redis at localhost:6379.
+ */
+import { Console, Duration, Effect, Schedule } from "effect";
+import Redis from "ioredis";
+import { DistributedSemaphore, RedisBacking } from "../src/index.ts";
+
+const redis = new Redis(process.env.REDIS_URL ?? "redis://localhost:6379");
+
+// Helper to create a task that competes for the lock
+const makeTask = (
+  id: number,
+  mutex: DistributedSemaphore.DistributedSemaphore
+) =>
+  Effect.gen(function* () {
+    yield* Console.log(`[Task ${id}] Starting, waiting for lock...`);
+    const startWait = Date.now();
+
+    yield* mutex.withPermits(1)(
+      Effect.gen(function* () {
+        const waitTime = Date.now() - startWait;
+        yield* Console.log(
+          `[Task ${id}] 🔒 Lock acquired! (waited ${waitTime}ms)`
+        );
+
+        // Simulate some work
+        yield* Effect.sleep(Duration.millis(200));
+
+        yield* Console.log(`[Task ${id}] 🔓 Releasing lock...`);
+      })
+    );
+
+    yield* Console.log(`[Task ${id}] Done`);
+  });
+
+// Run a scenario with the given configuration
+const runScenario = (name: string, pushEnabled: boolean) =>
+  Effect.gen(function* () {
+    yield* Console.log(`\n${"=".repeat(60)}`);
+    yield* Console.log(`${name}`);
+    yield* Console.log(`Push-based acquisition: ${pushEnabled ? "ON" : "OFF"}`);
+    yield* Console.log(`${"=".repeat(60)}\n`);
+
+    const startTime = Date.now();
+
+    // Create mutex with a unique key per scenario to avoid interference
+    const mutex = yield* DistributedSemaphore.make(
+      `concurrent-example-${pushEnabled ? "push" : "poll"}`,
+      {
+        acquireRetryPolicy: Schedule.spaced(Duration.millis(500)),
+        limit: 1, // Mutex - only one holder at a time
+      }
+    );
+
+    // Run 3 tasks concurrently, all competing for the same lock
+    yield* Effect.all(
+      [makeTask(1, mutex), makeTask(2, mutex), makeTask(3, mutex)],
+      { concurrency: 3 }
+    );
+
+    const totalTime = Date.now() - startTime;
+    yield* Console.log(`\n⏱️  Total time: ${totalTime}ms\n`);
+  });
+
+// Run both scenarios
+const main = Effect.gen(function* () {
+  yield* Console.log("🚀 Distributed Lock Concurrency Demo");
+  yield* Console.log(
+    "Showing 3 concurrent tasks competing for a mutex (limit=1)"
+  );
+
+  // Run WITHOUT push (polling only)
+  const RedisLayerNoPush = RedisBacking.layer(redis, {
+    keyPrefix: "concurrent-demo:",
+    pushBasedAcquireEnabled: false,
+  });
+  yield* runScenario("Scenario 1: Polling Only", false).pipe(
+    Effect.provide(RedisLayerNoPush)
+  );
+
+  // Run WITH push (pub/sub notifications)
+  const RedisLayerWithPush = RedisBacking.layer(redis, {
+    keyPrefix: "concurrent-demo:",
+    pushBasedAcquireEnabled: true,
+  });
+  yield* runScenario("Scenario 2: Push-Based (Pub/Sub)", true).pipe(
+    Effect.provide(RedisLayerWithPush)
+  );
+
+  yield* Console.log("✅ Demo complete!");
+  yield* Console.log(
+    "Notice how push-based acquisition completes faster because"
+  );
+  yield* Console.log(
+    "waiters are notified immediately instead of waiting for the next poll.\n"
+  );
+}).pipe(Effect.ensuring(Effect.promise(() => redis.quit())));
+
+Effect.runPromise(main).catch(console.error);

package/package.json

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

package/src/DistributedSemaphore.ts

@@ -44,7 +44,7 @@ export interface DistributedSemaphoreConfig {
    * How often to poll when waiting to acquire permits.
    * @default Schedule.spaced(Duration.millis(100))
    */
-  readonly acquireRetryPolicy?: Schedule.Schedule<void>;
+  readonly acquireRetryPolicy?: Schedule.Schedule<unknown>;
 
   /**
    * Retry policy when a backing failure occurs.
@@ -54,15 +54,13 @@ export interface DistributedSemaphoreConfig {
    * - Releasing permits
    * @default Schedule.recurs(3)
    */
-  readonly backingFailureRetryPolicy?: Schedule.Schedule<void>;
+  readonly backingFailureRetryPolicy?: Schedule.Schedule<unknown>;
 }
 
 const DEFAULT_LIMIT = 1;
 const DEFAULT_TTL = Duration.seconds(30);
-const DEFAULT_ACQUIRE_RETRY_POLICY = Schedule.spaced(Duration.millis(100)).pipe(
-  Schedule.asVoid
-);
-const DEFAULT_FAILURE_RETRY_POLICY = Schedule.recurs(3).pipe(Schedule.asVoid);
+const DEFAULT_ACQUIRE_RETRY_POLICY = Schedule.spaced(Duration.millis(100));
+const DEFAULT_FAILURE_RETRY_POLICY = Schedule.recurs(3);
 
 // =============================================================================
 // Acquire Options
@@ -222,8 +220,8 @@ type FullyResolvedConfig = {
   limit: number;
   ttl: Duration.Duration;
   refreshInterval: Duration.Duration;
-  acquireRetryPolicy: Schedule.Schedule<void>;
-  backingFailureRetryPolicy: Schedule.Schedule<void>;
+  acquireRetryPolicy: Schedule.Schedule<unknown>;
+  backingFailureRetryPolicy: Schedule.Schedule<unknown>;
 };
 
 function fullyResolveConfig(
@@ -445,6 +443,7 @@ export const make = (
             })
           : Effect.never;
 
+        // first to succeed (acquire permits) wins
         return yield* Effect.race(pollBasedAcquire, pushBasedAcquire);
       });
 

package/src/RedisBacking.ts

@@ -177,7 +177,7 @@ export interface RedisBackingOptions {
    * How often to retry the stream of notifications when permits are released.
    * @default Schedule.forever
    */
-  readonly pushStreamRetrySchedule?: Schedule.Schedule<void>;
+  readonly pushStreamRetrySchedule?: Schedule.Schedule<unknown>;
 }
 
 /**
@@ -198,7 +198,7 @@ export const layer = (
   const keyPrefix = options.keyPrefix ?? "semaphore:";
   const pushBasedAcquireEnabled = options.pushBasedAcquireEnabled ?? true;
   const pushStreamRetrySchedule =
-    options.pushStreamRetrySchedule ?? Schedule.forever.pipe(Schedule.asVoid);
+    options.pushStreamRetrySchedule ?? Schedule.forever;
   const prefixKey = (key: string) => `${keyPrefix}${key}`;
   const releaseChannel = (key: string) => `${keyPrefix}${key}:released`;
 
@@ -325,9 +325,9 @@ export const layer = (
           return { subscriber, messageHandler };
         }),
         ({ subscriber, messageHandler }) =>
-          Effect.sync(() => {
+          Effect.promise(async () => {
             subscriber.off("message", messageHandler);
-            subscriber.unsubscribe(channel);
+            await subscriber.unsubscribe(channel);
             subscriber.disconnect();
           })
       );

package/redis-semaphore/.codeclimate.yml

@@ -1,5 +0,0 @@
-version: '2'
-plugins:
-  eslint:
-    enabled: true
-    channel: 'eslint-6'

package/redis-semaphore/.fossa.yml

@@ -1,14 +0,0 @@
-# Generated by FOSSA CLI (https://github.com/fossas/fossa-cli)
-# Visit https://fossa.com to learn more
-
-version: 2
-cli:
-  server: https://app.fossa.com
-  fetcher: custom
-  project: git@github.com:swarthy/redis-semaphore.git
-analyze:
-  modules:
-  - name: .
-    type: npm
-    target: .
-    path: .

package/redis-semaphore/.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: 'npm'
-    directory: '/'
-    schedule:
-      interval: 'monthly'

package/redis-semaphore/.github/workflows/branches.yml

@@ -1,39 +0,0 @@
-name: CI (push)
-
-on:
-  push:
-    branches:
-      - master
-  workflow_dispatch:
-
-jobs:
-  integration-test:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x, 22.x]
-
-    env:
-      COVERALLS_REPO_TOKEN: '${{ secrets.COVERALLS_REPO_TOKEN }}'
-      COVERALLS_GIT_BRANCH: '${{ github.ref }}'
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Enable Corepack
-        run: corepack enable
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: 'yarn'
-
-      - run: yarn install --immutable
-
-      - run: docker compose up -d redis1 redis2 redis3
-      - run: docker compose run waiter
-
-      - run: yarn build
-      - run: yarn lint
-      - run: yarn test-ci-with-coverage

package/redis-semaphore/.github/workflows/pull-requests.yml

@@ -1,35 +0,0 @@
-name: CI (PR)
-
-on:
-  pull_request:
-    branches:
-      - master
-  workflow_dispatch:
-
-jobs:
-  integration-test:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x, 22.x]
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Enable Corepack
-        run: corepack enable
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: 'yarn'
-
-      - run: yarn install --immutable
-
-      - run: docker compose up -d redis1 redis2 redis3
-      - run: docker compose run waiter
-
-      - run: yarn build
-      - run: yarn lint
-      - run: yarn test

package/redis-semaphore/.mocharc.yaml

@@ -1,6 +0,0 @@
-extension: ts
-recursive: true
-timeout: 5s
-require:
-  - '@swc-node/register'
-  - test/setup.ts

package/redis-semaphore/.prettierrc

@@ -1,6 +0,0 @@
-{
-  "semi": false,
-  "singleQuote": true,
-  "trailingComma": "none",
-  "arrowParens": "avoid"
-}

package/redis-semaphore/.snyk

@@ -1,4 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.13.1
-ignore: {}
-patch: {}

package/redis-semaphore/.yarnrc.yml

@@ -1,2 +0,0 @@
-nodeLinker: node-modules
-defaultSemverRangePrefix: ''

package/redis-semaphore/CHANGELOG.md

@@ -1,70 +0,0 @@
-### redis-semaphore@5.6.2
-- Fixed implicit import from `src`
-- Removed `src` folder from NPM package
-
-### redis-semaphore@5.6.1
-- Removed `module` field from `package.json`
-
-### redis-semaphore@5.6.0
-- Added interface compatible client support (ex. `ioredis-mock`)
-- Removed `instanceof Redis` validation in constructor
-- `ioredis` marked as optional peerDependency, explicit `ioredis` install is required now
-
-### redis-semaphore@5.5.1
-- Fix race condition for refresh started before release and finished after release
-
-### redis-semaphore@5.5.0
-
-- Added `identifier` constructor option.
-- Added `acquiredExternally` constructor option.
-- Option `externallyAcquiredIdentifier` **DEPRECATED**.
-- Option `identifierSuffix` **DEPRECATED**.
-
-### redis-semaphore@5.4.0
-
-- Added `identifierSuffix` option, usefull for tracing app instance which locked resource
-
-### redis-semaphore@5.3.1
-
-- Fixed reacquire expired resource in refresh
-
-### redis-semaphore@5.3.0
-
-- Added `stopRefresh` method
-- Added `externallyAcquiredIdentifier` optional constructor option
-- Removed `uuid` dependency
-
-### redis-semaphore@5.2.0
-
-- Added `acquireAttemptsLimit` method
-
-### redis-semaphore@5.1.0
-
-- Added `tryAcquire`
-
-### redis-semaphore@5.0.0
-
-- **Breadking change:** Drop Node.js v10.x, v12.x support
-- Added `ioredis@5` support
-
-### redis-semaphore@4.1.0
-
-- Added `.isAcquired` property on all locks
-- Added `onLostLock` constructor option. By default throws unhandled error.
-
-### redis-semaphore@4.0.0
-
-- **Breaking change:** `Mutex`, `Semaphore`, `MultiSemaphore` not longer support `Cluster`. For multi-node case use `Redlock*` instead.
-- Added `RedlockMutex`, `RedlockSemaphore`, `RedlockMultiSemaphore`
-- Internals refactored
-
-### redis-semaphore@3.2.0
-
-- Added `MultiSemaphore`
-
-### redis-semaphore@3.0.0
-
-- **Breaking change:** `FairSemaphore` has been removed. Use `Semaphore` instead (has the same "fairness")
-  - the `acquire` method in `Semaphore` no longer returns a boolean. Instead, it throws an error if it cannot acquire, and if it doesn't throw, you can assume it worked.
-- Internal code has been cleaned up
-- Added more test, include synthetic node unsynchroned clocks

package/redis-semaphore/Dockerfile

@@ -1,5 +0,0 @@
-FROM node:alpine
-RUN npm i -g @swarthy/wait-for@2.0.2
-VOLUME /app
-WORKDIR /app
-USER node

package/redis-semaphore/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2018 Alexander Mochalin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.