@daiso-tech/core 0.39.0 → 0.41.0

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

@@ -0,0 +1,52 @@
+/**
+ * @module Lock
+ */
+import type { TimeSpan } from "../../time-span/implementations/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export declare const LOCK_STATE: {
+    readonly EXPIRED: "EXPIRED";
+    readonly UNAVAILABLE: "UNAVAILABLE";
+    readonly ACQUIRED: "ACQUIRED";
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export type LockState = (typeof LOCK_STATE)[keyof typeof LOCK_STATE];
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export type ILockExpiredState = {
+    type: (typeof LOCK_STATE)["EXPIRED"];
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export type ILockUnavailableState = {
+    type: (typeof LOCK_STATE)["UNAVAILABLE"];
+    owner: string;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export type ILockAcquiredState = {
+    type: (typeof LOCK_STATE)["ACQUIRED"];
+    remainingTime: TimeSpan | null;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export type ILockState = ILockUnavailableState | ILockAcquiredState | ILockExpiredState;

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

@@ -0,0 +1,14 @@
+/**
+ * @module Lock
+ */
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export const LOCK_STATE = {
+    EXPIRED: "EXPIRED",
+    UNAVAILABLE: "UNAVAILABLE",
+    ACQUIRED: "ACQUIRED",
+};
+//# sourceMappingURL=lock-state.contract.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lock-state.contract.js","sourceRoot":"","sources":["../../../src/lock/contracts/lock-state.contract.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACtB,OAAO,EAAE,SAAS;IAClB,WAAW,EAAE,aAAa;IAC1B,QAAQ,EAAE,UAAU;CACd,CAAC"}

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

@@ -1,115 +1,129 @@
 /**
  * @module Lock
  */
-import type { AsyncLazy, Result, TimeSpan } from "../../utilities/_module-exports.js";
-import type { LazyPromise } from "../../async/_module-exports.js";
-import type { KeyAlreadyAcquiredLockError } from "../../lock/contracts/lock.errors.js";
+import type { AsyncLazy, Result } from "../../utilities/_module-exports.js";
+import type { Task } from "../../task/_module-exports.js";
+import type { FailedAcquireLockError } from "../../lock/contracts/lock.errors.js";
+import type { ILockState } from "../../lock/contracts/lock-state.contract.js";
+import type { ITimeSpan } from "../../time-span/contracts/_module-exports.js";
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Contracts
  */
 export type LockAquireBlockingSettings = {
-    time?: TimeSpan;
-    interval?: TimeSpan;
+    time?: ITimeSpan;
+    interval?: ITimeSpan;
 };
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Contracts
  */
-export type ILock = {
+export type ILockStateMethods = {
+    getState(): Task<ILockState>;
     /**
-     * The `run` method wraps an {@link Invokable | `Invokable`} or {@link LazyPromise| `LazyPromise`} with the `acquire` and `release` method.
+     * The `key` of the `ILock` instance.
      */
-    run<TValue = void>(asyncFn: AsyncLazy<TValue>): LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>;
+    readonly key: string;
     /**
-     * The `runOrFail` method wraps an {@link Invokable | `Invokable`} or {@link LazyPromise| `LazyPromise`} with the `acquireOrFail` and `release` method.
-     * @throws {KeyAlreadyAcquiredLockError} {@link KeyAlreadyAcquiredLockError}
+     * The `id` of the `ILock` instance.
      */
-    runOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>): LazyPromise<TValue>;
+    readonly id: string;
     /**
-     * The `runBlocking` method wraps an {@link Invokable | `Invokable`} or {@link LazyPromise| `LazyPromise`} with the `acquireBlocking` and `release` method.
+     * The `ttl` of `ILock` instance.
      */
-    runBlocking<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: LockAquireBlockingSettings): LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>;
+    readonly ttl: ITimeSpan | null;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export type ILockBase = {
     /**
-     * The `runBlockingOrFail` method wraps an {@link Invokable | `Invokable`} or {@link LazyPromise| `LazyPromise`} with the `acquireBlockingOrFail` and `release` method.
-     * @throws {KeyAlreadyAcquiredLockError} {@link KeyAlreadyAcquiredLockError}
+     * The `run` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquire` and `release` method.
      */
-    runBlockingOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: LockAquireBlockingSettings): LazyPromise<TValue>;
+    run<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<Result<TValue, FailedAcquireLockError>>;
     /**
-     * The `acquire` method acquires a lock only if the lock is available.
+     * The `runOrFail` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquireOrFail` and `release` method.
+     * @throws {FailedAcquireLockError} {@link FailedAcquireLockError}
+     */
+    runOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<TValue>;
+    /**
+     * The `runBlocking` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquireBlocking` and `release` method.
+     */
+    runBlocking<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: LockAquireBlockingSettings): Task<Result<TValue, FailedAcquireLockError>>;
+    /**
+     * The `runBlockingOrFail` method wraps an {@link Invokable | `Invokable`} or {@link Task | `Task`} with the `acquireBlockingOrFail` and `release` method.
+     * @throws {FailedAcquireLockError} {@link FailedAcquireLockError}
+     */
+    runBlockingOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: LockAquireBlockingSettings): Task<TValue>;
+    /**
+     * The `acquire` method acquires a lock only if the key is not already acquired by different owner.
      *
-     * @returns Returns true if the lock is acquired otherwise false is returned.
+     * @returns Returns true if the lock is not already acquired otherwise false is returned.
      */
-    acquire(): LazyPromise<boolean>;
+    acquire(): Task<boolean>;
     /**
-     * The `acquireOrFail` method acquires a lock only if the lock is available.
-     * Throws an error if already acquired.
+     * The `acquireOrFail` 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 {KeyAlreadyAcquiredLockError} {@link KeyAlreadyAcquiredLockError}
+     * @throws {FailedAcquireLockError} {@link FailedAcquireLockError}
      */
-    acquireOrFail(): LazyPromise<void>;
+    acquireOrFail(): Task<void>;
     /**
-     * The `acquireBlocking` method acquires a lock only if the lock is available.
+     * The `acquireBlocking` 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 acquired otherwise false is returned.
+     * @returns Returns true if the lock is not already acquired otherwise false is returned.
      */
-    acquireBlocking(settings?: LockAquireBlockingSettings): LazyPromise<boolean>;
+    acquireBlocking(settings?: LockAquireBlockingSettings): Task<boolean>;
     /**
-     * The `acquireBlockingOrFail` method acquires a lock only if the lock is available.
+     * The `acquireBlockingOrFail` 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 cannot be acquired after the given `settings.time`.
+     * Throws an error if the lock is already acquired by different owner.
      *
-     * @throws {KeyAlreadyAcquiredLockError} {@link KeyAlreadyAcquiredLockError}
+     * @throws {FailedAcquireLockError} {@link FailedAcquireLockError}
      */
-    acquireBlockingOrFail(settings?: LockAquireBlockingSettings): LazyPromise<void>;
+    acquireBlockingOrFail(settings?: LockAquireBlockingSettings): Task<void>;
     /**
      * The `release` method releases a lock if owned by the same owner.
      *
      * @returns Returns true if the lock is released otherwise false is returned.
      */
-    release(): LazyPromise<boolean>;
+    release(): Task<boolean>;
     /**
      * The `releaseOrFail` method releases a lock if owned by the same owner.
-     * Throws an error if a different owner attempts to release the lock.
+     * Throws an error if the lock is not owned by same owner.
      *
-     * @throws {UnownedReleaseLockError} {@link UnownedReleaseLockError}
+     * @throws {FailedReleaseLockError} {@link FailedReleaseLockError}
      */
-    releaseOrFail(): LazyPromise<void>;
+    releaseOrFail(): Task<void>;
     /**
      * The `forceRelease` method releases a lock regardless of the owner.
+     *
+     * @returns Returns true if the lock exists or false if the lock doesnt exists.
      */
-    forceRelease(): LazyPromise<void>;
-    /**
-     * The `isExpired` method returns true if the lock is expired otherwise false is returned.
-     */
-    isExpired(): LazyPromise<boolean>;
-    /**
-     * The `isLocked` method returns true if the locked otherwise false is returned.
-     */
-    isLocked(): LazyPromise<boolean>;
+    forceRelease(): Task<boolean>;
     /**
-     * The `refresh` method updates the `ttl` of the lock if owned by the same owner.
+     * The `refresh` 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.
      */
-    refresh(ttl?: TimeSpan): LazyPromise<boolean>;
+    refresh(ttl?: ITimeSpan): Task<boolean>;
     /**
-     * The `refreshOrFail` method updates the `ttl` of the lock if owned by the same owner.
-     * Throws an error if a different owner attempts to refresh the lock.
-     * @throws {UnownedRefreshLockError} {@link UnownedRefreshLockError}
-     */
-    refreshOrFail(ttl?: TimeSpan): LazyPromise<void>;
-    /**
-     * The `getRemainingTime` return the reaming time as {@link TimeSpan | `TimeSpan`}.
+     * The `refreshOrFail` 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.
      *
-     * @returns Returns null if the key doesnt exist, key has no expiration and key has expired.
+     * @throws {FailedRefreshLockError} {@link FailedRefreshLockError}
      */
-    getRemainingTime(): LazyPromise<TimeSpan | null>;
-    /**
-     * The `getOwner` method return the current owner.
-     */
-    getOwner(): LazyPromise<string>;
+    refreshOrFail(ttl?: ITimeSpan): Task<void>;
 };
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export type ILock = ILockBase & ILockStateMethods;

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

