@daiso-tech/core 0.40.0 → 0.41.1

package/dist/shared-lock/contracts/shared-lock-state.contract.d.ts

@@ -0,0 +1,133 @@
+/**
+ * @module SharedLock
+ */
+import type { TimeSpan } from "../../time-span/implementations/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export declare const SHARED_LOCK_WRITER_STATE: {
+    readonly WRITER_UNAVAILABLE: "WRITER_UNAVAILABLE";
+    readonly WRITER_ACQUIRED: "WRITER_ACQUIRED";
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type SharedLockWriterState = (typeof SHARED_LOCK_WRITER_STATE)[keyof typeof SHARED_LOCK_WRITER_STATE];
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export declare const SHARED_LOCK_READER_STATE: {
+    readonly READER_LIMIT_REACHED: "READER_LIMIT_REACHED";
+    readonly READER_ACQUIRED: "READER_ACQUIRED";
+    readonly READER_UNACQUIRED: "READER_UNACQUIRED";
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type SharedLockReaderState = (typeof SHARED_LOCK_READER_STATE)[keyof typeof SHARED_LOCK_READER_STATE];
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export declare const SHARED_LOCK_STATE: {
+    readonly READER_LIMIT_REACHED: "READER_LIMIT_REACHED";
+    readonly READER_ACQUIRED: "READER_ACQUIRED";
+    readonly READER_UNACQUIRED: "READER_UNACQUIRED";
+    readonly WRITER_UNAVAILABLE: "WRITER_UNAVAILABLE";
+    readonly WRITER_ACQUIRED: "WRITER_ACQUIRED";
+    readonly EXPIRED: "EXPIRED";
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type SharedLockState = (typeof SHARED_LOCK_STATE)[keyof typeof SHARED_LOCK_STATE];
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockExpiredState = {
+    type: (typeof SHARED_LOCK_STATE)["EXPIRED"];
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockWriterUnavailableState = {
+    type: (typeof SHARED_LOCK_WRITER_STATE)["WRITER_UNAVAILABLE"];
+    owner: string;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockWriterAcquiredState = {
+    type: (typeof SHARED_LOCK_WRITER_STATE)["WRITER_ACQUIRED"];
+    remainingTime: TimeSpan | null;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockWriterState = ISharedLockWriterUnavailableState | ISharedLockWriterAcquiredState;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockReaderUnacquiredState = {
+    type: (typeof SHARED_LOCK_READER_STATE)["READER_UNACQUIRED"];
+    limit: number;
+    freeSlotsCount: number;
+    acquiredSlotsCount: number;
+    acquiredSlots: string[];
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockReaderAcquiredState = {
+    type: (typeof SHARED_LOCK_READER_STATE)["READER_ACQUIRED"];
+    limit: number;
+    remainingTime: TimeSpan | null;
+    freeSlotsCount: number;
+    acquiredSlotsCount: number;
+    acquiredSlots: string[];
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockReaderLimitReachedState = {
+    type: (typeof SHARED_LOCK_READER_STATE)["READER_LIMIT_REACHED"];
+    limit: number;
+    acquiredSlots: string[];
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockReaderState = ISharedLockReaderUnacquiredState | ISharedLockReaderAcquiredState | ISharedLockReaderLimitReachedState;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockState = ISharedLockExpiredState | ISharedLockWriterState | ISharedLockReaderState;

package/dist/shared-lock/contracts/shared-lock-state.contract.js

@@ -0,0 +1,33 @@
+/**
+ * @module SharedLock
+ */
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export const SHARED_LOCK_WRITER_STATE = {
+    WRITER_UNAVAILABLE: "WRITER_UNAVAILABLE",
+    WRITER_ACQUIRED: "WRITER_ACQUIRED",
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export const SHARED_LOCK_READER_STATE = {
+    READER_LIMIT_REACHED: "READER_LIMIT_REACHED",
+    READER_ACQUIRED: "READER_ACQUIRED",
+    READER_UNACQUIRED: "READER_UNACQUIRED",
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export const SHARED_LOCK_STATE = {
+    EXPIRED: "EXPIRED",
+    ...SHARED_LOCK_WRITER_STATE,
+    ...SHARED_LOCK_READER_STATE,
+};
+//# sourceMappingURL=shared-lock-state.contract.js.map

package/dist/shared-lock/contracts/shared-lock-state.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-lock-state.contract.js","sourceRoot":"","sources":["../../../src/shared-lock/contracts/shared-lock-state.contract.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACpC,kBAAkB,EAAE,oBAAoB;IACxC,eAAe,EAAE,iBAAiB;CAC5B,CAAC;AAUX;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACpC,oBAAoB,EAAE,sBAAsB;IAC5C,eAAe,EAAE,iBAAiB;IAClC,iBAAiB,EAAE,mBAAmB;CAChC,CAAC;AAUX;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC7B,OAAO,EAAE,SAAS;IAClB,GAAG,wBAAwB;IAC3B,GAAG,wBAAwB;CACrB,CAAC"}

package/dist/shared-lock/contracts/shared-lock.contract.d.ts

@@ -0,0 +1,222 @@
+/**
+ * @module SharedLock
+ */
+import type { Task } from "../../task/_module-exports.js";
+import type { AsyncLazy, Result } from "../../utilities/_module-exports.js";
+import type { LimitReachedReaderSemaphoreError, FailedAcquireWriterLockError } from "../../shared-lock/contracts/shared-lock.errors.js";
+import type { ISharedLockState } from "../../shared-lock/contracts/shared-lock-state.contract.js";
+import type { TimeSpan } from "../../time-span/implementations/_module-exports.js";
+import type { ITimeSpan } from "../../time-span/contracts/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type SharedLockAquireBlockingSettings = {
+    time?: ITimeSpan;
+    interval?: ITimeSpan;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type IReaderSemaphore = {
+    /**
+     * The `runReader` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquire` and `release` method.
+     *
+     */
+    runReader<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<Result<TValue, LimitReachedReaderSemaphoreError>>;
+    /**
+     * The `runReaderOrFail` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquireOrFail` and `release` method.
+     * @throws {LimitReachedReaderSemaphoreError} {@link LimitReachedReaderSemaphoreError}
+     */
+    runReaderOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<TValue>;
+    /**
+     * The `runReaderBlocking` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquireBlocking` and `release` method.
+     */
+    runReaderBlocking<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SharedLockAquireBlockingSettings): Task<Result<TValue, LimitReachedReaderSemaphoreError>>;
+    /**
+     * The `runReaderBlockingOrFail` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquireBlockingOrFail` and `release` method.
+     * @throws {LimitReachedReaderSemaphoreError} {@link LimitReachedReaderSemaphoreError}
+     */
+    runReaderBlockingOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SharedLockAquireBlockingSettings): Task<TValue>;
+    /**
+     * The `acquireReader` method acquires an slots only if the slot limit is not reached.
+     *
+     * @returns Returns true if the slot limit is not reached otherwise false is returned.
+     */
+    acquireReader(): Task<boolean>;
+    /**
+     * The `acquireReaderOrFail` method acquires an slots only if the slot limit is not reached.
+     * Throws an error if the slot limit is reached.
+     *
+     * @throws {LimitReachedReaderSemaphoreError} {@link LimitReachedReaderSemaphoreError}
+     */
+    acquireReaderOrFail(): Task<void>;
+    /**
+     * The `acquireReaderBlocking` method acquires an slots only if the slot limit is not reached.
+     * If the slot limit is reached, it retries every `settings.interval` until `settings.time` is reached.
+     *
+     * @returns Returns true if the slot limit is not reached otherwise false is returned.
+     */
+    acquireReaderBlocking(settings?: SharedLockAquireBlockingSettings): Task<boolean>;
+    /**
+     * The `acquireReaderBlockingOrFail` method acquires an slots only if the slot limit is not reached.
+     * If the slot limit is reached, it retries every `settings.interval` until `settings.time` is reached.
+     * Throws an error if the slot limit is reached after the given `settings.time`.
+     *
+     * @throws {LimitReachedReaderSemaphoreError} {@link LimitReachedReaderSemaphoreError}
+     */
+    acquireReaderBlockingOrFail(settings?: SharedLockAquireBlockingSettings): Task<void>;
+    /**
+     * The `releaseReader` method releases the current slot.
+     *
+     * @returns Returns true if the semaphore exists and has at least one busy slot or false.
+     */
+    releaseReader(): Task<boolean>;
+    /**
+     * The `releaseReaderOrFail` method releases the current slot.
+     * Throws an error if the slot is not acquired.
+     * @throws {FailedReleaseReaderSemaphoreError} {@link FailedReleaseReaderSemaphoreError}
+     */
+    releaseReaderOrFail(): Task<void>;
+    /**
+     * The `forceReleaseAllReaders` method releases the all slots.
+     *
+     * @returns Returns true if the semaphore exists and has at least one unavailable slot or false if all slots are available.
+     */
+    forceReleaseAllReaders(): Task<boolean>;
+    /**
+     * The `refreshReader` method updates the `ttl` of the slot when acquired.
+     *
+     * @returns Returns true if the slot is refreshed otherwise false is returned.
+     */
+    refreshReader(ttl?: ITimeSpan): Task<boolean>;
+    /**
+     * The `refreshReaderOrFail` method updates the `ttl` of the slot when acquired.
+     * Throws an error if the slot is not acquired.
+     * @throws {FailedRefreshReaderSemaphoreError} {@link FailedRefreshReaderSemaphoreError}
+     */
+    refreshReaderOrFail(ttl?: ITimeSpan): Task<void>;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type IWriterLock = {
+    /**
+     * The `runWriter` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquire` and `release` method.
+     */
+    runWriter<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<Result<TValue, FailedAcquireWriterLockError>>;
+    /**
+     * The `runWriterOrFail` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquireOrFail` and `release` method.
+     * @throws {FailedAcquireWriterLockError} {@link FailedAcquireWriterLockError}
+     */
+    runWriterOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<TValue>;
+    /**
+     * The `runWriterBlocking` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquireBlocking` and `release` method.
+     */
+    runWriterBlocking<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SharedLockAquireBlockingSettings): Task<Result<TValue, FailedAcquireWriterLockError>>;
+    /**
+     * The `runWriterBlockingOrFail` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquireBlockingOrFail` and `release` method.
+     * @throws {FailedAcquireWriterLockError} {@link FailedAcquireWriterLockError}
+     */
+    runWriterBlockingOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SharedLockAquireBlockingSettings): Task<TValue>;
+    /**
+     * The `acquireWriter` method acquires a lock only if the key is not already acquired by different owner.
+     *
+     * @returns Returns true if the lock is not already acquired otherwise false is returned.
+     */
+    acquireWriter(): Task<boolean>;
+    /**
+     * The `acquireWriterOrFail` method acquires a lock only if the key is not already acquired by different owner.
+     * Throws an error if the lock is already acquired by different owner.
+     *
+     * @throws {FailedAcquireWriterLockError} {@link FailedAcquireWriterLockError}
+     */
+    acquireWriterOrFail(): Task<void>;
+    /**
+     * The `acquireWriterBlocking` method acquires a lock only if the key is not already acquired by different owner.
+     * If the lock is not acquired, it retries every `settings.interval` until `settings.time` is reached.
+     *
+     * @returns Returns true if the lock is not already acquired otherwise false is returned.
+     */
+    acquireWriterBlocking(settings?: SharedLockAquireBlockingSettings): Task<boolean>;
+    /**
+     * The `acquireWriterBlockingOrFail` method acquires a lock only if the key is not already acquired by different owner.
+     * If the lock is not acquired, it retries every `settings.interval` until `settings.time` is reached.
+     * Throws an error if the lock is already acquired by different owner.
+     *
+     * @throws {FailedAcquireWriterLockError} {@link FailedAcquireWriterLockError}
+     */
+    acquireWriterBlockingOrFail(settings?: SharedLockAquireBlockingSettings): Task<void>;
+    /**
+     * The `releaseWriter` method releases a lock if owned by the same owner.
+     *
+     * @returns Returns true if the lock is released otherwise false is returned.
+     */
+    releaseWriter(): Task<boolean>;
+    /**
+     * The `releaseWriterOrFail` method releases a lock if owned by the same owner.
+     * Throws an error if the lock is not owned by same owner.
+     *
+     * @throws {FailedReleaseWriterLockError} {@link FailedReleaseWriterLockError}
+     */
+    releaseWriterOrFail(): Task<void>;
+    /**
+     * The `forceReleaseWriter` method releases a lock regardless of the owner.
+     *
+     * @returns Returns true if the lock exists or false if the lock doesnt exists.
+     */
+    forceReleaseWriter(): Task<boolean>;
+    /**
+     * The `refreshWriter` method updates the `ttl` of the lock if expireable and owned by the same owner.
+     *
+     * @returns Returns true if the lock is refreshed otherwise false is returned.
+     */
+    refreshWriter(ttl?: ITimeSpan): Task<boolean>;
+    /**
+     * The `refreshWriterOrFail` method updates the `ttl` of the lock if expireable and owned by the same owner.
+     * Throws an error if the lock is not owned by same owner.
+     * Throws an error if the key is unexpirable.
+     *
+     * @throws {FailedRefreshWriterLockError} {@link FailedRefreshWriterLockError}
+     */
+    refreshWriterOrFail(ttl?: ITimeSpan): Task<void>;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockStateMethods = {
+    getState(): Task<ISharedLockState>;
+    /**
+     * The `key` of the `ISharedLock` instance.
+     */
+    readonly key: string;
+    /**
+     * The `id` of the `ISharedLock` instance.
+     */
+    readonly id: string;
+    /**
+     * The `ttl` of `ISharedLock` instance.
+     */
+    readonly ttl: TimeSpan | null;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLockBase = IReaderSemaphore & IWriterLock & {
+    forceRelease(): Task<boolean>;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Contracts
+ */
+export type ISharedLock = ISharedLockBase & ISharedLockStateMethods;

package/dist/shared-lock/contracts/shared-lock.contract.js

@@ -0,0 +1,13 @@
+/**
+ * @module SharedLock
+ */
+import { 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+FailedRefreshReaderSemaphoreError, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+FailedReleaseReaderSemaphoreError, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+FailedReleaseWriterLockError, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+FailedRefreshWriterLockError, } from "../../shared-lock/contracts/shared-lock.errors.js";
+//# sourceMappingURL=shared-lock.contract.js.map

package/dist/shared-lock/contracts/shared-lock.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-lock.contract.js","sourceRoot":"","sources":["../../../src/shared-lock/contracts/shared-lock.contract.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO;AACH,6DAA6D;AAC7D,iCAAiC;AACjC,6DAA6D;AAC7D,iCAAiC;AACjC,6DAA6D;AAC7D,4BAA4B;AAC5B,6DAA6D;AAC7D,4BAA4B,GAC/B,MAAM,+CAA+C,CAAC"}

package/dist/shared-lock/contracts/shared-lock.errors.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @module SharedLock
+ */
+/**
+ * The error is thrown when trying to acquire a semaphore slot, but all slots are already taken.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare class LimitReachedReaderSemaphoreError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * The error is thrown when trying to referesh a semaphore slot that is already expired.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare class FailedRefreshReaderSemaphoreError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * The error is thrown when trying to release a semaphore slot that is already expired.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare class FailedReleaseReaderSemaphoreError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare const READER_SEMAPHORE_ERRORS: {
+    readonly ReachedLimit: typeof LimitReachedReaderSemaphoreError;
+    readonly FailedRefresh: typeof FailedRefreshReaderSemaphoreError;
+    readonly FailedRelease: typeof FailedReleaseReaderSemaphoreError;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export type AllReaderSemaphoreErrors = LimitReachedReaderSemaphoreError | FailedRefreshReaderSemaphoreError | FailedReleaseReaderSemaphoreError;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare function isReaderSemaphoreError(value: unknown): value is AllReaderSemaphoreErrors;
+/**
+ * The error is thrown when trying to acquire a lock that is owned by a different owner.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare class FailedAcquireWriterLockError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * The error is thrown when trying to release a lock that is owned by a different owner.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare class FailedReleaseWriterLockError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * The error is thrown when trying to referesh a lock that is owned by a different owner.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare class FailedRefreshWriterLockError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare const WRITER_LOCK_ERRORS: {
+    readonly FailedAcquire: typeof FailedAcquireWriterLockError;
+    readonly FailedRelease: typeof FailedReleaseWriterLockError;
+    readonly FailedRefresh: typeof FailedRefreshWriterLockError;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export type AllWriterLockErrors = FailedAcquireWriterLockError | FailedReleaseWriterLockError | FailedRefreshWriterLockError;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare function isWriterLockError(value: unknown): value is AllWriterLockErrors;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare const SHARED_LOCK_ERRORS: {
+    readonly FailedAcquire: typeof FailedAcquireWriterLockError;
+    readonly FailedRelease: typeof FailedReleaseWriterLockError;
+    readonly FailedRefresh: typeof FailedRefreshWriterLockError;
+    readonly ReachedLimit: typeof LimitReachedReaderSemaphoreError;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export type AllSharedLockErrors = AllWriterLockErrors | AllReaderSemaphoreErrors;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export declare function isSharedLockError(value: unknown): value is AllSharedLockErrors;

package/dist/shared-lock/contracts/shared-lock.errors.js

@@ -0,0 +1,136 @@
+/**
+ * @module SharedLock
+ */
+/**
+ * The error is thrown when trying to acquire a semaphore slot, but all slots are already taken.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export class LimitReachedReaderSemaphoreError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = LimitReachedReaderSemaphoreError.name;
+    }
+}
+/**
+ * The error is thrown when trying to referesh a semaphore slot that is already expired.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export class FailedRefreshReaderSemaphoreError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = FailedRefreshReaderSemaphoreError.name;
+    }
+}
+/**
+ * The error is thrown when trying to release a semaphore slot that is already expired.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export class FailedReleaseReaderSemaphoreError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = FailedReleaseReaderSemaphoreError.name;
+    }
+}
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export const READER_SEMAPHORE_ERRORS = {
+    ReachedLimit: LimitReachedReaderSemaphoreError,
+    FailedRefresh: FailedRefreshReaderSemaphoreError,
+    FailedRelease: FailedReleaseReaderSemaphoreError,
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export function isReaderSemaphoreError(value) {
+    for (const ErrorClass of Object.values(READER_SEMAPHORE_ERRORS)) {
+        if (!(value instanceof ErrorClass)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * The error is thrown when trying to acquire a lock that is owned by a different owner.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export class FailedAcquireWriterLockError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+    }
+}
+/**
+ * The error is thrown when trying to release a lock that is owned by a different owner.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export class FailedReleaseWriterLockError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+    }
+}
+/**
+ * The error is thrown when trying to referesh a lock that is owned by a different owner.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export class FailedRefreshWriterLockError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+    }
+}
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export const WRITER_LOCK_ERRORS = {
+    FailedAcquire: FailedAcquireWriterLockError,
+    FailedRelease: FailedReleaseWriterLockError,
+    FailedRefresh: FailedRefreshWriterLockError,
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export function isWriterLockError(value) {
+    for (const ErrorClass of Object.values(WRITER_LOCK_ERRORS)) {
+        if (!(value instanceof ErrorClass)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export const SHARED_LOCK_ERRORS = {
+    ...READER_SEMAPHORE_ERRORS,
+    ...WRITER_LOCK_ERRORS,
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock/contracts"`
+ * @group Errors
+ */
+export function isSharedLockError(value) {
+    return isReaderSemaphoreError(value) || isWriterLockError(value);
+}
+//# sourceMappingURL=shared-lock.errors.js.map

package/dist/shared-lock/contracts/shared-lock.errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-lock.errors.js","sourceRoot":"","sources":["../../../src/shared-lock/contracts/shared-lock.errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,MAAM,OAAO,gCAAiC,SAAQ,KAAK;IACvD,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,gCAAgC,CAAC,IAAI,CAAC;IACtD,CAAC;CACJ;AAED;;;;;GAKG;AACH,MAAM,OAAO,iCAAkC,SAAQ,KAAK;IACxD,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,iCAAiC,CAAC,IAAI,CAAC;IACvD,CAAC;CACJ;AAED;;;;;GAKG;AACH,MAAM,OAAO,iCAAkC,SAAQ,KAAK;IACxD,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,iCAAiC,CAAC,IAAI,CAAC;IACvD,CAAC;CACJ;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACnC,YAAY,EAAE,gCAAgC;IAC9C,aAAa,EAAE,iCAAiC;IAChD,aAAa,EAAE,iCAAiC;CAC1C,CAAC;AAYX;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAClC,KAAc;IAEd,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,MAAM,CAAC,uBAAuB,CAAC,EAAE,CAAC;QAC9D,IAAI,CAAC,CAAC,KAAK,YAAY,UAAU,CAAC,EAAE,CAAC;YACjC,OAAO,KAAK,CAAC;QACjB,CAAC;IACL,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,OAAO,4BAA6B,SAAQ,KAAK;IACnD,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9B,CAAC;CACJ;AAED;;;;;GAKG;AACH,MAAM,OAAO,4BAA6B,SAAQ,KAAK;IACnD,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9B,CAAC;CACJ;AAED;;;;;GAKG;AACH,MAAM,OAAO,4BAA6B,SAAQ,KAAK;IACnD,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9B,CAAC;CACJ;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAC9B,aAAa,EAAE,4BAA4B;IAC3C,aAAa,EAAE,4BAA4B;IAC3C,aAAa,EAAE,4BAA4B;CACrC,CAAC;AAYX;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC7B,KAAc;IAEd,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,EAAE,CAAC;QACzD,IAAI,CAAC,CAAC,KAAK,YAAY,UAAU,CAAC,EAAE,CAAC;YACjC,OAAO,KAAK,CAAC;QACjB,CAAC;IACL,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAC9B,GAAG,uBAAuB;IAC1B,GAAG,kBAAkB;CACf,CAAC;AAWX;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC7B,KAAc;IAEd,OAAO,sBAAsB,CAAC,KAAK,CAAC,IAAI,iBAAiB,CAAC,KAAK,CAAC,CAAC;AACrE,CAAC"}