@daiso-tech/core 0.40.0 → 0.41.0

package/dist/{utilities/classes/hooks → hooks}/hooks.d.ts

@@ -1,18 +1,16 @@
 /**
- * @module Utilities
+ * @module Hooks
  */
-import { type IInvokableObject, type Invokable, type InvokableFn, type OneOrMore } from "../../../utilities/functions/_module.js";
-import type { HookContext } from "../../../utilities/classes/hooks/types.js";
+import { type IInvokableObject, type Invokable, type InvokableFn, type OneOrMore } from "../utilities/_module-exports.js";
+import type { HookContext } from "../hooks/types.js";
 /**
  *
- * IMPORT_PATH: `"@daiso-tech/core/utilities"`
- * @group Hooks
+ * IMPORT_PATH: `"@daiso-tech/core/hooks"`
  */
 export type NextFunc<TParameters extends unknown[] = unknown[], TReturn = unknown> = InvokableFn<TParameters, TReturn>;
 /**
  *
- * IMPORT_PATH: `"@daiso-tech/core/utilities"`
- * @group Hooks
+ * IMPORT_PATH: `"@daiso-tech/core/hooks"`
  */
 export type Context<TContext extends HookContext = HookContext> = {
     name: string;
@@ -20,8 +18,7 @@ export type Context<TContext extends HookContext = HookContext> = {
 };
 /**
  *
- * IMPORT_PATH: `"@daiso-tech/core/utilities"`
- * @group Hooks
+ * IMPORT_PATH: `"@daiso-tech/core/hooks"`
  */
 export type MiddlewareFn<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = InvokableFn<[
     arguments_: TParameters,
@@ -30,8 +27,7 @@ export type MiddlewareFn<TParameters extends unknown[] = unknown[], TReturn = un
 ], TReturn>;
 /**
  *
- * IMPORT_PATH: `"@daiso-tech/core/utilities"`
- * @group Hooks
+ * IMPORT_PATH: `"@daiso-tech/core/hooks"`
  */
 export type IMiddlewareObject<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = IInvokableObject<[
     arguments_: TParameters,
@@ -40,14 +36,12 @@ export type IMiddlewareObject<TParameters extends unknown[] = unknown[], TReturn
 ], TReturn>;
 /**
  *
- * IMPORT_PATH: `"@daiso-tech/core/utilities"`
- * @group Hooks
+ * IMPORT_PATH: `"@daiso-tech/core/hooks"`
  */
 export type Middleware<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = IMiddlewareObject<TParameters, TReturn, TContext> | MiddlewareFn<TParameters, TReturn, TContext>;
 /**
  *
- * IMPORT_PATH: `"@daiso-tech/core/utilities"`
- * @group Hooks
+ * IMPORT_PATH: `"@daiso-tech/core/hooks"`
  */
 export type HooksSettings<TContext extends HookContext = HookContext> = {
     /**
@@ -66,8 +60,7 @@ export type HooksSettings<TContext extends HookContext = HookContext> = {
  *
  * Middlewares apply left to right: each wraps the next, with the leftmost being the outermost layer and the rightmost wrapping the original function.
  *
- * IMPORT_PATH: `"@daiso-tech/core/utilities"`
- * @group Hooks
+ * IMPORT_PATH: `"@daiso-tech/core/hooks"`
  */
 export declare class Hooks<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> implements IInvokableObject<TParameters, TReturn> {
     private readonly invokable;
@@ -78,7 +71,7 @@ export declare class Hooks<TParameters extends unknown[] = unknown[], TReturn =
     /**
      * @example
      * ```ts
-     * import { Hooks, type MiddlewareFn } from "@daiso-tech/core/utilities";
+     * import { Hooks, type MiddlewareFn } from "@daiso-tech/core/hooks";
      *
      * function log<TParameters extends unknown[], TReturn>(): MiddlewareFn<TParameters, TReturn, { funcName: string; }> {
      *   return (args, next, { name: funcName }) => {

package/dist/{utilities/classes/hooks → hooks}/hooks.js

@@ -1,15 +1,14 @@
 /**
- * @module Utilities
+ * @module Hooks
  */
-import { getInvokableName, resolveInvokable, resolveOneOrMore, } from "../../../utilities/functions/_module.js";
+import { getInvokableName, resolveInvokable, resolveOneOrMore, } from "../utilities/_module-exports.js";
 /**
  * The `Hooks` class provides a convenient way to change and inspect arguments and return value of only sync functions.
  * For example `Hooks` class can be used to log function arguments and return values. Note this class is immutable.
  *
  * Middlewares apply left to right: each wraps the next, with the leftmost being the outermost layer and the rightmost wrapping the original function.
  *
- * IMPORT_PATH: `"@daiso-tech/core/utilities"`
- * @group Hooks
+ * IMPORT_PATH: `"@daiso-tech/core/hooks"`
  */
 export class Hooks {
     invokable;
@@ -35,7 +34,7 @@ export class Hooks {
     /**
      * @example
      * ```ts
-     * import { Hooks, type MiddlewareFn } from "@daiso-tech/core/utilities";
+     * import { Hooks, type MiddlewareFn } from "@daiso-tech/core/hooks";
      *
      * function log<TParameters extends unknown[], TReturn>(): MiddlewareFn<TParameters, TReturn, { funcName: string; }> {
      *   return (args, next, { name: funcName }) => {

package/dist/hooks/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../src/hooks/hooks.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GAKnB,MAAM,gCAAgC,CAAC;AAoFxC;;;;;;;GAOG;AACH,MAAM,OAAO,KAAK;IAoFO;IACA;IAGA;IAlFb,MAAM,CAAC,IAAI,CAKf,SAA0C,EAC1C,WAAkE,EAClE,EACI,IAAI,GAAG,gBAAgB,CAAC,SAAS,CAAC,EAClC,OAAO,GAAG,EAAc,GACF;QAE1B,IAAI,IAAI,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;QACvC,KAAK,MAAM,IAAI,IAAI,gBAAgB,CAAC,WAAW,CAAC;aAC3C,GAAG,CAAC,gBAAgB,CAAC;aACrB,OAAO,EAAE,EAAE,CAAC;YACb,MAAM,QAAQ,GAAG,IAAI,CAAC;YACtB,MAAM,IAAI,GAAG,CAAC,GAAG,UAAuB,EAAE,EAAE,CACxC,QAAQ,CAAC,GAAG,UAAU,CAAC,CAAC;YAC5B,IAAI,GAAG,CAAC,GAAG,UAAuB,EAAE,EAAE;gBAClC,OAAO,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE;oBAC1B,IAAI;oBACJ,OAAO;iBACV,CAAC,CAAC;YACP,CAAC,CAAC;QACN,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEgB,IAAI,CAAoC;IAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,YACqB,SAA0C,EAC1C,WAEhB,EACgB,WAAoC,EAAE;QAJtC,cAAS,GAAT,SAAS,CAAiC;QAC1C,gBAAW,GAAX,WAAW,CAE3B;QACgB,aAAQ,GAAR,QAAQ,CAA8B;QAEvD,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClE,CAAC;IAED;;OAEG;IACH,IAAI,CACA,WAAkE;QAElE,OAAO,IAAI,KAAK,CACZ,IAAI,CAAC,SAAS,EACd;YACI,GAAG,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC;YACrC,GAAG,gBAAgB,CAAC,WAAW,CAAC;SACnC,EACD,IAAI,CAAC,QAAQ,CAChB,CAAC;IACN,CAAC;IAED;;OAEG;IACH,QAAQ,CACJ,SAAkB,EAClB,WAAkE;QAElE,IAAI,SAAS,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAClC,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,MAAM;QACF,OAAO,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,GAAG,UAAuB;QAC7B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC;IACpC,CAAC;CACJ"}

package/dist/{utilities/classes/hooks → hooks}/types.d.ts

@@ -1,9 +1,8 @@
 /**
- * @module Utilities
+ * @module Hooks
  */
 /**
  *
- * IMPORT_PATH: `"@daiso-tech/core/utilities"`
- * @group Hooks
+ * IMPORT_PATH: `"@daiso-tech/core/hooks"`
  */
 export type HookContext = Partial<Record<string | symbol, unknown>>;

package/dist/hooks/types.js

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

package/dist/hooks/types.js.map

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

package/dist/lock/contracts/_module-exports.d.ts

@@ -1,7 +1,9 @@
-export * from "../../lock/contracts/lock-adapter.contract.js";
 export * from "../../lock/contracts/database-lock-adapter.contract.js";
-export * from "../../lock/contracts/lock-provider.contract.js";
+export * from "../../lock/contracts/lock-adapter.contract.js";
 export * from "../../lock/contracts/lock-provider-factory.contract.js";
+export * from "../../lock/contracts/lock-provider.contract.js";
+export * from "../../lock/contracts/lock-state.contract.js";
 export * from "../../lock/contracts/lock.contract.js";
 export * from "../../lock/contracts/lock.errors.js";
 export * from "../../lock/contracts/lock.events.js";
+export * from "../../lock/contracts/types.js";

package/dist/lock/contracts/_module-exports.js

@@ -1,8 +1,10 @@
-export * from "../../lock/contracts/lock-adapter.contract.js";
 export * from "../../lock/contracts/database-lock-adapter.contract.js";
-export * from "../../lock/contracts/lock-provider.contract.js";
+export * from "../../lock/contracts/lock-adapter.contract.js";
 export * from "../../lock/contracts/lock-provider-factory.contract.js";
+export * from "../../lock/contracts/lock-provider.contract.js";
+export * from "../../lock/contracts/lock-state.contract.js";
 export * from "../../lock/contracts/lock.contract.js";
 export * from "../../lock/contracts/lock.errors.js";
 export * from "../../lock/contracts/lock.events.js";
+export * from "../../lock/contracts/types.js";
 //# sourceMappingURL=_module-exports.js.map

package/dist/lock/contracts/_module-exports.js.map

@@ -1 +1 @@
-{"version":3,"file":"_module-exports.js","sourceRoot":"","sources":["../../../src/lock/contracts/_module-exports.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,oDAAoD,CAAC;AACnE,cAAc,4CAA4C,CAAC;AAC3D,cAAc,oDAAoD,CAAC;AACnE,cAAc,mCAAmC,CAAC;AAClD,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"_module-exports.js","sourceRoot":"","sources":["../../../src/lock/contracts/_module-exports.ts"],"names":[],"mappings":"AAAA,cAAc,oDAAoD,CAAC;AACnE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,oDAAoD,CAAC;AACnE,cAAc,4CAA4C,CAAC;AAC3D,cAAc,yCAAyC,CAAC;AACxD,cAAc,mCAAmC,CAAC;AAClD,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC"}

package/dist/lock/contracts/database-lock-adapter.contract.d.ts

@@ -1,6 +1,7 @@
 /**
  * @module Lock
  */
+import type { InvokableFn } from "../../utilities/_module-exports.js";
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
@@ -24,6 +25,21 @@ export type ILockData = ILockExpirationData & {
      */
     owner: string;
 };
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
+ * @group Contracts
+ */
+export type IDatabaseLockTransaction = {
+    /**
+     * The `find` returns the lock if it exists otherwise `null` is returned.
+     */
+    find(key: string): Promise<ILockData | null>;
+    /**
+     * The `upsert` inserts a lock if it doesnt exist otherwise it will be updated.
+     */
+    upsert(key: string, lockId: string, expiration: Date | null): Promise<void>;
+};
 /**
  * The `IDatabaseLockAdapter` contract defines a way for managing locks independent of data storage.
  * This contract simplifies the implementation of lock adapters with CRUD-based databases, such as SQL databases and ORMs like TypeOrm and MikroOrm.
@@ -33,23 +49,14 @@ export type ILockData = ILockExpirationData & {
  */
 export type IDatabaseLockAdapter = {
     /**
-     * Inserts a new lock into the database.
-     *
-     * @param key The unique identifier for the lock.
-     * @param owner The identifier of the entity acquiring the lock.
-     * @param expiration The date and time when the lock should expire. Use `null` for a lock that doesn't expire.
-     */
-    insert(key: string, owner: string, expiration: Date | null): Promise<void>;
-    /**
-     * Conditionally renews the lock on `key` if it has already expired, setting a new `owner` and `expiration`.
-     * Note you need to check if the expiration field is not null and greater than or equal to current time.
+     * The `transaction` method runs the `fn` function inside a transaction.
+     * The `fn` function is given a {@link IDatabaseLockTransaction | `IDatabaseLockTransaction`} object.
      *
-     * @param key The unique identifier for the lock.
-     * @param owner The new identifier for the entity acquiring the lock.
-     * @param expiration The new date and time when the lock should expire. Use `null` for a lock that doesn't expire.
-     * @returns Returns number of updated.
+     * Note when implementing this method use the strictest transaction level mode.
      */
-    updateIfExpired(key: string, owner: string, expiration: Date | null): Promise<number>;
+    transaction<TReturn>(fn: InvokableFn<[
+        transaction: IDatabaseLockTransaction
+    ], Promise<TReturn>>): Promise<TReturn>;
     /**
      * Removes a lock from the database regardless of its owner.
      *
@@ -63,7 +70,7 @@ export type IDatabaseLockAdapter = {
      * @param owner The identifier of the expected owner.
      * @returns Returns {@link ILockExpirationData |`ILockExpirationData | null`}. The {@link ILockExpirationData |`ILockExpirationData`} data if successfully removed, otherwise `null` if the lock wasn't found or the owner didn't match.
      */
-    removeIfOwner(key: string, owner: string): Promise<ILockData | null>;
+    removeIfOwner(key: string, lockId: string): Promise<ILockData | null>;
     /**
      * Updates the expiration date of a lock if it is currently held by the specified owner.
      *
@@ -72,7 +79,7 @@ export type IDatabaseLockAdapter = {
      * @param expiration The new date and time when the lock should expire.
      * @returns Returns a number greater than or equal to `1` if the lock's expiration was updated, or `0` if the lock wasn't found or the owner didn't match.
      */
-    updateExpirationIfOwner(key: string, owner: string, expiration: Date): Promise<number>;
+    updateExpiration(key: string, lockId: string, expiration: Date): Promise<number>;
     /**
      * Retrieves the current lock data for a given key.
      *

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

@@ -1,23 +1,15 @@
 /**
  * @module Lock
  */
-import type { TimeSpan } from "../../utilities/_module-exports.js";
+import type { TimeSpan } from "../../time-span/implementations/_module-exports.js";
 /**
- *
  * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
  * @group Contracts
  */
-export declare const LOCK_REFRESH_RESULT: {
-    readonly REFRESHED: "refreshed";
-    readonly UNOWNED_REFRESH: "unonwned_refresh";
-    readonly UNEXPIRABLE_KEY: "unexpireable_key";
+export type ILockAdapterState = {
+    owner: string;
+    expiration: Date | null;
 };
-/**
- *
- * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
- * @group Contracts
- */
-export type LockRefreshResult = (typeof LOCK_REFRESH_RESULT)[keyof typeof LOCK_REFRESH_RESULT];
 /**
  * The `ILockAdapter` contract defines a way for managing locks independent of the underlying technology.
  * This contract is not meant to be used directly, instead you should use {@link ILockProvider | `ILockProvider`} contract.
@@ -27,29 +19,28 @@ export type LockRefreshResult = (typeof LOCK_REFRESH_RESULT)[keyof typeof LOCK_R
  */
 export type ILockAdapter = {
     /**
-     * The `acquire` method acquires a lock only if the lock is not acquired.
+     * The `acquire` method acquires a lock only if expired.
      *
-     * @returns Returns true if lock is not already acquired or false.
+     * @returns Returns `true` if expired otherwise `false` is returned.
      */
-    acquire(key: string, owner: string, ttl: TimeSpan | null): Promise<boolean>;
+    acquire(key: string, lockId: string, ttl: TimeSpan | null): Promise<boolean>;
     /**
      * The `release` method releases a lock if the owner matches.
      *
-     * @returns Returns true if released otherwise false is returned.
+     * @returns Returns `true` if released otherwise `false` is returned.
      */
-    release(key: string, owner: string): Promise<boolean>;
+    release(key: string, lockId: string): Promise<boolean>;
     /**
      * The `forceRelease` method releases a lock regardless of the owner.
      *
-     * @returns Returns true if the lock was released or false if the lock doesnt exists
+     * @returns Returns `true` if the lock exists or `false` if the lock is expired.
      */
     forceRelease(key: string): Promise<boolean>;
     /**
-     * The `refresh` method will upadte `ttl` of lock if it matches the given `key`, given `owner` and is expireable.
-     * @returns
-     * - {@link LOCK_REFRESH_RESULT.UNOWNED_REFRESH | `LOCK_REFRESH_RESULT.UNOWNED_REFRESH`}: The lock doesn't exist or is owned by a different owner.
-     * - {@link LOCK_REFRESH_RESULT.UNEXPIRABLE_KEY | `LOCK_REFRESH_RESULT.UNEXPIRABLE_KEY`}: The lock is owned by the same owner but cannot be refreshed because it's unexpirable.
-     * - {@link LOCK_REFRESH_RESULT.REFRESHED | `LOCK_REFRESH_RESULT.REFRESHED`}: The lock is owned by the same owner and its ttl has been updated.
+     * The `refresh` method will upadte `ttl` of lock if it matches the `owner` and is expireable.
+     *
+     * @returns Returns `false` if the lock is unexpireable, the is expired, does not match the `owner` otherwise `true` is returned.
      */
-    refresh(key: string, owner: string, ttl: TimeSpan): Promise<LockRefreshResult>;
+    refresh(key: string, lockId: string, ttl: TimeSpan): Promise<boolean>;
+    getState(key: string): Promise<ILockAdapterState | null>;
 };

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

@@ -1,14 +1,5 @@
 /**
  * @module Lock
  */
-/**
- *
- * IMPORT_PATH: `"@daiso-tech/core/lock/contracts"`
- * @group Contracts
- */
-export const LOCK_REFRESH_RESULT = {
-    REFRESHED: "refreshed",
-    UNOWNED_REFRESH: "unonwned_refresh",
-    UNEXPIRABLE_KEY: "unexpireable_key",
-};
+export {};
 //# sourceMappingURL=lock-adapter.contract.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"lock-adapter.contract.js","sourceRoot":"","sources":["../../../src/lock/contracts/lock-adapter.contract.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAC/B,SAAS,EAAE,WAAW;IACtB,eAAe,EAAE,kBAAkB;IACnC,eAAe,EAAE,kBAAkB;CAC7B,CAAC"}
+{"version":3,"file":"lock-adapter.contract.js","sourceRoot":"","sources":["../../../src/lock/contracts/lock-adapter.contract.ts"],"names":[],"mappings":"AAAA;;GAEG"}

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

@@ -1,10 +1,10 @@
 /**
  * @module Lock
  */
-import type { OneOrMore, TimeSpan } from "../../utilities/_module-exports.js";
 import type { ILock } from "../../lock/contracts/lock.contract.js";
 import type { IEventListenable } from "../../event-bus/contracts/_module-exports.js";
 import type { LockEventMap } from "../../lock/contracts/lock.events.js";
+import type { ITimeSpan } from "../../time-span/contracts/_module-exports.js";
 /**
  * The `ILockListenable` contract defines a way for listening {@link ILock | `ILock`} operations.
  *
@@ -21,11 +21,11 @@ export type LockProviderCreateSettings = {
     /**
      * You can also provide a `settings.ttl` value using. If not specified it defaults to null, meaning no TTL is applied.
      */
-    ttl?: TimeSpan | null;
+    ttl?: ITimeSpan | null;
     /**
-     * You can provide a custom owner. If not specified a unique owner will be generated by default.
+     * You can provide a custom lock id. If not specified a unique lock id will be generated by default.
      */
-    owner?: OneOrMore<string>;
+    lockId?: string;
 };
 /**
  *
@@ -40,7 +40,7 @@ export type ILockProviderBase = {
      * If it's an `Iterable`, it will be joined into a single string.
      * Think of an `Iterable` as representing a path.
      */
-    create(key: OneOrMore<string>, settings?: LockProviderCreateSettings): ILock;
+    create(key: string, settings?: LockProviderCreateSettings): ILock;
 };
 /**
  * The `ILockProvider` contract defines a way for managing locks independent of the underlying technology.

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,120 +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 not already acquired by different owner.
+     * 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 not already acquired otherwise false is returned.
      */
-    acquire(): LazyPromise<boolean>;
+    acquire(): Task<boolean>;
     /**
-     * The `acquireOrFail` method acquires a lock only if the lock is not already acquired by different owner.
+     * 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 not already acquired by different owner.
+     * 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 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 not already acquired by different owner.
+     * 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 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 was released or false if the lock doesnt exists
-     */
-    forceRelease(): LazyPromise<boolean>;
-    /**
-     * The `isExpired` method returns true if the lock is expired otherwise false is returned.
-     */
-    isExpired(): LazyPromise<boolean>;
-    /**
-     * The `isLocked` method returns true if the lock is unexpirable or unexpired otherwise false is returned.
+     * @returns Returns true if the lock exists or false if the lock doesnt exists.
      */
-    isLocked(): LazyPromise<boolean>;
+    forceRelease(): Task<boolean>;
     /**
      * 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 expireable and owned by the same owner.
-     * Throws an error if a different owner attempts to refresh the lock.
+     * Throws an error if the lock is not owned by same owner.
      * Throws an error if the key is unexpirable.
      *
-     * @throws {UnownedRefreshLockError} {@link UnownedRefreshLockError}
-     * @throws {UnrefreshableKeyLockError} {@link UnrefreshableKeyLockError}
+     * @throws {FailedRefreshLockError} {@link FailedRefreshLockError}
      */
-    refreshOrFail(ttl?: TimeSpan): LazyPromise<void>;
-    /**
-     * The `getRemainingTime` return the reaming time as {@link TimeSpan | `TimeSpan`}.
-     *
-     * @returns Returns null if the key doesnt exist, key has no expiration and key has expired.
-     */
-    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;