@daiso-tech/core 0.21.0 → 0.22.0

package/dist/types/lock/implementations/adapters/mongodb-lock-adapter/mongodb-lock-adapter.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @module Lock
+ */
+import type { IDatabaseLockAdapter, ILockData } from "../../../../lock/contracts/_module";
+import type { CollectionOptions, Db } from "mongodb";
+/**
+ * @group Adapters
+ */
+export type MongodbLockAdapterSettings = {
+    database: Db;
+    rootGroup: string;
+    collectionName?: string;
+    collectionSettings?: CollectionOptions;
+};
+/**
+ * @group Adapters
+ */
+export declare class MongodbLockAdapter implements IDatabaseLockAdapter {
+    private readonly group;
+    private readonly database;
+    private readonly collection;
+    private readonly collectionName;
+    private readonly collectionSettings?;
+    /**
+     * @example
+     * ```ts
+     * import { MongodbLockAdapter } from "@daiso-tech/core";
+     * import { MongoClient } from "mongodb";
+     *
+     * (async () => {
+     *   const client = await MongoClient.connect("YOUR_MONGODB_CONNECTION_STRING");
+     *   const database = client.db("database");
+     *   const lockAdapter = new MongodbLockAdapter({
+     *     database,
+     *     rootGroup: "@global"
+     *   });
+     *   await lockAdapter.init();
+     * })();
+     * ```
+     */
+    constructor({ collectionName, collectionSettings, database, rootGroup, }: MongodbLockAdapterSettings);
+    removeExpiredKeys(): Promise<void>;
+    /**
+     * Creates all related indexes.
+     * Note the <i>init</i> method needs to be called before using the adapter.
+     */
+    init(): Promise<void>;
+    /**
+     * Removes the collection where the cache values are stored and all it's related indexes.
+     * Note all cache data will be removed.
+     */
+    deInit(): Promise<void>;
+    insert(key: string, owner: string, expiration: Date | null): Promise<void>;
+    update(key: string, owner: string, expiration: Date | null): Promise<number>;
+    remove(key: string, owner: string | null): Promise<void>;
+    refresh(key: string, owner: string, expiration: Date): Promise<number>;
+    find(key: string): Promise<ILockData | null>;
+    getGroup(): string;
+    withGroup(group: string): IDatabaseLockAdapter;
+}

package/dist/types/lock/implementations/adapters/redis-lock-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../lock/implementations/adapters/redis-lock-adapter/redis-lock-adapter";

package/dist/types/lock/implementations/adapters/redis-lock-adapter/redis-lock-adapter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module Lock
+ */
+import { TimeSpan } from "../../../../utilities/_module";
+import type { ILockAdapter } from "../../../../lock/contracts/_module";
+import type Redis from "ioredis";
+import type { Result } from "ioredis";
+declare module "ioredis" {
+    interface RedisCommander<Context> {
+        daiso_lock_acquire(key: string, owner: string, ttl: string): Result<number, Context>;
+        daiso_lock_release(key: string, owner: string): Result<number, Context>;
+        daiso_lock_refresh(key: string, owner: string, ttl: string): Result<number, Context>;
+    }
+}
+/**
+ * @group Adapters
+ */
+export type RedisLockAdapterSettings = {
+    database: Redis;
+    rootGroup: string;
+};
+/**
+ * @group Adapters
+ */
+export declare class RedisLockAdapter implements ILockAdapter {
+    private readonly group;
+    private readonly database;
+    /**
+     * @example
+     * ```ts
+     * import { RedisLockAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const database = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const serde = new SuperJsonSerde();
+     * const lockAdapter = new RedisLockAdapter({
+     *   database,
+     *   serde,
+     *   rootGroup: "@global"
+     * });
+     * ```
+     */
+    constructor(settings: RedisLockAdapterSettings);
+    private initAquireCommand;
+    private initReleaseCommand;
+    private initRefreshComand;
+    private getPrefix;
+    private withPrefix;
+    acquire(key: string, owner: string, ttl: TimeSpan | null): Promise<boolean>;
+    release(key: string, owner: string): Promise<boolean>;
+    forceRelease(key: string): Promise<void>;
+    isLocked(key: string): Promise<boolean>;
+    getRemainingTime(key: string): Promise<TimeSpan | null>;
+    refresh(key: string, owner: string, ttl: TimeSpan): Promise<boolean>;
+    getGroup(): string;
+    withGroup(group: string): ILockAdapter;
+}

