@daiso-tech/core 0.40.0 → 0.41.1

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

@@ -0,0 +1,177 @@
+/**
+ * @module SharedLock
+ */
+import { CORE, resolveOneOrMore, callInvokable, } from "../../../../utilities/_module-exports.js";
+import {} from "../../../../utilities/_module-exports.js";
+import { EventBus } from "../../../../event-bus/implementations/derivables/_module-exports.js";
+import { MemoryEventBusAdapter } from "../../../../event-bus/implementations/adapters/_module-exports.js";
+import { v4 } from "uuid";
+import { resolveDatabaseSharedLockAdapter } from "../../../../shared-lock/implementations/derivables/shared-lock-provider/resolve-database-shared-lock-adapter.js";
+import { SharedLockSerdeTransformer } from "../../../../shared-lock/implementations/derivables/shared-lock-provider/shared-lock-serde-transformer.js";
+import { SharedLock } from "../../../../shared-lock/implementations/derivables/shared-lock-provider/shared-lock.js";
+import { Namespace } from "../../../../namespace/namespace.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock"`
+ * @group Derivables
+ */
+export const DEFAULT_SHARED_LOCK_NAMESPACE = new Namespace("@shared-lock");
+/**
+ * `SharedLockProvider` class can be derived from any {@link ISharedLockAdapter | `ISharedLockAdapter`} or {@link IDatabaseSharedLockAdapter | `IDatabaseSharedLockAdapter`}.
+ *
+ * Note the {@link ISharedLock | `ISharedLock`} instances created by the `SharedLockProvider` class are serializable and deserializable,
+ * allowing them to be seamlessly transferred across different servers, processes, and databases.
+ * This can be done directly using {@link ISerderRegister | `ISerderRegister`} or indirectly through components that rely on {@link ISerderRegister | `ISerderRegister`} internally.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/shared-lock"`
+ * @group Derivables
+ */
+export class SharedLockProvider {
+    eventBus;
+    originalAdapter;
+    adapter;
+    namespace;
+    creatLockId;
+    defaultTtl;
+    defaultBlockingInterval;
+    defaultBlockingTime;
+    defaultRefreshTime;
+    serde;
+    serdeTransformerName;
+    /**
+     * @example
+     * ```ts
+     * import { SqliteSharedLockAdapter } from "@daiso-tech/core/shared-lock/adapters";
+     * import { SharedLockProvider } from "@daiso-tech/core/shared-lock";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
+     * import Sqlite from "better-sqlite3";
+     *
+     * const database = new Sqlite("local.db");
+     * const lockAdapter = new SqliteSharedLockAdapter({
+     *   database,
+     * });
+     * // You need initialize the adapter once before using it.
+     * await lockAdapter.init();
+     *
+     * const serde = new Serde(new SuperJsonSerdeAdapter())
+     * const lockProvider = new SharedLockProvider({
+     *   serde,
+     *   adapter: lockAdapter,
+     * });
+     * ```
+     */
+    constructor(settings) {
+        const { defaultTtl = TimeSpan.fromMinutes(5), defaultBlockingInterval = TimeSpan.fromSeconds(1), defaultBlockingTime = TimeSpan.fromMinutes(1), defaultRefreshTime = TimeSpan.fromMinutes(5), createLockId = () => v4(), serde, namespace = DEFAULT_SHARED_LOCK_NAMESPACE, adapter, eventBus = new EventBus({
+            adapter: new MemoryEventBusAdapter(),
+        }), serdeTransformerName = "", } = settings;
+        this.serde = serde;
+        this.defaultBlockingInterval = TimeSpan.fromTimeSpan(defaultBlockingInterval);
+        this.defaultBlockingTime = TimeSpan.fromTimeSpan(defaultBlockingTime);
+        this.defaultRefreshTime = TimeSpan.fromTimeSpan(defaultRefreshTime);
+        this.creatLockId = createLockId;
+        this.namespace = namespace;
+        this.defaultTtl =
+            defaultTtl === null ? null : TimeSpan.fromTimeSpan(defaultTtl);
+        this.eventBus = eventBus;
+        this.serdeTransformerName = serdeTransformerName;
+        this.originalAdapter = adapter;
+        this.adapter = resolveDatabaseSharedLockAdapter(adapter);
+        this.registerToSerde();
+    }
+    registerToSerde() {
+        const transformer = new SharedLockSerdeTransformer({
+            originalAdapter: this.originalAdapter,
+            adapter: this.adapter,
+            defaultBlockingInterval: this.defaultBlockingInterval,
+            defaultBlockingTime: this.defaultBlockingTime,
+            defaultRefreshTime: this.defaultRefreshTime,
+            eventBus: this.eventBus,
+            namespace: this.namespace,
+            serdeTransformerName: this.serdeTransformerName,
+        });
+        for (const serde of resolveOneOrMore(this.serde)) {
+            serde.registerCustom(transformer, CORE);
+        }
+    }
+    /**
+     * You can listen to the following {@link SharedLockEventMap | `SharedLockEventMap`} of all {@link ISharedLock | `ISharedLock`} instances created by the {@link ISharedLockProvider | `ISharedLockProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    addListener(eventName, listener) {
+        return this.eventBus.addListener(eventName, listener);
+    }
+    /**
+     * You can listen to the following {@link SharedLockEventMap | `SharedLockEventMap`} of all {@link ISharedLock | `ISharedLock`} instances created by the {@link ISharedLockProvider | `ISharedLockProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    removeListener(eventName, listener) {
+        return this.eventBus.removeListener(eventName, listener);
+    }
+    /**
+     * You can listen to the following {@link SharedLockEventMap | `SharedLockEventMap`} of all {@link ISharedLock | `ISharedLock`} instances created by the {@link ISharedLockProvider | `ISharedLockProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    listenOnce(eventName, listener) {
+        return this.eventBus.listenOnce(eventName, listener);
+    }
+    /**
+     * You can listen to the following {@link SharedLockEventMap | `SharedLockEventMap`} of all {@link ISharedLock | `ISharedLock`} instances created by the {@link ISharedLockProvider | `ISharedLockProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    asPromise(eventName) {
+        return this.eventBus.asPromise(eventName);
+    }
+    /**
+     * You can listen to the following {@link SharedLockEventMap | `SharedLockEventMap`} of all {@link ISharedLock | `ISharedLock`} instances created by the {@link ISharedLockProvider | `ISharedLockProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    subscribeOnce(eventName, listener) {
+        return this.eventBus.subscribeOnce(eventName, listener);
+    }
+    /**
+     * You can listen to the following {@link SharedLockEventMap | `SharedLockEventMap`} of all {@link ISharedLock | `ISharedLock`} instances created by the {@link ISharedLockProvider | `ISharedLockProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    subscribe(eventName, listener) {
+        return this.eventBus.subscribe(eventName, listener);
+    }
+    /**
+     * @example
+     * ```ts
+     * import { SharedLockProvider } from "@daiso-tech/core/shared-lock";
+     * import { MemorySharedLockAdapter } from "@daiso-tech/core/shared-lock/adapters";
+     * import { Namespace } from "@daiso-tech/core/namespace";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
+     *
+     * const lockProvider = new SharedLockProvider({
+     *   adapter: new MemorySharedLockAdapter(),
+     *   namespace: new Namespace("shared_lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
+     * });
+     *
+     * const lock = lockProvider.create("a");
+     * ```
+     */
+    create(key, settings) {
+        const { ttl = this.defaultTtl, lockId = callInvokable(this.creatLockId), limit, } = settings;
+        const keyObj = this.namespace.create(key);
+        return new SharedLock({
+            limit,
+            namespace: this.namespace,
+            adapter: this.adapter,
+            originalAdapter: this.originalAdapter,
+            eventDispatcher: this.eventBus,
+            key: keyObj,
+            lockId,
+            ttl: ttl === null ? null : TimeSpan.fromTimeSpan(ttl),
+            serdeTransformerName: this.serdeTransformerName,
+            defaultBlockingInterval: this.defaultBlockingInterval,
+            defaultBlockingTime: this.defaultBlockingTime,
+            defaultRefreshTime: this.defaultRefreshTime,
+        });
+    }
+}
+//# sourceMappingURL=shared-lock-provider.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared-lock-provider.js","sourceRoot":"","sources":["../../../../../src/shared-lock/implementations/derivables/shared-lock-provider/shared-lock-provider.ts"],"names":[],"mappings":"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"}

