@daiso-tech/core 0.22.2 → 0.24.0

package/dist/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.d.ts

@@ -0,0 +1,172 @@
+/**
+ * @module Lock
+ */
+import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module-exports.js";
+import type { IGroupableEventBus } from "../../../../event-bus/contracts/_module-exports.js";
+import type { IDatabaseLockAdapter, ILockAdapter } from "../../../../lock/contracts/_module-exports.js";
+import type { ILockProviderFactory } from "../../../../lock/contracts/lock-provider-factory.contract.js";
+import type { IGroupableLockProvider } from "../../../../lock/contracts/lock-provider.contract.js";
+import type { IFlexibleSerde } from "../../../../serde/contracts/_module-exports.js";
+import { type OneOrMore } from "../../../../utilities/_module-exports.js";
+import type { TimeSpan } from "../../../../utilities/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/derivables"```
+ * @group Derivables
+ */
+export type LockAdapters<TAdapters extends string> = Partial<Record<TAdapters, ILockAdapter | IDatabaseLockAdapter>>;
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/derivables"```
+ * @group Derivables
+ */
+export type LockProviderFactorySettings<TAdapters extends string> = {
+    /**
+     * You can pass one or more <i>{@link IFlexibleSerde}</i> that will be used to register all <i>{@link ILock}</i> related errors and events.
+     * @default {true}
+     */
+    serde: OneOrMore<IFlexibleSerde>;
+    /**
+     * If set to true, all <i>{@link ILock}</i> related errors will be registered with the specified <i>IFlexibleSerde</i> during constructor initialization.
+     * This ensures that all <i>{@link ILock}</i> related errors will be serialized correctly.
+     * @default {true}
+     */
+    shouldRegisterErrors?: boolean;
+    /**
+     * If set to true, all <i>{@link ILock}</i> related events will be registered with the specified <i>IFlexibleSerde</i> during constructor initialization.
+     * This ensures that all <i>{@link ILock}</i> related events will be serialized correctly.
+     * @default {true}
+     */
+    shouldRegisterEvents?: boolean;
+    adapters: LockAdapters<TAdapters>;
+    defaultAdapter?: NoInfer<TAdapters>;
+    /**
+     * You can pass your owner id generator function.
+     */
+    createOwnerId?: () => string;
+    /**
+     * In order to listen to events of <i>{@link LockProvider}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     */
+    eventBus?: IGroupableEventBus<any>;
+    /**
+     * You can decide the default ttl value for <i>{@link ILock}</i> expiration. If null is passed then no ttl will be used by default.
+     * @default TimeSpan.fromMinutes(5);
+     */
+    defaultTtl?: TimeSpan | null;
+    /**
+     * The default refreshtime used in the <i>{@link ILock}</i> <i>extend</i> method.
+     * @default TimeSpan.fromMinutes(5);`
+     */
+    defaultExtendTime?: TimeSpan;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    timeout?: TimeSpan | null;
+};
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/derivables"```
+ * @group Derivables
+ */
+export declare class LockProviderFactory<TAdapters extends string> implements ILockProviderFactory<TAdapters> {
+    private readonly serde;
+    private readonly shouldRegisterErrors?;
+    private readonly shouldRegisterEvents?;
+    private readonly defaultAdapter?;
+    private readonly lockProviderRecord;
+    private readonly createOwnerId?;
+    private readonly eventBus?;
+    private readonly defaultTtl?;
+    private readonly defaultExtendTime?;
+    private readonly retryAttempts?;
+    private readonly backoffPolicy?;
+    private readonly retryPolicy?;
+    private readonly timeout?;
+    /**
+     * @example
+     * ```ts
+     * import { LockProviderFactory } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter, RedisLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * 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 Redis from "ioredis"
+     *
+     * const eventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
+     * const lockProviderFactory = new LockProviderFactory({
+     *   serde,
+     *   adapters: {
+     *     memory: new MemoryLockAdapter({
+     *       rootGroup: "@global"
+     *     }),
+     *     redis: new RedisLockAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       rootGroup: "@global"
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     *   eventBus,
+     * });
+     * ```
+     */
+    constructor(settings: LockProviderFactorySettings<TAdapters>);
+    private init;
+    /**
+     * @example
+     * ```ts
+     * import { LockProviderFactory } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter, RedisLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * 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 Redis from "ioredis"
+     *
+     * const eventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
+     * const lockProviderFactory = new LockProviderFactory({
+     *   serde,
+     *   adapters: {
+     *     memory: new MemoryLockAdapter({
+     *       rootGroup: "@global"
+     *     }),
+     *     redis: new RedisLockAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       rootGroup: "@global"
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     *   eventBus,
+     * });
+     *
+     * // Will create and acquire the lock with default adapter which is MemoryEventBusAdapter
+     * await lockProviderFactory.use().create("a").acquire();
+     *
+     * // Will create and acquire the lock with redis adapter which is RedisLockAdapter
+     * await lockProviderFactory.use("redis").create("a").acquire();
+     * ```
+     */
+    use(adapterName?: TAdapters | undefined): IGroupableLockProvider;
+}

package/dist/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.js

