effect-distributed-lock 0.0.5 → 0.0.7

package/redis-semaphore/package.json

@@ -1,79 +0,0 @@
-{
-  "name": "redis-semaphore",
-  "version": "5.6.2",
-  "description": "Distributed mutex and semaphore based on Redis",
-  "main": "lib/index.js",
-  "scripts": {
-    "lint": "eslint --ext .js,.ts .",
-    "test": "mocha",
-    "test-ci-with-coverage": "nyc mocha && nyc report --reporter=text-lcov | coveralls",
-    "coverage-html": "nyc mocha && nyc report --reporter=html",
-    "converalls": "nyc mocha && nyc report --reporter=text-lcov | coveralls",
-    "dev": "mocha -w",
-    "build": "yarn build-commonjs",
-    "build-commonjs": "rm -rf lib && yarn tsc -b tsconfig.build-commonjs.json",
-    "build-es": "rm -rf es && yarn tsc -b tsconfig.build-es.json",
-    "preversion": "yarn lint && yarn test && yarn build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:swarthy/redis-semaphore.git"
-  },
-  "keywords": [
-    "redis",
-    "redlock",
-    "mutex",
-    "semaphore"
-  ],
-  "author": "Alexander Mochalin (horroshow@mail.ru)",
-  "license": "MIT",
-  "devDependencies": {
-    "@swarthy/wait-for": "^2.1.1",
-    "@swc-node/register": "1.10.10",
-    "@swc/core": "1.11.11",
-    "@types/chai": "^4.3.20",
-    "@types/chai-as-promised": "^7.1.8",
-    "@types/debug": "^4.1.12",
-    "@types/ioredis-mock": "^8.2.5",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "22.13.11",
-    "@types/sinon": "^17.0.4",
-    "@types/sinon-chai": "^3.2.12",
-    "@typescript-eslint/eslint-plugin": "8.27.0",
-    "@typescript-eslint/parser": "8.27.0",
-    "benchmark": "^2.1.4",
-    "chai": "4.5.0",
-    "chai-as-promised": "7.1.2",
-    "coveralls": "^3.1.1",
-    "eslint": "9.23.0",
-    "eslint-plugin-node": "11.1.0",
-    "ioredis": "5.6.0",
-    "ioredis-mock": "8.9.0",
-    "mocha": "11.1.0",
-    "mocha-lcov-reporter": "^1.3.0",
-    "nyc": "^17.1.0",
-    "sinon": "19.0.4",
-    "sinon-chai": "3.7.0",
-    "snyk": "1.1296.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.2"
-  },
-  "engines": {
-    "node": ">= 14.17.0"
-  },
-  "peerDependencies": {
-    "ioredis": "^4.1.0 || ^5"
-  },
-  "peerDependenciesMeta": {
-    "ioredis": {
-      "optional": true
-    }
-  },
-  "dependencies": {
-    "debug": "^4.4.0"
-  },
-  "packageManager": "yarn@4.1.0+sha256.81a00df816059803e6b5148acf03ce313cad36b7f6e5af6efa040a15981a6ffb",
-  "files": [
-    "lib/"
-  ]
-}

package/redis-semaphore/setup-redis-servers.sh

@@ -1,2 +0,0 @@
-#!/bin/sh
-docker compose up -d redis1 redis2 redis3

package/redis-semaphore/src/Lock.ts