package/dist/shared-lock/implementations/derivables/shared-lock-provider/shared-lock-serde-transformer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @module SharedLock
+ */
+import type { ISerdeTransformer } from "../../../../serde/contracts/_module-exports.js";
+import { SharedLock, type ISerializedSharedLock } from "../../../../shared-lock/implementations/derivables/shared-lock-provider/shared-lock.js";
+import { type OneOrMore } from "../../../../utilities/_module-exports.js";
+import type { ISharedLockAdapter, SharedLockAdapterVariants, SharedLockEventMap } from "../../../../shared-lock/contracts/_module-exports.js";
+import type { IEventBus } from "../../../../event-bus/contracts/_module-exports.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module-exports.js";
+import type { Namespace } from "../../../../namespace/_module-exports.js";
+/**
+ * @internal
+ */
+export type SharedLockSerdeTransformerSettings = {
+    adapter: ISharedLockAdapter;
+    originalAdapter: SharedLockAdapterVariants;
+    namespace: Namespace;
+    defaultBlockingInterval: TimeSpan;
+    defaultBlockingTime: TimeSpan;
+    defaultRefreshTime: TimeSpan;
+    eventBus: IEventBus<SharedLockEventMap>;
+    serdeTransformerName: string;
+};
+/**
+ * @internal
+ */
+export declare class SharedLockSerdeTransformer implements ISerdeTransformer<SharedLock, ISerializedSharedLock> {
+    private readonly adapter;
+    private readonly originalAdapter;
+    private readonly namespace;
+    private readonly defaultBlockingInterval;
+    private readonly defaultBlockingTime;
+    private readonly defaultRefreshTime;
+    private readonly eventBus;
+    private readonly serdeTransformerName;
+    constructor(settings: SharedLockSerdeTransformerSettings);
+    get name(): OneOrMore<string>;
+    isApplicable(value: unknown): value is SharedLock;
+    deserialize(serializedValue: ISerializedSharedLock): SharedLock;
+    serialize(deserializedValue: SharedLock): ISerializedSharedLock;
+}