package/dist/types/lock/implementations/adapters/sqlite-lock-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../lock/implementations/adapters/sqlite-lock-adapter/sqlite-lock-adapter";

package/dist/types/lock/implementations/adapters/sqlite-lock-adapter/sqlite-lock-adapter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module Lock
+ */
+import type { IDatabaseLockAdapter, ILockData } from "../../../../lock/contracts/_module";
+import { TimeSpan } from "../../../../utilities/_module";
+import type { SqliteDatabase } from "kysely";
+/**
+ * @group Adapters
+ */
+export type SqliteLockAdapterSettings = {
+    database: SqliteDatabase;
+    tableName?: string;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+    rootGroup: string;
+};
+/**
+ * @group Adapters
+ */
+export declare class SqliteLockAdapter implements IDatabaseLockAdapter {
+    private databaseLockAdapter;
+    /**
+     * @example
+     * ```ts
+     * import { SqliteLockAdapter } from "@daiso-tech/core";
+     * import Sqlite from "better-sqlite3";
+     *
+     * (async () => {
+     *   const database = new Sqlite("local.db");
+     *   const lockAdapter = new SqliteLockAdapter({
+     *     database,
+     *     rootGroup: "@global"
+     *   });
+     *   await lockAdapter.init();
+     * })();
+     * ```
+     */
+    constructor(settings: SqliteLockAdapterSettings);
+    removeExpiredKeys(): Promise<void>;
+    /**
+     * Removes the table where the cache values are stored and removes the table indexes.
+     * Note all cache data will be removed.
+     */
+    deInit(): Promise<void>;
+    /**
+     * Creates the table where the cache values are stored and it's related indexes.
+     * Note the <i>init</i> method needs to be called before using the adapter.
+     */
+    init(): Promise<void>;
+    insert(key: string, owner: string, expiration: Date | null): Promise<void>;
+    update(key: string, owner: string, expiration: Date | null): Promise<number>;
+    remove(key: string, owner: string | null): Promise<void>;
+    refresh(key: string, owner: string, expiration: Date): Promise<number>;
+    find(key: string): Promise<ILockData | null>;
+    getGroup(): string;
+    withGroup(group: string): IDatabaseLockAdapter;
+}

package/dist/types/lock/implementations/derivables/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../lock/implementations/derivables/lock-provider/_module";
+export * from "../../../lock/implementations/derivables/lock-provider-factory/_module";

package/dist/types/lock/implementations/derivables/lock-provider/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../lock/implementations/derivables/lock-provider/lock-provider";

package/dist/types/lock/implementations/derivables/lock-provider/database-lock-adapter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module Lock
+ */
+import type { IDeinitizable, IInitizable } from "../../../../_module";
+import { TimeSpan } from "../../../../_module";
+import type { IDatabaseLockAdapter, ILockAdapter } from "../../../../lock/contracts/_module";
+/**
+ * @internal
+ */
+export declare class DatabaseLockAdapter implements ILockAdapter, IDeinitizable, IInitizable {
+    private readonly adapter;
+    constructor(adapter: IDatabaseLockAdapter);
+    init(): Promise<void>;
+    deInit(): Promise<void>;
+    acquire(key: string, owner: string, ttl: TimeSpan | null): Promise<boolean>;
+    release(key: string, owner: string): Promise<boolean>;
+    forceRelease(key: string): Promise<void>;
+    isLocked(key: string): Promise<boolean>;
+    getRemainingTime(key: string): Promise<TimeSpan | null>;
+    refresh(key: string, owner: string, ttl: TimeSpan): Promise<boolean>;
+    getGroup(): string;
+    withGroup(group: string): ILockAdapter;
+}

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

