Class Lock

IMPORTANT: This class is not intended to be instantiated directly, instead it should be created by the LockProvider class instance.

Implements

Methods

acquire acquireBlocking acquireOrFail addListener addListenerMany asPromise forceRelease getOwner getRemainingTime isExpired isLocked listenOnce refresh refreshOrFail release releaseOrFail removeListener removeListenerMany run runBlocking runOrFail subscribe subscribeMany

Methods

acquire

  • acquire(): LazyPromise<boolean>

  • Returns LazyPromise<boolean>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
    import { TimeSpan } from "@daiso-tech/core/utilities";
    import { delay } from "@daiso-tech/core/async";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    async function fn(): Promise<void> {
      // Use try-finally when acquiring a lock to ensure it’s released if an error happens.
      try {
        const hasAquired = await lock.acquire();
        if (!hasAquired) {
          return;
        }
        console.log("START: ", 1);
        // Let’s pretend we’re doing async database work.
        await delay(TimeSpan.fromSeconds(2));
        console.log("END: ", 2);
      }
      finally {
        await lock.release();
      }
    }

    await Promise.allSettled([
      fn(),
      fn(),
      fn(),
      fn(),
    ]);

acquireBlocking

  • acquireBlocking(settings?): LazyPromise<boolean>

  • Parameters

    Returns LazyPromise<boolean>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
    import { TimeSpan } from "@daiso-tech/core/utilities";
    import { delay } from "@daiso-tech/core/async";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    async function fn(): Promise<void> {
      // Use try-finally when acquiring a lock to ensure it’s released if an error happens.
      try {
        const hasAquired = await lock.acquireBlocking();
        if (!hasAquired) {
          return;
        }
        console.log("START: ", 1);
        // Let’s pretend we’re doing async database work.
        await delay(TimeSpan.fromSeconds(2));
        console.log("END: ", 2);
      }
      finally {
        await lock.release();
      }
    }

    await Promise.allSettled([
      fn(),
      fn(),
      fn(),
      fn(),
    ]);

acquireOrFail

  • acquireOrFail(): LazyPromise<void>

  • Returns LazyPromise<void>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
    import { TimeSpan } from "@daiso-tech/core/utilities";
    import { delay } from "@daiso-tech/core/async";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    async function fn(): Promise<void> {
      // Use try-finally when acquiring a lock to ensure it’s released if an error happens.
      try {
        // Retries 4 times to acquire the lock, then throws an error.
        await lock.acquireOrFail().setRetryAttempts(4);
        console.log("START: ", 1);
        // Let’s pretend we’re doing async database work.
        await delay(TimeSpan.fromSeconds(2));
        console.log("END: ", 2);
      }
      finally {
        await lock.release();
      }
    }

    await Promise.allSettled([
      fn(),
      fn(),
      fn(),
      fn(),
    ]);

addListener

  • addListener<TEventClass>(event, listener): LazyPromise<void>

  • You can listen to different events of the current Lock class instance.

    Refer to LockEvents, to se all events dispatched by LockProvider class instance. Refer to IEventListenable for details on how the method works.

    Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    const listener: Invokable <LockEvents> = event => {
      console.log(event);
    }
    await lock.addListener(KeyAcquiredLockEvent, listener);
    await lock.acquire();

addListenerMany

  • addListenerMany<TEventClass>(events, listener): LazyPromise<void>

  • You can listen to different events of the current Lock class instance.

    Refer to LockEvents, to se all events dispatched by LockProvider class instance. Refer to IEventListenable for details on how the method works.

    Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    const listener: Invokable <LockEvents> = event => {
      console.log(event);
    }
    await lock.addListenerMany([KeyAcquiredLockEvent], listener);
    await lock.acquire();

asPromise

forceRelease

getOwner

getRemainingTime

isExpired

isLocked

listenOnce

  • listenOnce<TEventClass>(event, listener): LazyPromise<void>

  • You can listen to different events of the current Lock class instance.

    Refer to LockEvents, to se all events dispatched by LockProvider class instance. Refer to IEventListenable for details on how the method works.

    Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    const listener: Invokable <LockEvents> = event => {
      console.log(event);
    }
    await lock.listenOnce(KeyAcquiredLockEvent, listener);
    await lock.acquire();

refresh

refreshOrFail

release

releaseOrFail

removeListener

  • removeListener<TEventClass>(event, listener): LazyPromise<void>

  • You can listen to different events of the current Lock class instance.

    Refer to LockEvents, to se all events dispatched by LockProvider class instance. Refer to IEventListenable for details on how the method works.

    Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    const listener: Invokable <LockEvents> = event => {
      console.log(event);
    }
    await lock.addListener(KeyAcquiredLockEvent, listener);
    await lock.removeListener(KeyAcquiredLockEvent, listener);
    await lock.acquire();

removeListenerMany

  • removeListenerMany<TEventClass>(events, listener): LazyPromise<void>

  • You can listen to different events of the current Lock class instance.

    Refer to LockEvents, to se all events dispatched by LockProvider class instance. Refer to IEventListenable for details on how the method works.

    Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    const listener: Invokable <LockEvents> = event => {
      console.log(event);
    }
    await lock.addListenerMany([KeyAcquiredLockEvent], listener);
    await lock.removeListenerMany([KeyAcquiredLockEvent], listener);
    await lock.acquire();