package/dist/shared-lock/implementations/derivables/shared-lock-provider/shared-lock-serde-transformer.js

@@ -0,0 +1,77 @@
+/**
+ * @module SharedLock
+ */
+import { SharedLock, } from "../../../../shared-lock/implementations/derivables/shared-lock-provider/shared-lock.js";
+import {} from "../../../../utilities/_module-exports.js";
+import { getConstructorName } from "../../../../utilities/_module-exports.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module-exports.js";
+/**
+ * @internal
+ */
+export class SharedLockSerdeTransformer {
+    adapter;
+    originalAdapter;
+    namespace;
+    defaultBlockingInterval;
+    defaultBlockingTime;
+    defaultRefreshTime;
+    eventBus;
+    serdeTransformerName;
+    constructor(settings) {
+        const { adapter, originalAdapter, namespace, defaultBlockingInterval, defaultBlockingTime, defaultRefreshTime, eventBus, serdeTransformerName, } = settings;
+        this.serdeTransformerName = serdeTransformerName;
+        this.adapter = adapter;
+        this.originalAdapter = originalAdapter;
+        this.namespace = namespace;
+        this.defaultBlockingInterval = defaultBlockingInterval;
+        this.defaultBlockingTime = defaultBlockingTime;
+        this.defaultRefreshTime = defaultRefreshTime;
+        this.eventBus = eventBus;
+    }
+    get name() {
+        return [
+            "shared-lock",
+            this.serdeTransformerName,
+            getConstructorName(this.originalAdapter),
+            this.namespace.toString(),
+        ].filter((str) => str !== "");
+    }
+    isApplicable(value) {
+        const isSharedLock = value instanceof SharedLock &&
+            getConstructorName(value) === SharedLock.name;
+        if (!isSharedLock) {
+            return false;
+        }
+        const isSerdTransformerNameMathcing = value._internal_getSerdeTransformerName() ===
+            this.serdeTransformerName;
+        const isNamespaceMatching = this.namespace.toString() ===
+            value._internal_getNamespace().toString();
+        const isAdapterMatching = getConstructorName(this.originalAdapter) ===
+            getConstructorName(value._internal_getAdapter());
+        return (isSerdTransformerNameMathcing &&
+            isNamespaceMatching &&
+            isAdapterMatching);
+    }
+    deserialize(serializedValue) {
+        const { key, lockId, limit, ttlInMs } = serializedValue;
+        const keyObj = this.namespace.create(key);
+        return new SharedLock({
+            lockId,
+            adapter: this.adapter,
+            originalAdapter: this.originalAdapter,
+            eventDispatcher: this.eventBus,
+            key: keyObj,
+            limit,
+            serdeTransformerName: this.serdeTransformerName,
+            ttl: ttlInMs === null ? null : TimeSpan.fromMilliseconds(ttlInMs),
+            defaultBlockingInterval: this.defaultBlockingInterval,
+            defaultBlockingTime: this.defaultBlockingTime,
+            defaultRefreshTime: this.defaultRefreshTime,
+            namespace: this.namespace,
+        });
+    }
+    serialize(deserializedValue) {
+        return SharedLock._internal_serialize(deserializedValue);
+    }
+}
+//# sourceMappingURL=shared-lock-serde-transformer.js.map