@@ -0,0 +1,89 @@
+/**
+ * @module Lock
+ */
+import type { ISerdeRegistrable } from "../../../../utilities/_module";
+import { TimeSpan, type OneOrMore } from "../../../../utilities/_module";
+import type { IDatabaseLockAdapter, LockEvents } from "../../../../lock/contracts/_module";
+import { type ILock, type IGroupableLockProvider, type LockProviderCreateSettings, type ILockProvider, type ILockAdapter } from "../../../../lock/contracts/_module";
+import type { BackoffPolicy, LazyPromise, RetryPolicy } from "../../../../async/_module";
+import { Lock, type ISerializedLock } from "../../../../lock/implementations/derivables/lock-provider/lock";
+import type { EventClass, EventInstance, IGroupableEventBus, Listener, Unsubscribe } from "../../../../event-bus/contracts/_module";
+import type { IFlexibleSerde, ISerdeTransformer } from "../../../../serde/contracts/_module";
+/**
+ * @group Derivables
+ */
+export type LockProviderSettings = {
+    /**
+     * You can pass your owner id generator function.
+     */
+    createOwnerId?: () => string;
+    adapter: ILockAdapter | IDatabaseLockAdapter;
+    /**
+     * 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 refresh time used in the <i>{@link ILock}</i> <i>extend</i> method.
+     * @default TimeSpan.fromMinutes(5);
+     */
+    defaultRefreshTime?: 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;
+};
+/**
+ * @group Derivables
+ */
+export declare class LockProvider implements IGroupableLockProvider, ISerdeRegistrable, ISerdeTransformer<Lock, ISerializedLock> {
+    private static DEFAULT_TTL;
+    private static DEFAULT_REFRESH_TIME;
+    private static isDatabaseAdapter;
+    private readonly createOwnerId;
+    private readonly adapter;
+    private readonly defaultTtl;
+    private readonly defaultRefreshTime;
+    private readonly retryAttempts;
+    private readonly backoffPolicy;
+    private readonly retryPolicy;
+    private readonly timeout;
+    private readonly eventBus;
+    private readonly lockProviderEventBus;
+    get name(): string;
+    constructor(settings: LockProviderSettings);
+    addListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    listenOnce<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    subscribe<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    isApplicable(value: unknown): value is Lock;
+    serialize(deserializedValue: Lock): ISerializedLock;
+    deserialize(serializedValue: ISerializedLock): Lock;
+    create(key: OneOrMore<string>, settings?: LockProviderCreateSettings): ILock;
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ILockProvider;
+    registerToSerde(serde: OneOrMore<IFlexibleSerde>): void;
+}

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

@@ -0,0 +1,73 @@
+/**
+ * @module Lock
+ */
+import type { LazyPromiseable, Result } from "../../../../utilities/_module";
+import type { TimeSpan } from "../../../../utilities/_module";
+import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module";
+import { LazyPromise } from "../../../../async/_module";
+import type { ILockAdapter, LockEvents } from "../../../../lock/contracts/_module";
+import { KeyAlreadyAcquiredLockError, type ILock } from "../../../../lock/contracts/_module";
+import type { EventClass, Listener, EventInstance, Unsubscribe, IGroupableEventBus, IEventDispatcher } from "../../../../event-bus/contracts/_module";
+/**
+ * @group Derivables
+ */
+export type ISerializedLock = {
+    group: string;
+    key: string;
+    owner: string;
+    ttlInMs: number | null;
+};
+/**
+ * @internal
+ */
+export type LockSettings = {
+    lockEventBus: IGroupableEventBus<LockEvents>;
+    lockProviderEventDispatcher: IEventDispatcher<LockEvents>;
+    adapter: ILockAdapter;
+    key: string;
+    owner: string;
+    defaultRefreshTime: TimeSpan;
+    ttl: TimeSpan | null;
+    lazyPromiseSettings: {
+        retryAttempts: number | null;
+        backoffPolicy: BackoffPolicy | null;
+        retryPolicy: RetryPolicy | null;
+        timeout: TimeSpan | null;
+    };
+};
+/**
+ * @internal
+ */
+export declare class Lock implements ILock {
+    static serialize(deserializedValue: Lock): ISerializedLock;
+    private readonly lockProviderEventDispatcher;
+    private readonly lockEventBus;
+    private readonly adapter;
+    private readonly key;
+    private readonly owner;
+    private readonly ttl;
+    private readonly defaultRefreshTime;
+    private readonly lazyPromiseSettings;
+    constructor(settings: LockSettings);
+    private createLayPromise;
+    run<TValue = void>(asyncFn: LazyPromiseable<TValue>, shouldTimeout?: boolean): LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>;
+    runOrFail<TValue = void>(asyncFn: LazyPromiseable<TValue>, shouldTimeout?: boolean): LazyPromise<TValue>;
+    acquire(): LazyPromise<boolean>;
+    acquireOrFail(): LazyPromise<void>;
+    release(): LazyPromise<boolean>;
+    releaseOrFail(): LazyPromise<void>;
+    forceRelease(): LazyPromise<void>;
+    isExpired(): LazyPromise<boolean>;
+    isLocked(): LazyPromise<boolean>;
+    refresh(ttl?: TimeSpan): LazyPromise<boolean>;
+    refreshOrFail(ttl?: TimeSpan): LazyPromise<void>;
+    getRemainingTime(): LazyPromise<TimeSpan | null>;
+    getOwner(): LazyPromise<string>;
+    addListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    listenOnce<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    subscribe<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+}

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