@@ -1,172 +0,0 @@
-import createDebug from 'debug'
-import * as crypto from 'node:crypto'
-import LostLockError from './errors/LostLockError'
-import TimeoutError from './errors/TimeoutError'
-import { defaultOnLockLost, defaultTimeoutOptions } from './misc'
-import { AcquireOptions, LockLostCallback, LockOptions } from './types'
-
-const REFRESH_INTERVAL_COEF = 0.8
-
-const debug = createDebug('redis-semaphore:instance')
-
-export abstract class Lock {
-  protected abstract _kind: string
-  protected abstract _key: string
-  protected _identifier: string
-  protected _acquireOptions: AcquireOptions
-  protected _refreshTimeInterval: number
-  protected _refreshInterval?: ReturnType<typeof setInterval>
-  protected _refreshing = false
-  protected _acquired = false
-  protected _acquiredExternally = false
-  protected _onLockLost: LockLostCallback
-
-  protected abstract _refresh(): Promise<boolean>
-  protected abstract _acquire(): Promise<boolean>
-  protected abstract _release(): Promise<void>
-
-  constructor({
-    lockTimeout = defaultTimeoutOptions.lockTimeout,
-    acquireTimeout = defaultTimeoutOptions.acquireTimeout,
-    acquireAttemptsLimit = defaultTimeoutOptions.acquireAttemptsLimit,
-    retryInterval = defaultTimeoutOptions.retryInterval,
-    refreshInterval = Math.round(lockTimeout * REFRESH_INTERVAL_COEF),
-    onLockLost = defaultOnLockLost,
-    externallyAcquiredIdentifier,
-    identifierSuffix,
-    identifier,
-    acquiredExternally
-  }: LockOptions = defaultTimeoutOptions) {
-    if (
-      identifier !== undefined &&
-      (!identifier || typeof identifier !== 'string')
-    ) {
-      throw new Error('identifier must be not empty random string')
-    }
-    if (acquiredExternally && !identifier) {
-      throw new Error(
-        'acquiredExternally=true meanless without custom identifier'
-      )
-    }
-    if (externallyAcquiredIdentifier && (identifier || acquiredExternally)) {
-      throw new Error(
-        'Invalid usage. Use custom identifier and acquiredExternally: true'
-      )
-    }
-    this._identifier =
-      identifier ||
-      externallyAcquiredIdentifier ||
-      this.getIdentifier(identifierSuffix)
-    this._acquiredExternally =
-      !!acquiredExternally || !!externallyAcquiredIdentifier
-    this._acquireOptions = {
-      lockTimeout,
-      acquireTimeout,
-      acquireAttemptsLimit,
-      retryInterval,
-      identifier: this._identifier
-    }
-    this._refreshTimeInterval = refreshInterval
-    this._onLockLost = onLockLost
-  }
-
-  get identifier(): string {
-    return this._identifier
-  }
-
-  get isAcquired(): boolean {
-    return this._acquired
-  }
-
-  private getIdentifier(identifierSuffix: string | undefined): string {
-    const uuid = crypto.randomUUID()
-    return identifierSuffix ? `${uuid}-${identifierSuffix}` : uuid
-  }
-
-  private _startRefresh(): void {
-    this._refreshInterval = setInterval(
-      this._processRefresh,
-      this._refreshTimeInterval
-    )
-    this._refreshInterval.unref()
-  }
-
-  stopRefresh(): void {
-    if (this._refreshInterval) {
-      debug(
-        `clear refresh interval ${this._kind} (key: ${this._key}, identifier: ${this._identifier})`
-      )
-      clearInterval(this._refreshInterval)
-    }
-  }
-
-  private _processRefresh = async (): Promise<void> => {
-    if (this._refreshing) {
-      debug(
-        `already refreshing ${this._kind} (key: ${this._key}, identifier: ${this._identifier}) (skip)`
-      )
-      return
-    }
-    this._refreshing = true
-    try {
-      debug(
-        `refresh ${this._kind} (key: ${this._key}, identifier: ${this._identifier})`
-      )
-      const refreshed = await this._refresh()
-      if (!refreshed) {
-        if (!this._acquired) {
-          debug(
-            `refresh ${this._kind} (key: ${this._key}, identifier: ${this._identifier} failed, but lock was purposefully released`
-          )
-          return
-        }
-        this._acquired = false
-        this.stopRefresh()
-        const lockLostError = new LostLockError(
-          `Lost ${this._kind} for key ${this._key}`
-        )
-        this._onLockLost(lockLostError)
-      }
-    } finally {
-      this._refreshing = false
-    }
-  }
-
-  async acquire(): Promise<void> {
-    debug(`acquire ${this._kind} (key: ${this._key})`)
-    const acquired = await this.tryAcquire()
-    if (!acquired) {
-      throw new TimeoutError(`Acquire ${this._kind} ${this._key} timeout`)
-    }
-  }
-
-  async tryAcquire(): Promise<boolean> {
-    debug(`tryAcquire ${this._kind} (key: ${this._key})`)
-    const acquired = this._acquiredExternally
-      ? await this._refresh()
-      : await this._acquire()
-    if (!acquired) {
-      return false
-    }
-    this._acquired = true
-    this._acquiredExternally = false
-    if (this._refreshTimeInterval > 0) {
-      this._startRefresh()
-    }
-    return true
-  }
-
-  async release(): Promise<void> {
-    debug(
-      `release ${this._kind} (key: ${this._key}, identifier: ${this._identifier})`
-    )
-    if (this._refreshTimeInterval > 0) {
-      this.stopRefresh()
-    }
-    if (this._acquired || this._acquiredExternally) {
-      await this._release()
-    }
-    this._acquired = false
-    this._acquiredExternally = false
-  }
-}