@@ -0,0 +1,150 @@
+/**
+ * @module Lock
+ */
+import { registerLockErrorsToSerde, registerLockEventsToSerde, } from "../../../../lock/contracts/_module-exports.js";
+import { DefaultAdapterNotDefinedError, UnregisteredAdapterError, } from "../../../../utilities/_module-exports.js";
+import { LockProvider } from "../../../../lock/implementations/derivables/lock-provider/_module.js";
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/derivables"```
+ * @group Derivables
+ */
+export class LockProviderFactory {
+    serde;
+    shouldRegisterErrors;
+    shouldRegisterEvents;
+    defaultAdapter;
+    lockProviderRecord;
+    createOwnerId;
+    eventBus;
+    defaultTtl;
+    defaultExtendTime;
+    retryAttempts;
+    backoffPolicy;
+    retryPolicy;
+    timeout;
+    /**
+     * @example
+     * ```ts
+     * import { LockProviderFactory } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter, RedisLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * 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 Redis from "ioredis"
+     *
+     * const eventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
+     * const lockProviderFactory = new LockProviderFactory({
+     *   serde,
+     *   adapters: {
+     *     memory: new MemoryLockAdapter({
+     *       rootGroup: "@global"
+     *     }),
+     *     redis: new RedisLockAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       rootGroup: "@global"
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     *   eventBus,
+     * });
+     * ```
+     */
+    constructor(settings) {
+        const { serde, shouldRegisterErrors = true, shouldRegisterEvents = true, adapters, defaultAdapter, createOwnerId, eventBus, defaultTtl, defaultExtendTime, retryAttempts, backoffPolicy, retryPolicy, timeout, } = settings;
+        this.serde = serde;
+        this.shouldRegisterErrors = shouldRegisterErrors;
+        this.shouldRegisterEvents = shouldRegisterEvents;
+        this.defaultAdapter = defaultAdapter;
+        this.createOwnerId = createOwnerId;
+        this.eventBus = eventBus;
+        this.defaultTtl = defaultTtl;
+        this.defaultExtendTime = defaultExtendTime;
+        this.retryAttempts = retryAttempts;
+        this.backoffPolicy = backoffPolicy;
+        this.retryPolicy = retryPolicy;
+        this.timeout = timeout;
+        this.lockProviderRecord = this.init(adapters);
+    }
+    init(adapters) {
+        if (this.shouldRegisterErrors) {
+            registerLockErrorsToSerde(this.serde);
+        }
+        if (this.shouldRegisterEvents) {
+            registerLockEventsToSerde(this.serde);
+        }
+        const cacheRecord = {};
+        for (const key in adapters) {
+            const { [key]: adapter } = adapters;
+            if (adapter === undefined) {
+                continue;
+            }
+            const lockProvider = new LockProvider({
+                adapter,
+                serde: this.serde,
+                eventBus: this.eventBus,
+                defaultTtl: this.defaultTtl,
+                retryAttempts: this.retryAttempts,
+                backoffPolicy: this.backoffPolicy,
+                retryPolicy: this.retryPolicy,
+                timeout: this.timeout,
+                defaultRefreshTime: this.defaultExtendTime,
+                createOwnerId: this.createOwnerId,
+            });
+            cacheRecord[key] = lockProvider;
+        }
+        return cacheRecord;
+    }
+    /**
+     * @example
+     * ```ts
+     * import { LockProviderFactory } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter, RedisLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * 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 Redis from "ioredis"
+     *
+     * const eventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
+     * const lockProviderFactory = new LockProviderFactory({
+     *   serde,
+     *   adapters: {
+     *     memory: new MemoryLockAdapter({
+     *       rootGroup: "@global"
+     *     }),
+     *     redis: new RedisLockAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       rootGroup: "@global"
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     *   eventBus,
+     * });
+     *
+     * // Will create and acquire the lock with default adapter which is MemoryEventBusAdapter
+     * await lockProviderFactory.use().create("a").acquire();
+     *
+     * // Will create and acquire the lock with redis adapter which is RedisLockAdapter
+     * await lockProviderFactory.use("redis").create("a").acquire();
+     * ```
+     */
+    use(adapterName = this.defaultAdapter) {
+        if (adapterName === undefined) {
+            throw new DefaultAdapterNotDefinedError(LockProviderFactory.name);
+        }
+        const lockProvider = this.lockProviderRecord[adapterName];
+        if (lockProvider === undefined) {
+            throw new UnregisteredAdapterError(adapterName);
+        }
+        return lockProvider;
+    }
+}
+//# sourceMappingURL=lock-provider-factory.js.map

