@daiso-tech/core/dist/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.js

The library offers flexible, framework-agnostic solutions for modern web applications, built on adaptable components that integrate seamlessly with popular frameworks like Next Js.

import { DefaultAdapterNotDefinedError, Namespace, resolveOneOrMore, UnregisteredAdapterError, } from "../../../../utilities/_module-exports.js";
import { LockProvider, } from "../../../../lock/implementations/derivables/lock-provider/_module.js";
/**
 * The `LockProviderFactory` class is immutable.
 *
 * IMPORT_PATH: `"@daiso-tech/core/lock"`
 * @group Derivables
 */
export class LockProviderFactory {
    settings;
    /**
     * @example
     * ```ts
     * import { LockProviderFactory } from "@daiso-tech/core/lock";
     * import type { IDatabaseLockAdapter } from "@daiso-tech/core/lock/contracts";
     * import { MemoryLockAdapter, RedisLockAdapter, SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
     * import { Serde } from "@daiso-tech/core/serde";
     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
     * import Redis from "ioredis"
     *
     * const serde = new Serde(new SuperJsonSerdeAdapter());
     * const lockProviderFactory = new LockProviderFactory({
     *   serde,
     *   adapters: {
     *     memory: new MemoryLockAdapter(),
     *     redis: new RedisLockAdapter(new Redis("YOUR_REDIS_CONNECTION")),
     *   },
     *   defaultAdapter: "memory",
     * });
     * ```
     */
    constructor(settings) {
        this.settings = settings;
    }
    setNamespace(namespace) {
        return new LockProviderFactory({
            ...this.settings,
            namespace,
        });
    }
    setCreateOwnerId(createId) {
        return new LockProviderFactory({
            ...this.settings,
            createOwnerId: createId,
        });
    }
    setEventBus(eventBus) {
        return new LockProviderFactory({
            ...this.settings,
            eventBus,
        });
    }
    setDefaultTtl(ttl) {
        return new LockProviderFactory({
            ...this.settings,
            defaultTtl: ttl,
        });
    }
    setDefaultBlockingInterval(interval) {
        return new LockProviderFactory({
            ...this.settings,
            defaultBlockingInterval: interval,
        });
    }
    setDefaultBlockingTime(time) {
        return new LockProviderFactory({
            ...this.settings,
            defaultBlockingTime: time,
        });
    }
    setDefaultRefreshTime(time) {
        return new LockProviderFactory({
            ...this.settings,
            defaultRefreshTime: time,
        });
    }
    setLazyPromiseFactory(factory) {
        return new LockProviderFactory({
            ...this.settings,
            lazyPromiseFactory: factory,
        });
    }
    /**
     * @example
     * ```ts
     * import { LockProviderFactory } from "@daiso-tech/core/lock";
     * import type { IDatabaseLockAdapter } from "@daiso-tech/core/lock/contracts";
     * import { MemoryLockAdapter, RedisLockAdapter, SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
     * import { Serde } from "@daiso-tech/core/serde";
     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
     * import { TimeSpan } from "@daiso-tech/core/utilities";
     * import Redis from "ioredis";
     *
     * const serde = new Serde(new SuperJsonSerdeAdapter());
     * const lockProviderFactory = new LockProviderFactory({
     *   serde,
     *   adapters: {
     *     memory: new MemoryLockAdapter(),
     *     redis: new RedisLockAdapter(new Redis("YOUR_REDIS_CONNECTION")),
     *   },
     *   defaultAdapter: "memory",
     * });
     *
     * // Will acquire key using the default adapter which is MemoryLockAdapter
     * await lockProviderFactory
     *   .use()
     *   .create("a")
     *   .acquire();
     *
     * // Will acquire key using the redis adapter which is RedisLockAdapter
     * await lockProviderFactory
     *   .use("redis")
     *   .create("a")
     *   .acquire();
     * ```
     */
    use(adapterName = this.settings.defaultAdapter) {
        if (adapterName === undefined) {
            throw new DefaultAdapterNotDefinedError(LockProviderFactory.name);
        }
        const adapter = this.settings.adapters[adapterName];
        if (adapter === undefined) {
            throw new UnregisteredAdapterError(adapterName);
        }
        const { namespace = new Namespace(["@", "lock"]) } = this.settings;
        return new LockProvider({
            ...this.settings,
            adapter,
            namespace: new Namespace([
                ...resolveOneOrMore(namespace._getInternal().original),
                adapterName,
            ]),
            serdeTransformerName: adapterName,
        });
    }
}
//# sourceMappingURL=lock-provider-factory.js.map