@@ -1,21 +1,13 @@
 /**
  * @module Lock
  */
-/**
- *
- * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
- * @group Errors
- */
-export declare class LockError extends Error {
-    constructor(message: string, cause?: unknown);
-}
 /**
  * The error is thrown when trying to acquire a lock that is owned by a different owner.
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Errors
  */
-export declare class KeyAlreadyAcquiredLockError extends LockError {
+export declare class FailedAcquireLockError extends Error {
     constructor(message: string, cause?: unknown);
 }
 /**
@@ -24,7 +16,7 @@ export declare class KeyAlreadyAcquiredLockError extends LockError {
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Errors
  */
-export declare class UnownedReleaseLockError extends LockError {
+export declare class FailedReleaseLockError extends Error {
     constructor(message: string, cause?: unknown);
 }
 /**
@@ -33,7 +25,7 @@ export declare class UnownedReleaseLockError extends LockError {
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Errors
  */
-export declare class UnownedRefreshLockError extends LockError {
+export declare class FailedRefreshLockError extends Error {
     constructor(message: string, cause?: unknown);
 }
 /**
@@ -42,8 +34,19 @@ export declare class UnownedRefreshLockError extends LockError {
  * @group Errors
  */
 export declare const LOCK_ERRORS: {
-    readonly Base: typeof LockError;
-    readonly KeyAlreadyAcquired: typeof KeyAlreadyAcquiredLockError;
-    readonly UnownedRelease: typeof UnownedReleaseLockError;
-    readonly UnownedRefresh: typeof UnownedRefreshLockError;
+    readonly FailedAcquire: typeof FailedAcquireLockError;
+    readonly FailedRelease: typeof FailedReleaseLockError;
+    readonly FailedRefresh: typeof FailedRefreshLockError;
 };
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Errors
+ */
+export type AllLockErrors = FailedAcquireLockError | FailedReleaseLockError | FailedRefreshLockError;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Errors
+ */
+export declare function isLockError(value: unknown): value is AllLockErrors;

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

@@ -1,25 +1,16 @@
 /**
  * @module Lock
  */
-/**
- *
- * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
- * @group Errors
- */
-export class LockError extends Error {
-    constructor(message, cause) {
-        super(message, { cause });
-    }
-}
 /**
  * The error is thrown when trying to acquire a lock that is owned by a different owner.
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Errors
  */
-export class KeyAlreadyAcquiredLockError extends LockError {
+export class FailedAcquireLockError extends Error {
     constructor(message, cause) {
         super(message, { cause });
+        this.name = FailedAcquireLockError.name;
     }
 }
 /**
@@ -28,9 +19,10 @@ export class KeyAlreadyAcquiredLockError extends LockError {
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Errors
  */
-export class UnownedReleaseLockError extends LockError {
+export class FailedReleaseLockError extends Error {
     constructor(message, cause) {
         super(message, { cause });
+        this.name = FailedReleaseLockError.name;
     }
 }
 /**
@@ -39,9 +31,10 @@ export class UnownedReleaseLockError extends LockError {
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Errors
  */
-export class UnownedRefreshLockError extends LockError {
+export class FailedRefreshLockError extends Error {
     constructor(message, cause) {
         super(message, { cause });
+        this.name = FailedRefreshLockError.name;
     }
 }
 /**
@@ -50,9 +43,21 @@ export class UnownedRefreshLockError extends LockError {
  * @group Errors
  */
 export const LOCK_ERRORS = {
-    Base: LockError,
-    KeyAlreadyAcquired: KeyAlreadyAcquiredLockError,
-    UnownedRelease: UnownedReleaseLockError,
-    UnownedRefresh: UnownedRefreshLockError,
+    FailedAcquire: FailedAcquireLockError,
+    FailedRelease: FailedReleaseLockError,
+    FailedRefresh: FailedRefreshLockError,
 };
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Errors
+ */
+export function isLockError(value) {
+    for (const ErrorClass of Object.values(LOCK_ERRORS)) {
+        if (!(value instanceof ErrorClass)) {
+            return false;
+        }
+    }
+    return true;
+}
 //# sourceMappingURL=lock.errors.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"lock.errors.js","sourceRoot":"","sources":["../../../src/lock/contracts/lock.errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,MAAM,OAAO,SAAU,SAAQ,KAAK;IAChC,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9B,CAAC;CACJ;AAED;;;;;GAKG;AACH,MAAM,OAAO,2BAA4B,SAAQ,SAAS;IACtD,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9B,CAAC;CACJ;AAED;;;;;GAKG;AACH,MAAM,OAAO,uBAAwB,SAAQ,SAAS;IAClD,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9B,CAAC;CACJ;AAED;;;;;GAKG;AACH,MAAM,OAAO,uBAAwB,SAAQ,SAAS;IAClD,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9B,CAAC;CACJ;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,IAAI,EAAE,SAAS;IACf,kBAAkB,EAAE,2BAA2B;IAC/C,cAAc,EAAE,uBAAuB;IACvC,cAAc,EAAE,uBAAuB;CACjC,CAAC"}
+{"version":3,"file":"lock.errors.js","sourceRoot":"","sources":["../../../src/lock/contracts/lock.errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAC7C,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC,IAAI,CAAC;IAC5C,CAAC;CACJ;AAED;;;;;GAKG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAC7C,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC,IAAI,CAAC;IAC5C,CAAC;CACJ;AAED;;;;;GAKG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAC7C,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC,IAAI,CAAC;IAC5C,CAAC;CACJ;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,aAAa,EAAE,sBAAsB;IACrC,aAAa,EAAE,sBAAsB;IACrC,aAAa,EAAE,sBAAsB;CAC/B,CAAC;AAYX;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,KAAc;IACtC,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QAClD,IAAI,CAAC,CAAC,KAAK,YAAY,UAAU,CAAC,EAAE,CAAC;YACjC,OAAO,KAAK,CAAC;QACjB,CAAC;IACL,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC"}

package/dist/lock/contracts/lock.events.d.ts

@@ -1,36 +1,36 @@
 /**
  * @module Lock
  */
-import type { TimeSpan } from "../../utilities/_module-exports.js";
+import type { ILockStateMethods } from "../../lock/contracts/lock.contract.js";
+/**
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Events
+ */
+export type LockEventBase = {
+    lock: ILockStateMethods;
+};
 /**
  * The event is dispatched when a lock is aquired.
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Events
  */
-export type AcquiredLockEvent = {
-    key: string;
-    owner: string;
-    ttl: TimeSpan | null;
-};
+export type AcquiredLockEvent = LockEventBase;
 /**
  * The event is dispatched when a lock is released.
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Events
  */
-export type ReleasedLockEvent = {
-    key: string;
-    owner: string;
-};
+export type ReleasedLockEvent = LockEventBase;
 /**
  * The event is dispatched when a lock is forcefully released.
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Events
  */
-export type ForceReleasedLockEvent = {
-    key: string;
+export type ForceReleasedLockEvent = LockEventBase & {
+    hasReleased: boolean;
 };
 /**
  * The event is dispatched when trying to release a lock that is owned by a different owner.
@@ -38,50 +38,34 @@ export type ForceReleasedLockEvent = {
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Events
  */
-export type UnownedReleaseTryLockEvent = {
-    key: string;
-    owner: string;
-};
+export type FailedReleaseLockEvent = LockEventBase;
 /**
  * The event is dispatched when trying to refefresh a lock that is owned by a different owner.
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Events
  */
-export type UnownedRefreshTryLockEvent = {
-    key: string;
-    owner: string;
-};
+export type FailedRefreshLockEvent = LockEventBase;
 /**
  * The event is dispatched when trying to acquire a lock that is owned by a different owner.
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Events
  */
-export type UnavailableLockEvent = {
-    key: string;
-    owner: string;
-};
+export type UnavailableLockEvent = LockEventBase;
 /**
  * The event is dispatched when a lock is refreshed.
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Events
  */
-export type RefreshedLockEvent = {
-    key: string;
-    owner: string;
-    ttl: TimeSpan;
-};
+export type RefreshedLockEvent = LockEventBase;
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Events
  */
-export type UnexpectedErrorLockEvent = {
-    key: string;
-    owner: string;
-    ttl: TimeSpan | null;
+export type UnexpectedErrorLockEvent = LockEventBase & {
     error: unknown;
 };
 /**
@@ -92,8 +76,8 @@ export type UnexpectedErrorLockEvent = {
 export declare const LOCK_EVENTS: {
     readonly ACQUIRED: "ACQUIRED";
     readonly RELEASED: "RELEASED";
-    readonly UNOWNED_RELEASE_TRY: "UNOWNED_RELEASE_TRY";
-    readonly UNOWNED_REFRESH_TRY: "UNOWNED_REFRESH_TRY";
+    readonly FAILED_RELEASE: "FAILED_RELEASE";
+    readonly FAILED_REFRESH: "FAILED_REFRESH";
     readonly UNAVAILABLE: "UNAVAILABLE";
     readonly FORCE_RELEASED: "FORCE_RELEASED";
     readonly REFRESHED: "REFRESHED";
@@ -107,8 +91,8 @@ export declare const LOCK_EVENTS: {
 export type LockEventMap = {
     [LOCK_EVENTS.ACQUIRED]: AcquiredLockEvent;
     [LOCK_EVENTS.RELEASED]: ReleasedLockEvent;
-    [LOCK_EVENTS.UNOWNED_RELEASE_TRY]: UnownedReleaseTryLockEvent;
-    [LOCK_EVENTS.UNOWNED_REFRESH_TRY]: UnownedRefreshTryLockEvent;
+    [LOCK_EVENTS.FAILED_RELEASE]: FailedReleaseLockEvent;
+    [LOCK_EVENTS.FAILED_REFRESH]: FailedRefreshLockEvent;
     [LOCK_EVENTS.UNAVAILABLE]: UnavailableLockEvent;
     [LOCK_EVENTS.FORCE_RELEASED]: ForceReleasedLockEvent;
     [LOCK_EVENTS.REFRESHED]: RefreshedLockEvent;

package/dist/lock/contracts/lock.events.js

@@ -9,8 +9,8 @@
 export const LOCK_EVENTS = {
     ACQUIRED: "ACQUIRED",
     RELEASED: "RELEASED",
-    UNOWNED_RELEASE_TRY: "UNOWNED_RELEASE_TRY",
-    UNOWNED_REFRESH_TRY: "UNOWNED_REFRESH_TRY",
+    FAILED_RELEASE: "FAILED_RELEASE",
+    FAILED_REFRESH: "FAILED_REFRESH",
     UNAVAILABLE: "UNAVAILABLE",
     FORCE_RELEASED: "FORCE_RELEASED",
     REFRESHED: "REFRESHED",

package/dist/lock/contracts/lock.events.js.map

@@ -1 +1 @@
-{"version":3,"file":"lock.events.js","sourceRoot":"","sources":["../../../src/lock/contracts/lock.events.ts"],"names":[],"mappings":"AAAA;;GAEG;AAgGH;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,QAAQ,EAAE,UAAU;IACpB,QAAQ,EAAE,UAAU;IACpB,mBAAmB,EAAE,qBAAqB;IAC1C,mBAAmB,EAAE,qBAAqB;IAC1C,WAAW,EAAE,aAAa;IAC1B,cAAc,EAAE,gBAAgB;IAChC,SAAS,EAAE,WAAW;IACtB,gBAAgB,EAAE,kBAAkB;CAC9B,CAAC"}
+{"version":3,"file":"lock.events.js","sourceRoot":"","sources":["../../../src/lock/contracts/lock.events.ts"],"names":[],"mappings":"AAAA;;GAEG;AAiFH;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,QAAQ,EAAE,UAAU;IACpB,QAAQ,EAAE,UAAU;IACpB,cAAc,EAAE,gBAAgB;IAChC,cAAc,EAAE,gBAAgB;IAChC,WAAW,EAAE,aAAa;IAC1B,cAAc,EAAE,gBAAgB;IAChC,SAAS,EAAE,WAAW;IACtB,gBAAgB,EAAE,kBAAkB;CAC9B,CAAC"}

package/dist/lock/contracts/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module Lock
+ */
+import type { IDatabaseLockAdapter } from "../../lock/contracts/database-lock-adapter.contract.js";
+import type { ILockAdapter } from "../../lock/contracts/lock-adapter.contract.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export type LockAdapterVariants = ILockAdapter | IDatabaseLockAdapter;

package/dist/lock/contracts/types.js

@@ -0,0 +1,5 @@
+/**
+ * @module Lock
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lock/contracts/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lock/contracts/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}