package/dist/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-provider-factory.js","sourceRoot":"","sources":["../../../../../src/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,EACH,yBAAyB,EACzB,yBAAyB,GAC5B,MAAM,qCAAqC,CAAC;AAI7C,OAAO,EACH,6BAA6B,EAC7B,wBAAwB,GAE3B,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,YAAY,EAAE,MAAM,4DAA4D,CAAC;AA+F1F;;;;GAIG;AACH,MAAM,OAAO,mBAAmB;IAGX,KAAK,CAA4B;IACjC,oBAAoB,CAAW;IAC/B,oBAAoB,CAAW;IAC/B,cAAc,CAAsB;IACpC,kBAAkB,CAAgC;IAClD,aAAa,CAAgB;IAC7B,QAAQ,CAA2B;IACnC,UAAU,CAAmB;IAC7B,iBAAiB,CAAY;IAC7B,aAAa,CAAiB;IAC9B,aAAa,CAAwB;IACrC,WAAW,CAAsB;IACjC,OAAO,CAAmB;IAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,YAAY,QAAgD;QACxD,MAAM,EACF,KAAK,EACL,oBAAoB,GAAG,IAAI,EAC3B,oBAAoB,GAAG,IAAI,EAC3B,QAAQ,EACR,cAAc,EACd,aAAa,EACb,QAAQ,EACR,UAAU,EACV,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,WAAW,EACX,OAAO,GACV,GAAG,QAAQ,CAAC;QAEb,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;QACjD,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;QACjD,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QAC3C,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClD,CAAC;IAEO,IAAI,CACR,QAAiC;QAEjC,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;QACD,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;QACD,MAAM,WAAW,GAAkC,EAAE,CAAC;QACtD,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;YACzB,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,QAAQ,CAAC;YACpC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBACxB,SAAS;YACb,CAAC;YACD,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC;gBAClC,OAAO;gBACP,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,UAAU,EAAE,IAAI,CAAC,UAAU;gBAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,kBAAkB,EAAE,IAAI,CAAC,iBAAiB;gBAC1C,aAAa,EAAE,IAAI,CAAC,aAAa;aACpC,CAAC,CAAC;YACH,WAAW,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC;QACpC,CAAC;QACD,OAAO,WAAW,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,GAAG,CACC,cAAqC,IAAI,CAAC,cAAc;QAExD,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QACtE,CAAC;QACD,MAAM,YAAY,GAAG,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;QAC1D,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAC7B,MAAM,IAAI,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACpD,CAAC;QACD,OAAO,YAAY,CAAC;IACxB,CAAC;CACJ"}

package/dist/lock/implementations/test-utilities/_module-exports.d.ts

@@ -0,0 +1,3 @@
+export * from "../../../lock/implementations/test-utilities/database-lock-adapter.test-suite.js";
+export * from "../../../lock/implementations/test-utilities/lock-adapter.test-suite.js";
+export * from "../../../lock/implementations/test-utilities/lock-provider.test-suite.js";

package/dist/lock/implementations/test-utilities/_module-exports.js

@@ -0,0 +1,4 @@
+export * from "../../../lock/implementations/test-utilities/database-lock-adapter.test-suite.js";
+export * from "../../../lock/implementations/test-utilities/lock-adapter.test-suite.js";
+export * from "../../../lock/implementations/test-utilities/lock-provider.test-suite.js";
+//# sourceMappingURL=_module-exports.js.map

package/dist/lock/implementations/test-utilities/_module-exports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module-exports.js","sourceRoot":"","sources":["../../../../src/lock/implementations/test-utilities/_module-exports.ts"],"names":[],"mappings":"AAAA,cAAc,2EAA2E,CAAC;AAC1F,cAAc,kEAAkE,CAAC;AACjF,cAAc,mEAAmE,CAAC"}

package/dist/lock/implementations/test-utilities/database-lock-adapter.test-suite.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module Lock
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type IDatabaseLockAdapter } from "../../../lock/contracts/_module-exports.js";
+import { type Promisable } from "../../../utilities/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/test-utilities"```
+ * @group Utilities
+ */
+export type DatabaseLockAdapterTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IDatabaseLockAdapter>;
+};
+/**
+ * The <i>databaseLockAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IDatabaseLockAdapter}</i> with <i>vitest</i>.
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/test-utilities"```
+ * @group Utilities
+ * @example
+ * ```ts
+ * import { afterEach, beforeEach, describe, expect, test } from "vitest";
+ * import { databaseLockAdapterTestSuite } from "@@daiso-tech/core/lock/implementations/test-utilities";
+ * import { LibsqlLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+ * import { type Client, createClient } from "@libsql/client";
+ *
+ * describe("class: LibsqlLockAdapter", () => {
+ *     let client: Client;
+ *     beforeEach(() => {
+ *         client = createClient({
+ *             url: ":memory:",
+ *         });
+ *     });
+ *     afterEach(() => {
+ *         client.close();
+ *     });
+ *     databaseLockAdapterTestSuite({
+ *         createAdapter: async () => {
+ *             const lockAdapter = new LibsqlLockAdapter({
+ *                database: client,
+ *                 tableName: "custom_table",
+ *                 shouldRemoveExpiredKeys: false,
+ *                 rootGroup: "@a",
+ *             });
+ *             await lockAdapter.init();
+ *             return lockAdapter;
+ *         },
+ *         test,
+ *         beforeEach,
+ *         expect,
+ *         describe,
+ *     });
+ * });
+ *
+ * ```
+ */
+export declare function databaseLockAdapterTestSuite(settings: DatabaseLockAdapterTestSuiteSettings): void;