package/redis-semaphore/src/RedisMultiSemaphore.ts

@@ -1,56 +0,0 @@
-import { acquireSemaphore } from './multiSemaphore/acquire'
-import { refreshSemaphore } from './multiSemaphore/refresh'
-import { releaseSemaphore } from './multiSemaphore/release'
-import RedisSemaphore from './RedisSemaphore'
-import { LockOptions, RedisClient } from './types'
-
-export default class RedisMultiSemaphore extends RedisSemaphore {
-  protected _kind = 'multi-semaphore'
-  protected _permits: number
-
-  constructor(
-    client: RedisClient,
-    key: string,
-    limit: number,
-    permits: number,
-    options?: LockOptions
-  ) {
-    super(client, key, limit, options)
-    if (!permits) {
-      throw new Error('"permits" is required')
-    }
-    if (typeof permits !== 'number') {
-      throw new Error('"permits" must be a number')
-    }
-    this._permits = permits
-  }
-
-  protected async _refresh(): Promise<boolean> {
-    return await refreshSemaphore(
-      this._client,
-      this._key,
-      this._limit,
-      this._permits,
-      this._acquireOptions
-    )
-  }
-
-  protected async _acquire(): Promise<boolean> {
-    return await acquireSemaphore(
-      this._client,
-      this._key,
-      this._limit,
-      this._permits,
-      this._acquireOptions
-    )
-  }
-
-  protected async _release(): Promise<void> {
-    await releaseSemaphore(
-      this._client,
-      this._key,
-      this._permits,
-      this._identifier
-    )
-  }
-}

package/redis-semaphore/src/RedisMutex.ts

@@ -1,45 +0,0 @@
-import type { RedisClient } from './types'
-
-import { Lock } from './Lock'
-import { acquireMutex } from './mutex/acquire'
-import { refreshMutex } from './mutex/refresh'
-import { releaseMutex } from './mutex/release'
-import { LockOptions } from './types'
-
-export default class RedisMutex extends Lock {
-  protected _kind = 'mutex'
-  protected _key: string
-  protected _client: RedisClient
-
-  constructor(client: RedisClient, key: string, options?: LockOptions) {
-    super(options)
-    if (!client) {
-      throw new Error('"client" is required')
-    }
-    if (!key) {
-      throw new Error('"key" is required')
-    }
-    if (typeof key !== 'string') {
-      throw new Error('"key" must be a string')
-    }
-    this._client = client
-    this._key = `mutex:${key}`
-  }
-
-  protected async _refresh(): Promise<boolean> {
-    return await refreshMutex(
-      this._client,
-      this._key,
-      this._identifier,
-      this._acquireOptions.lockTimeout
-    )
-  }
-
-  protected async _acquire(): Promise<boolean> {
-    return await acquireMutex(this._client, this._key, this._acquireOptions)
-  }
-
-  protected async _release(): Promise<void> {
-    await releaseMutex(this._client, this._key, this._identifier)
-  }
-}

package/redis-semaphore/src/RedisSemaphore.ts

@@ -1,49 +0,0 @@
-import RedisMutex from './RedisMutex'
-import { acquireSemaphore } from './semaphore/acquire'
-import { refreshSemaphore } from './semaphore/refresh'
-import { releaseSemaphore } from './semaphore/release'
-import { LockOptions, RedisClient } from './types'
-
-export default class RedisSemaphore extends RedisMutex {
-  protected _kind = 'semaphore'
-  protected _limit: number
-
-  constructor(
-    client: RedisClient,
-    key: string,
-    limit: number,
-    options?: LockOptions
-  ) {
-    super(client, key, options)
-    if (!limit) {
-      throw new Error('"limit" is required')
-    }
-    if (typeof limit !== 'number') {
-      throw new Error('"limit" must be a number')
-    }
-    this._key = `semaphore:${key}`
-    this._limit = limit
-  }
-
-  protected async _refresh(): Promise<boolean> {
-    return await refreshSemaphore(
-      this._client,
-      this._key,
-      this._limit,
-      this._acquireOptions
-    )
-  }
-
-  protected async _acquire(): Promise<boolean> {
-    return await acquireSemaphore(
-      this._client,
-      this._key,
-      this._limit,
-      this._acquireOptions
-    )
-  }
-
-  protected async _release(): Promise<void> {
-    await releaseSemaphore(this._client, this._key, this._identifier)
-  }
-}

package/redis-semaphore/src/RedlockMultiSemaphore.ts

