@daiso-tech/core
Version:
The library offers flexible, framework-agnostic solutions for modern web applications, built on adaptable components that integrate seamlessly with popular frameworks like Next Js.
198 lines (197 loc) • 8.64 kB
TypeScript
/**
* @module Lock
*/
import { TimeSpan, type Factory, type AsyncLazy } from "../../../../utilities/_module-exports.js";
import { KeyPrefixer, type OneOrMore } from "../../../../utilities/_module-exports.js";
import type { IDatabaseLockAdapter, LockEventMap } from "../../../../lock/contracts/_module-exports.js";
import { type ILock, type LockProviderCreateSettings, type ILockProvider, type ILockAdapter } from "../../../../lock/contracts/_module-exports.js";
import { LazyPromise } from "../../../../async/_module-exports.js";
import type { EventListener, IEventBus, Unsubscribe } from "../../../../event-bus/contracts/_module-exports.js";
import type { IFlexibleSerde } from "../../../../serde/contracts/_module-exports.js";
/**
*
* IMPORT_PATH: `"@daiso-tech/core/lock"`
* @group Derivables
*/
export type LockProviderSettingsBase = {
keyPrefixer: KeyPrefixer;
/**
* You can pass a {@link Factory | `Factory`} of {@link LazyPromise| `LazyPromise`} to configure default settings for all {@link LazyPromise| `LazyPromise`} instances used in the `LockProvider` class.
* @default
* ```ts
* import { LazyPromise } from "@daiso-tech/core/async";
*
* (invokable) => new LazyPromise(invokable)
* ```
*/
lazyPromiseFactory?: Factory<AsyncLazy<any>, LazyPromise<any>>;
serde: OneOrMore<IFlexibleSerde>;
/**
* @default {""}
*/
serdeTransformerName?: string;
/**
* You can pass your owner id generator function.
*/
createOwnerId?: () => string;
/**
* @default
* ```ts
* import { EventBus } from "@daiso-tech/core/event-bus";
* import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
* import { KeyPrefixer } from "@daiso-tech/core/utilities";
*
* new EventBus({
* keyPrefixer: new KeyPrefixer("event-bus"),
* adapter: new MemoryEventBusAdapter()
* })
* ```
*/
eventBus?: IEventBus;
/**
* You can decide the default ttl value for {@link ILock | `ILock`} expiration. If null is passed then no ttl will be used by default.
* @default
* ```ts
* TimeSpan.fromMinutes(5);
* ```
*/
defaultTtl?: TimeSpan | null;
/**
* The default refresh time used in the {@link ILock | `ILock`} `acquireBlocking` and `runBlocking` methods.
* @default
* ```ts
* TimeSpan.fromSeconds(1);
* ```
*/
defaultBlockingInterval?: TimeSpan;
/**
* The default refresh time used in the {@link ILock | `ILock`} `acquireBlocking` and `runBlocking` methods.
* @default
* ```ts
* TimeSpan.fromMinutes(1);
* ```
*/
defaultBlockingTime?: TimeSpan;
/**
* The default refresh time used in the {@link ILock | `ILock`} `referesh` method.
* ```ts
* TimeSpan.fromMinutes(5);
* ```
*/
defaultRefreshTime?: TimeSpan;
};
/**
*
* IMPORT_PATH: `"@daiso-tech/core/lock"`
* @group Derivables
*/
export type LockAdapter = ILockAdapter | IDatabaseLockAdapter;
/**
*
* IMPORT_PATH: `"@daiso-tech/core/lock"`
* @group Derivables
*/
export type LockProviderSettings = LockProviderSettingsBase & {
adapter: LockAdapter;
};
/**
* `LockProvider` class can be derived from any {@link ILockAdapter | `ILockAdapter`} or {@link IDatabaseLockAdapter | `IDatabaseLockAdapter`}.
*
* Note the {@link ILock | `ILock`} instances created by the `LockProvider` class are serializable and deserializable,
* allowing them to be seamlessly transferred across different servers, processes, and databases.
* This can be done directly using {@link IFlexibleSerde | `IFlexibleSerde`} or indirectly through components that rely on {@link IFlexibleSerde | `IFlexibleSerde`} internally.
*
* IMPORT_PATH: `"@daiso-tech/core/lock"`
* @group Derivables
*/
export declare class LockProvider implements ILockProvider {
private lockStore;
private readonly eventBus;
private readonly adapter;
private readonly keyPrefixer;
private readonly createOwnerId;
private readonly defaultTtl;
private readonly defaultBlockingInterval;
private readonly defaultBlockingTime;
private readonly defaultRefreshTime;
private readonly serde;
private readonly lazyPromiseFactory;
private readonly serdeTransformerName;
/**
* @example
* ```ts
* import { SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
* import { LockProvider } from "@daiso-tech/core/lock";
* import { KeyPrefixer } from "@daiso-tech/core/utilities";
* 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 SqliteLockAdapter({
* database,
* });
* // You need initialize the adapter once before using it.
* await lockAdapter.init();
*
* const serde = new Serde(new SuperJsonSerdeAdapter())
* const lockProvider = new LockProvider({
* keyPrefixer: new KeyPrefixer("lock"),
* serde,
* adapter: lockAdapter,
* });
* ```
*/
constructor(settings: LockProviderSettings);
private registerToSerde;
/**
* You can listen to the following {@link LockEvents | `LockEvents`} of all {@link ILock | `ILock`} instances created by the {@link ILockProvider | `ILockProvider`}.
* To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
*/
addListener<TEventName extends keyof LockEventMap>(eventName: TEventName, listener: EventListener<LockEventMap[TEventName]>): LazyPromise<void>;
/**
* You can listen to the following {@link LockEvents | `LockEvents`} of all {@link ILock | `ILock`} instances created by the {@link ILockProvider | `ILockProvider`}.
* To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
*/
removeListener<TEventName extends keyof LockEventMap>(eventName: TEventName, listener: EventListener<LockEventMap[TEventName]>): LazyPromise<void>;
/**
* You can listen to the following {@link LockEvents | `LockEvents`} of all {@link ILock | `ILock`} instances created by the {@link ILockProvider | `ILockProvider`}.
* To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
*/
listenOnce<TEventName extends keyof LockEventMap>(eventName: TEventName, listener: EventListener<LockEventMap[TEventName]>): LazyPromise<void>;
/**
* You can listen to the following {@link LockEvents | `LockEvents`} of all {@link ILock | `ILock`} instances created by the {@link ILockProvider | `ILockProvider`}.
* To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
*/
asPromise<TEventName extends keyof LockEventMap>(eventName: TEventName): LazyPromise<LockEventMap[TEventName]>;
/**
* You can listen to the following {@link LockEvents | `LockEvents`} of all {@link ILock | `ILock`} instances created by the {@link ILockProvider | `ILockProvider`}.
* To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
*/
subscribeOnce<TEventName extends keyof LockEventMap>(eventName: TEventName, listener: EventListener<LockEventMap[TEventName]>): LazyPromise<Unsubscribe>;
/**
* You can listen to the following {@link LockEvents | `LockEvents`} of all {@link ILock | `ILock`} instances created by the {@link ILockProvider | `ILockProvider`}.
* To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
*/
subscribe<TEventName extends keyof LockEventMap>(eventName: TEventName, listener: EventListener<LockEventMap[TEventName]>): LazyPromise<Unsubscribe>;
private createLazyPromise;
/**
* @example
* ```ts
* import { LockProvider } from "@daiso-tech/core/lock";
* import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
* import { KeyPrefixer } from "@daiso-tech/core/utilities";
* import { Serde } from "@daiso-tech/core/serde";
* import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
*
* const lockProvider = new LockProvider({
* adapter: new MemoryLockAdapter(),
* keyPrefixer: new KeyPrefixer("lock"),
* serde: new Serde(new SuperJsonSerdeAdapter())
* });
*
* const lock = lockProvider.create("a");
* ```
*/
create(key: OneOrMore<string>, settings?: LockProviderCreateSettings): ILock;
}