@@ -0,0 +1 @@
+export * from "../../../../lock/implementations/derivables/lock-provider-factory/lock-provider-factory";

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

@@ -0,0 +1,98 @@
+/**
+ * @module Lock
+ */
+import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module";
+import type { IGroupableEventBus } from "../../../../event-bus/contracts/_module";
+import type { IDatabaseLockAdapter, ILockAdapter } from "../../../../lock/contracts/_module";
+import type { ILockProviderFactory } from "../../../../lock/contracts/lock-provider-factory.contract";
+import type { IGroupableLockProvider } from "../../../../lock/contracts/lock-provider.contract";
+import type { IFlexibleSerde } from "../../../../serde/contracts/_module";
+import { type OneOrMore } from "../../../../utilities/_module";
+import type { TimeSpan } from "../../../../utilities/_module";
+/**
+ * @group Derivables
+ */
+export type LockAdapters<TAdapters extends string> = Partial<Record<TAdapters, ILockAdapter | IDatabaseLockAdapter>>;
+/**
+ * @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;
+};
+/**
+ * @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?;
+    constructor(settings: LockProviderFactorySettings<TAdapters>);
+    private init;
+    use(adapterName?: TAdapters | undefined): IGroupableLockProvider;
+}

package/dist/types/serde/contracts/flexible-serde.contract.d.ts

@@ -3,6 +3,7 @@
  */
 import type { ISerializable } from "../../serde/contracts/serializable.contract";
 import type { ISerde } from "../../serde/contracts/serde.contract";
+import type { BaseEvent } from "../../_module";
 /**
  * The <i>SerializableClass</i> contract defines standard way to make a class instance serializable and deserializable.
  * @group Contracts
@@ -12,10 +13,9 @@ export type SerializableClass<TSerializedValue> = {
     deserialize(serializedValue: TSerializedValue): ISerializable<TSerializedValue>;
 };
 /**
- * The <i>SerializableClass</i> contract defines standard way to make a error class instance serializable and deserializable.
  * @group Contracts
  */
-export type ErrorClass = new (...args: any[]) => Error;
+export type SerializableEventClass<TFields extends Record<string, unknown>> = new (fields: any) => BaseEvent<TFields>;
 /**
  * @group Contracts
  */