package/dist/shared-lock/implementations/derivables/shared-lock-provider/shared-lock-serde-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-lock-serde-transformer.js","sourceRoot":"","sources":["../../../../../src/shared-lock/implementations/derivables/shared-lock-provider/shared-lock-serde-transformer.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,95 @@
+/**
+ * @module SharedLock
+ */
+import { Task } from "../../../../task/_module-exports.js";
+import type { IEventDispatcher } from "../../../../event-bus/contracts/event-bus.contract.js";
+import type { Key, Namespace } from "../../../../namespace/_module-exports.js";
+import { FailedAcquireWriterLockError, LimitReachedReaderSemaphoreError, type IDatabaseSharedLockAdapter, type ISharedLock, type ISharedLockAdapter, type ISharedLockState, type SharedLockAquireBlockingSettings, type SharedLockEventMap } from "../../../../shared-lock/contracts/_module-exports.js";
+import type { ITimeSpan } from "../../../../time-span/contracts/_module-exports.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module-exports.js";
+import { type AsyncLazy, type Result } from "../../../../utilities/_module-exports.js";
+/**
+ * @internal
+ */
+export type ISerializedSharedLock = {
+    version: "1";
+    key: string;
+    lockId: string;
+    limit: number;
+    ttlInMs: number | null;
+};
+/**
+ * @internal
+ */
+export type SharedLockSettings = {
+    serdeTransformerName: string;
+    namespace: Namespace;
+    adapter: ISharedLockAdapter;
+    originalAdapter: IDatabaseSharedLockAdapter | ISharedLockAdapter;
+    eventDispatcher: IEventDispatcher<SharedLockEventMap>;
+    limit: number;
+    key: Key;
+    lockId: string;
+    ttl: TimeSpan | null;
+    defaultBlockingInterval: TimeSpan;
+    defaultBlockingTime: TimeSpan;
+    defaultRefreshTime: TimeSpan;
+};
+/**
+ * @internal
+ */
+export declare class SharedLock implements ISharedLock {
+    /**
+     * @internal
+     */
+    static _internal_serialize(deserializedValue: SharedLock): ISerializedSharedLock;
+    private readonly namespace;
+    private readonly adapter;
+    private readonly originalAdapter;
+    private readonly eventDispatcher;
+    private readonly _key;
+    private readonly lockId;
+    private _ttl;
+    private readonly defaultBlockingInterval;
+    private readonly defaultBlockingTime;
+    private readonly defaultRefreshTime;
+    private readonly serdeTransformerName;
+    private readonly limit;
+    constructor(settings: SharedLockSettings);
+    _internal_getNamespace(): Namespace;
+    _internal_getSerdeTransformerName(): string;
+    _internal_getAdapter(): IDatabaseSharedLockAdapter | ISharedLockAdapter;
+    runReader<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<Result<TValue, LimitReachedReaderSemaphoreError>>;
+    runReaderOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<TValue>;
+    runReaderBlocking<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SharedLockAquireBlockingSettings): Task<Result<TValue, LimitReachedReaderSemaphoreError>>;
+    runReaderBlockingOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SharedLockAquireBlockingSettings): Task<TValue>;
+    private handleUnexpectedError;
+    private handleDispatch;
+    acquireReader(): Task<boolean>;
+    acquireReaderOrFail(): Task<void>;
+    acquireReaderBlocking(settings?: SharedLockAquireBlockingSettings): Task<boolean>;
+    acquireReaderBlockingOrFail(settings?: SharedLockAquireBlockingSettings): Task<void>;
+    releaseReader(): Task<boolean>;
+    releaseReaderOrFail(): Task<void>;
+    forceReleaseAllReaders(): Task<boolean>;
+    refreshReader(ttl?: ITimeSpan): Task<boolean>;
+    refreshReaderOrFail(ttl?: ITimeSpan): Task<void>;
+    runWriter<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<Result<TValue, FailedAcquireWriterLockError>>;
+    runWriterOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<TValue>;
+    runWriterBlocking<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SharedLockAquireBlockingSettings): Task<Result<TValue, FailedAcquireWriterLockError>>;
+    runWriterBlockingOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SharedLockAquireBlockingSettings): Task<TValue>;
+    acquireWriter(): Task<boolean>;
+    acquireWriterOrFail(): Task<void>;
+    acquireWriterBlocking(settings?: SharedLockAquireBlockingSettings): Task<boolean>;
+    acquireWriterBlockingOrFail(settings?: SharedLockAquireBlockingSettings): Task<void>;
+    releaseWriter(): Task<boolean>;
+    releaseWriterOrFail(): Task<void>;
+    forceReleaseWriter(): Task<boolean>;
+    refreshWriter(ttl?: ITimeSpan): Task<boolean>;
+    refreshWriterOrFail(ttl?: ITimeSpan): Task<void>;
+    get key(): string;
+    get id(): string;
+    get ttl(): TimeSpan | null;
+    forceRelease(): Task<boolean>;
+    getState(): Task<ISharedLockState>;
+}