@@ -1,56 +0,0 @@
-import { acquireRedlockMultiSemaphore } from './redlockMultiSemaphore/acquire'
-import { refreshRedlockMultiSemaphore } from './redlockMultiSemaphore/refresh'
-import { releaseRedlockMultiSemaphore } from './redlockMultiSemaphore/release'
-import RedlockSemaphore from './RedlockSemaphore'
-import { LockOptions, RedisClient } from './types'
-
-export default class RedlockMultiSemaphore extends RedlockSemaphore {
-  protected _kind = 'redlock-multi-semaphore'
-  protected _permits: number
-
-  constructor(
-    clients: RedisClient[],
-    key: string,
-    limit: number,
-    permits: number,
-    options?: LockOptions
-  ) {
-    super(clients, key, limit, options)
-    if (!permits) {
-      throw new Error('"permits" is required')
-    }
-    if (typeof permits !== 'number') {
-      throw new Error('"permits" must be a number')
-    }
-    this._permits = permits
-  }
-
-  protected async _refresh(): Promise<boolean> {
-    return await refreshRedlockMultiSemaphore(
-      this._clients,
-      this._key,
-      this._limit,
-      this._permits,
-      this._acquireOptions
-    )
-  }
-
-  protected async _acquire(): Promise<boolean> {
-    return await acquireRedlockMultiSemaphore(
-      this._clients,
-      this._key,
-      this._limit,
-      this._permits,
-      this._acquireOptions
-    )
-  }
-
-  protected async _release(): Promise<void> {
-    await releaseRedlockMultiSemaphore(
-      this._clients,
-      this._key,
-      this._permits,
-      this._identifier
-    )
-  }
-}

package/redis-semaphore/src/RedlockMutex.ts

@@ -1,52 +0,0 @@
-import { Lock } from './Lock'
-import { defaultTimeoutOptions } from './misc'
-import { acquireRedlockMutex } from './redlockMutex/acquire'
-import { refreshRedlockMutex } from './redlockMutex/refresh'
-import { releaseRedlockMutex } from './redlockMutex/release'
-import { LockOptions, RedisClient } from './types'
-
-export default class RedlockMutex extends Lock {
-  protected _kind = 'redlock-mutex'
-  protected _key: string
-  protected _clients: RedisClient[]
-
-  constructor(
-    clients: RedisClient[],
-    key: string,
-    options: LockOptions = defaultTimeoutOptions
-  ) {
-    super(options)
-    if (!clients || !Array.isArray(clients)) {
-      throw new Error('"clients" array is required')
-    }
-    if (!key) {
-      throw new Error('"key" is required')
-    }
-    if (typeof key !== 'string') {
-      throw new Error('"key" must be a string')
-    }
-    this._clients = clients
-    this._key = `mutex:${key}`
-  }
-
-  protected async _refresh(): Promise<boolean> {
-    return await refreshRedlockMutex(
-      this._clients,
-      this._key,
-      this._identifier,
-      this._acquireOptions.lockTimeout
-    )
-  }
-
-  protected async _acquire(): Promise<boolean> {
-    return await acquireRedlockMutex(
-      this._clients,
-      this._key,
-      this._acquireOptions
-    )
-  }
-
-  protected async _release(): Promise<void> {
-    await releaseRedlockMutex(this._clients, this._key, this._identifier)
-  }
-}

package/redis-semaphore/src/RedlockSemaphore.ts

@@ -1,49 +0,0 @@
-import RedlockMutex from './RedlockMutex'
-import { acquireRedlockSemaphore } from './redlockSemaphore/acquire'
-import { refreshRedlockSemaphore } from './redlockSemaphore/refresh'
-import { releaseRedlockSemaphore } from './redlockSemaphore/release'
-import { LockOptions, RedisClient } from './types'
-
-export default class RedlockSemaphore extends RedlockMutex {
-  protected _kind = 'redlock-semaphore'
-  protected _limit: number
-
-  constructor(
-    clients: RedisClient[],
-    key: string,
-    limit: number,
-    options?: LockOptions
-  ) {
-    super(clients, key, options)
-    if (!limit) {
-      throw new Error('"limit" is required')
-    }
-    if (typeof limit !== 'number') {
-      throw new Error('"limit" must be a number')
-    }
-    this._key = `semaphore:${key}`
-    this._limit = limit
-  }
-
-  protected async _refresh(): Promise<boolean> {
-    return await refreshRedlockSemaphore(
-      this._clients,
-      this._key,
-      this._limit,
-      this._acquireOptions
-    )
-  }
-
-  protected async _acquire(): Promise<boolean> {
-    return await acquireRedlockSemaphore(
-      this._clients,
-      this._key,
-      this._limit,
-      this._acquireOptions
-    )
-  }
-
-  protected async _release(): Promise<void> {
-    await releaseRedlockSemaphore(this._clients, this._key, this._identifier)
-  }
-}