@@ -30,6 +30,7 @@ export type ISerdeTransformer<TDeserializedValue, TSerializedValue> = {
  * @group Contracts
  */
 export type IFlexibleSerde<TSerializedValue = unknown> = ISerde<TSerializedValue> & {
+    registerEvent<TFields extends Record<string, unknown>>(eventClass: SerializableEventClass<TFields>): IFlexibleSerde<TSerializedValue>;
     /**
      * The <i>registerClass</i> method is used for registering custom class for serialization and deserialization.
      * The <i>class_</i> parameter must be of type <i>{@link SerializableClass}</i>.

package/dist/types/serde/implementations/no-op-serde/no-op-serde.d.ts

@@ -1,12 +1,13 @@
 /**
  * @module EventBus
  */
-import type { IFlexibleSerde, ISerdeTransformer, SerializableClass } from "../../../serde/contracts/_module";
+import type { SerializableEventClass, IFlexibleSerde, ISerdeTransformer, SerializableClass } from "../../../serde/contracts/_module";
 /**
  * This <i>NoOpSerde</i> will do nothing and is used for easily mocking {@link IFlexibleSerde} or {@link ISerde} for testing.
  * @group Adapters
  */
 export declare class NoOpSerde<TSerializedValue> implements IFlexibleSerde<TSerializedValue> {
+    registerEvent<TFields extends Record<string, unknown>>(_eventClass: SerializableEventClass<TFields>): IFlexibleSerde<TSerializedValue>;
     serialize<TValue>(value: TValue): TSerializedValue;
     deserialize<TValue>(serializedValue: TSerializedValue): TValue;
     registerClass<TSerializedClassInstance>(_class: SerializableClass<TSerializedClassInstance>): IFlexibleSerde<TSerializedValue>;

package/dist/types/serde/implementations/super-json-serde/super-json-serde.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Serde
  */
-import type { ISerdeTransformer, SerializableClass } from "../../../serde/contracts/_module";
+import type { SerializableEventClass, ISerdeTransformer, SerializableClass } from "../../../serde/contracts/_module";
 import { type IFlexibleSerde } from "../../../serde/contracts/_module";
 /**
  * The <i>SuperJsonSerde</i> class has direct support for the following values
@@ -41,6 +41,7 @@ export declare class SuperJsonSerde implements IFlexibleSerde<string> {
     private registerFloat64Array;
     private registerAll;
     registerClass<TSerializedClassInstance>(class_: SerializableClass<TSerializedClassInstance>): IFlexibleSerde<string>;
+    registerEvent<TFields extends Record<string, unknown>>(eventClass: SerializableEventClass<TFields>): IFlexibleSerde<string>;
     serialize<TValue>(value: TValue): string;
     deserialize<TValue>(value: string): TValue;
 }

package/dist/types/utilities/contracts/_module.d.ts

@@ -2,3 +2,4 @@ export * from "../../utilities/contracts/serialized-error.contract";
 export * from "../../utilities/contracts/buildable.contract";
 export * from "../../utilities/contracts/deinitizable.contract";
 export * from "../../utilities/contracts/initizable.contract";
+export * from "../../utilities/contracts/serde-registrable.contract";

package/dist/types/utilities/contracts/serde-registrable.contract.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module Utilities
+ */
+import type { IFlexibleSerde } from "../../serde/contracts/_module";
+import type { OneOrMore } from "../../utilities/types";
+/**
+ * @group Contracts
+ */
+export type ISerdeRegistrable = {
+    registerToSerde(serde: OneOrMore<IFlexibleSerde>): void;
+};

package/dist/types/utilities/types.d.ts

@@ -1,12 +1,14 @@
 /**
  * @module Utilities
  */
+import type { LazyPromise } from "../_module";
 export type OneOrMore<TItem> = TItem | [TItem, ...TItem[]];
 export type Lazyable<TValue> = TValue | (() => TValue);
 export type Promisable<TValue> = TValue | PromiseLike<TValue>;
-export type AsyncLazyable<TValue> = TValue | (() => Promisable<TValue>);
+export type AsyncLazyable<TValue> = TValue | LazyPromise<TValue> | (() => Promisable<TValue>);
 export type Result<TValue, TError> = [TValue, null] | [null, TError];
 export type AsyncIterableValue<TInput> = Iterable<TInput> | AsyncIterable<TInput>;
 export type AnyFunction = (...parameters: unknown[]) => unknown;
 export type Func<TArgs extends unknown[], TReturn> = (...args_: TArgs) => TReturn;
 export type GetOrAddValue<TValue> = Awaited<TValue extends AnyFunction ? ReturnType<TValue> : TValue>;
+export type LazyPromiseable<TValue> = (() => PromiseLike<TValue>) | LazyPromise<TValue>;

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "@daiso-tech/core",
     "private": false,
-    "version": "0.21.0",
+    "version": "0.22.0",
     "author": "Yousif Abdulkarim",
     "license": "Apache-2.0",
     "main": "./dist/cjs/_module.js",
     "module": "./dist/esm/_module.js",
     "types": "./dist/types/_module.d.ts",
-    "homepage": "https://yousif-khalil-abdulkarim.github.io/daiso-core/",
+    "homepage": "https://yousif-khalil-abdulkarim.github.io/daiso-core/modules.html",
     "repository": {
         "type": "git",
         "url": "https://github.com/yousif-khalil-abdulkarim/daiso-core.git"
@@ -53,6 +53,7 @@
         "@testcontainers/mongodb": "^10.13.2",
         "@testcontainers/redis": "^10.13.2",
         "@types/better-sqlite3": "^7.6.11",
+        "@types/uuid": "^10.0.0",
         "@typescript-eslint/eslint-plugin": "^8.1.0",
         "@typescript-eslint/parser": "^8.1.0",
         "@vitest/eslint-plugin": "^1.0.3",
@@ -99,6 +100,7 @@
     "dependencies": {
         "@libsql/kysely-libsql": "^0.4.0",
         "kysely": "^0.27.0",
-        "superjson-cjs": "^2.2.3"
+        "superjson-cjs": "^2.2.3",
+        "uuid": "^11.0.5"
     }
 }