run

  • run<TValue>(asyncFn): LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>

  • Type Parameters

    • TValue = void

    Parameters

    Returns LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
    import { TimeSpan } from "@daiso-tech/core/utilities";
    import { delay } from "@daiso-tech/core/async";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    async function fn(): Promise<void> {
      await lock.run(async () => {
        console.log("START: ", 1);
        // Let’s pretend we’re doing async database work.
        await delay(TimeSpan.fromSeconds(2));
        console.log("END: ", 2);
      });
    }

    await Promise.allSettled([
      fn(),
      fn(),
      fn(),
      fn(),
    ]);

    You can also pass an LazyPromise instead of async function.

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
    import { TimeSpan } from "@daiso-tech/core/utilities";
    import { delay } from "@daiso-tech/core/async";
    import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
    import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
    import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const cache: IGroupableCache = new Cache({
      // Let's pretend when the cache adapter increments a key it will occur in 2 async, get the value, increment the value in memory and update the key.
      adapter: new MemoryCacheAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });
    await cache.put("a", 0);

    const lock = lockProvider.create("a");

    async function fn(): Promise<void> {
      // The lock will ensure the key will be incremented correctly
      await lock.run(cache.increment("a", 1));
    }

    await Promise.allSettled([
      fn(),
      fn(),
      fn(),
      fn(),
    ]);

runBlocking

  • runBlocking<TValue>(asyncFn, settings?): LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>

  • Type Parameters

    • TValue = void

    Parameters

    Returns LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
    import { TimeSpan } from "@daiso-tech/core/utilities";
    import { delay } from "@daiso-tech/core/async";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    async function fn(): Promise<void> {
      await lock.runBlocking(async () => {
        console.log("START: ", 1);
        // Let’s pretend we’re doing async database work.
        await delay(TimeSpan.fromSeconds(2));
        console.log("END: ", 2);
      });
    }

    await Promise.allSettled([
      fn(),
      fn(),
      fn(),
      fn(),
    ]);

    You can also pass an LazyPromise instead of async function.

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
    import { TimeSpan } from "@daiso-tech/core/utilities";
    import { delay } from "@daiso-tech/core/async";
    import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
    import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
    import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const cache: IGroupableCache = new Cache({
      // Let's pretend when the cache adapter increments a key it will occur in 2 async, get the value, increment the value in memory and update the key.
      adapter: new MemoryCacheAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });
    await cache.put("a", 0);

    const lock = lockProvider.create("a");

    async function fn(): Promise<void> {
      // The lock will ensure the key will be incremented correctly
      await lock.runBlocking(cache.increment("a", 1));
    }

    await Promise.allSettled([
      fn(),
      fn(),
      fn(),
      fn(),
    ]);

runOrFail

  • runOrFail<TValue>(asyncFn): LazyPromise<TValue>

  • Type Parameters

    • TValue = void

    Parameters

    Returns LazyPromise<TValue>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
    import { TimeSpan } from "@daiso-tech/core/utilities";
    import { delay } from "@daiso-tech/core/async";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    async function fn(): Promise<void> {
      await lock.runOrFail(async () => {
        console.log("START: ", 1);
        // Let’s pretend we’re doing async database work.
        await delay(TimeSpan.fromSeconds(2));
        console.log("END: ", 2);
      })
      // Retries 4 times to acquire the lock, then throws an error.
      .setRetryAttempts(4);
    }

    await Promise.allSettled([
      fn(),
      fn(),
      fn(),
      fn(),
    ]);

    You can also pass an LazyPromise instead of async function.

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
    import { TimeSpan } from "@daiso-tech/core/utilities";
    import { delay } from "@daiso-tech/core/async";
    import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
    import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
    import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const cache: IGroupableCache = new Cache({
      // Let's pretend when the cache adapter increments a key it will occur in 2 async, get the value, increment the value in memory and update the key.
      adapter: new MemoryCacheAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });
    await cache.put("a", 0);

    const lock = lockProvider.create("a");

    async function fn(): Promise<void> {
      await lock
        // The lock will ensure the key will be incremented correctly
        .runOrFail(cache.increment("a", 1));
        // Retries 4 times to acquire the lock, then throws an error.
        .setRetryAttempts(4);
    }

    await Promise.allSettled([
      fn(),
      fn(),
      fn(),
      fn(),
    ]);

subscribe

  • subscribe<TEventClass>(event, listener): LazyPromise<Unsubscribe>

  • You can listen to different events of the current Lock class instance.

    Refer to LockEvents, to se all events dispatched by LockProvider class instance. Refer to IEventListenable for details on how the method works.

    Type Parameters

    Parameters

    Returns LazyPromise<Unsubscribe>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    const listener: Invokable <LockEvents> = event => {
      console.log(event);
    }
    const unsubscribe = await lock.subscribe(KeyAcquiredLockEvent, listener);
    await lock.acquire();
    await unsubscribe();

subscribeMany

  • subscribeMany<TEventClass>(events, listener): LazyPromise<Unsubscribe>

  • You can listen to different events of the current Lock class instance.

    Refer to LockEvents, to se all events dispatched by LockProvider class instance. Refer to IEventListenable for details on how the method works.

    Type Parameters

    Parameters

    Returns LazyPromise<Unsubscribe>

    Example

    import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
    import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
    import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
    import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
    import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";

    const eventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });
    const serde = new Serde(SuperJsonSerdeAdapter);
    const lockProvider: IGroupableLockProvider = new LockProvider({
      serde,
      adapter: new MemoryLockAdapter({
        rootGroup: "@global"
      }),
      eventBus,
    });

    const lock = lockProvider.create("a");

    const listener: Invokable <LockEvents> = event => {
      console.log(event);
    }
    const unsubscribe = await lock.subscribeMany([KeyAcquiredLockEvent], listener);
    await lock.acquire();
    await unsubscribe();

Settings

Member Visibility

On This Page

Methods