package/redis-semaphore/src/errors/LostLockError.ts

@@ -1 +0,0 @@
-export default class LostLockError extends Error {}

package/redis-semaphore/src/errors/TimeoutError.ts

@@ -1 +0,0 @@
-export default class TimeoutError extends Error {}

package/redis-semaphore/src/index.ts

@@ -1,23 +0,0 @@
-import MultiSemaphore from './RedisMultiSemaphore'
-import Mutex from './RedisMutex'
-import Semaphore from './RedisSemaphore'
-import RedlockMultiSemaphore from './RedlockMultiSemaphore'
-import RedlockMutex from './RedlockMutex'
-import RedlockSemaphore from './RedlockSemaphore'
-import LostLockError from './errors/LostLockError'
-import TimeoutError from './errors/TimeoutError'
-
-export { defaultTimeoutOptions } from './misc'
-
-export {
-  Mutex,
-  Semaphore,
-  MultiSemaphore,
-  RedlockMutex,
-  RedlockSemaphore,
-  RedlockMultiSemaphore,
-  LostLockError,
-  TimeoutError
-}
-
-export type { LockLostCallback, TimeoutOptions, LockOptions } from './types'

package/redis-semaphore/src/misc.ts

@@ -1,12 +0,0 @@
-import LostLockError from './errors/LostLockError'
-
-export const defaultTimeoutOptions = {
-  lockTimeout: 10000,
-  acquireTimeout: 10000,
-  acquireAttemptsLimit: Number.POSITIVE_INFINITY,
-  retryInterval: 10
-}
-
-export function defaultOnLockLost(err: LostLockError): never {
-  throw err
-}

package/redis-semaphore/src/multiSemaphore/acquire/index.ts

@@ -1,53 +0,0 @@
-import createDebug from 'debug'
-import { RedisClient } from '../../types'
-import { delay } from '../../utils'
-import { acquireLua } from './lua'
-
-const debug = createDebug('redis-semaphore:multi-semaphore:acquire')
-
-export interface Options {
-  identifier: string
-  lockTimeout: number
-  acquireTimeout: number
-  acquireAttemptsLimit: number
-  retryInterval: number
-}
-
-export async function acquireSemaphore(
-  client: RedisClient,
-  key: string,
-  limit: number,
-  permits: number,
-  options: Options
-): Promise<boolean> {
-  const {
-    identifier,
-    lockTimeout,
-    acquireTimeout,
-    acquireAttemptsLimit,
-    retryInterval
-  } = options
-  let attempt = 0
-  const end = Date.now() + acquireTimeout
-  let now
-  while ((now = Date.now()) < end && ++attempt <= acquireAttemptsLimit) {
-    debug(key, identifier, limit, lockTimeout, 'attempt', attempt)
-    const result = await acquireLua(client, [
-      key,
-      limit,
-      permits,
-      identifier,
-      lockTimeout,
-      now
-    ])
-    debug(key, 'result', typeof result, result)
-    if (result === 1) {
-      debug(key, identifier, 'acquired')
-      return true
-    } else {
-      await delay(retryInterval)
-    }
-  }
-  debug(key, identifier, limit, lockTimeout, 'timeout or reach limit')
-  return false
-}

package/redis-semaphore/src/multiSemaphore/acquire/lua.ts

@@ -1,31 +0,0 @@
-import { createEval } from '../../utils/index'
-
-export const acquireLua = createEval<
-  [string, number, number, string, number, number],
-  0 | 1
->(
-  `
-  local key = KEYS[1]
-  local limit = tonumber(ARGV[1])
-  local permits = tonumber(ARGV[2])
-  local identifier = ARGV[3]
-  local lockTimeout = tonumber(ARGV[4])
-  local now = tonumber(ARGV[5])
-  local expiredTimestamp = now - lockTimeout
-  local args = {}
-
-  redis.call('zremrangebyscore', key, '-inf', expiredTimestamp)
-
-  if (redis.call('zcard', key) + permits) <= limit then
-    for i=0, permits - 1 do
-      table.insert(args, now)
-      table.insert(args, identifier .. '_' .. i)
-    end
-    redis.call('zadd', key, unpack(args))
-    redis.call('pexpire', key, lockTimeout)
-    return 1
-  else
-    return 0
-  end`,
-  1
-)