@daiso-tech/core 0.16.0 → 0.17.4

package/dist/types/event-bus/implementations/derivables/event-bus-factory.d.ts

@@ -1,19 +1,8 @@
 /**
  * @module EventBus
  */
-import type { IGroupableEventBus, IEventBusAdapter, IEventBusFactory, BaseEvents } from "../../../event-bus/contracts/_module";
-/**
- * @group Derivables
- */
-export type EventBusDrivers<TAdapters extends string = string> = Partial<Record<TAdapters, IEventBusAdapter>>;
-/**
- * @group Derivables
- */
-export type EventBusFactorySettings<TAdapters extends string = string> = {
-    drivers: EventBusDrivers<TAdapters>;
-    defaultDriver?: NoInfer<TAdapters>;
-    rootGroup?: string;
-};
+import type { IGroupableEventBus, IEventBusFactory, BaseEvent } from "../../../event-bus/contracts/_module";
+import { type EventBusFactorySettings, EventBusFactorySettingsBuilder } from "../../../event-bus/implementations/derivables/event-bus-factory-settings";
 /**
  * @group Derivables
  * @example
@@ -22,22 +11,50 @@ export type EventBusFactorySettings<TAdapters extends string = string> = {
  * import Redis from "ioredis"
  *
  * const eventBusFactory = new EventBusFactory({
- *   drivers: {
- *     memory: new MemoryEventBusAdapter(),
+ *   adapters: {
+ *     memory: new MemoryEventBusAdapter({ rootGroup: "@global" }),
  *     redis: new RedisPubSubEventBusAdapter({
  *       dispatcherClient: new Redis(),
  *       listenerClient: new Redis(),
+ *       serde: new SuperJsonSerde(),
+ *       rootGroup: "@global"
  *     }),
  *   },
- *   defaultDriver: "memory",
+ *   defaultAdapter: "memory",
  * });
  * ```
  */
-export declare class EventBusFactory<TAdapters extends string = string, TEvents extends BaseEvents = BaseEvents> implements IEventBusFactory<TAdapters, TEvents> {
-    private readonly drivers;
-    private readonly defaultDriver?;
-    private readonly lazyPromiseSettings?;
+export declare class EventBusFactory<TAdapters extends string = string> implements IEventBusFactory<TAdapters> {
+    /**
+     * @example
+     * ```ts
+     * import { EventBusFactory, SuperJsonSerde. MemoryEventBusAdapter, RedisPubSubEventBusAdapter, EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const cacheFactory = new EventBusFactory(
+     *   EventBusFactory
+     *     .settings()
+     *     .setAdapter("memory", new MemoryEventBusAdapter({
+     *       rootGroup: "@global"
+     *     }))
+     *     .setAdapter("redis", new RedisPubSubEventBusAdapter({
+     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION"),
+     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION")
+     *       serde: new SuperJsonSerde(),
+     *       rootGroup: "@global"
+     *     }))
+     *     .setDefaultAdapter("memory")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TAdapters extends string, TSettings extends EventBusFactorySettings<TAdapters>>(): EventBusFactorySettingsBuilder<TSettings>;
+    private readonly adapters;
+    private readonly defaultAdapter?;
+    private readonly retryAttempts?;
+    private readonly backoffPolicy?;
+    private readonly retryPolicy?;
+    private readonly timeout?;
     constructor(settings: EventBusFactorySettings<TAdapters>);
-    use(driverName?: TAdapters | undefined): IGroupableEventBus<TEvents>;
-    withType<TOutput extends BaseEvents = TEvents>(): IEventBusFactory<TAdapters, TOutput>;
+    use<TEvents extends BaseEvent = BaseEvent>(adapterName?: TAdapters | undefined): IGroupableEventBus<TEvents>;
 }

package/dist/types/event-bus/implementations/derivables/event-bus-settings.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @module EventBus
+ */
+import type { BackoffPolicy, RetryPolicy } from "../../../async/_module";
+import { type IGroupableEventBus, type IEventBusAdapter } from "../../../event-bus/contracts/_module";
+import type { IBuildable, TimeSpan } from "../../../utilities/_module";
+/**
+ * @group Derivables
+ */
+export type EventBusSettings = {
+    adapter: IEventBusAdapter;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     */
+    timeout?: TimeSpan | null;
+};
+/**
+ * The <i>EventBusSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Derivables
+ */
+export declare class EventBusSettingsBuilder<TSettings extends Partial<EventBusSettings>> implements IBuildable<EventBusSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setAdapter(adapter: IEventBusAdapter): EventBusSettingsBuilder<TSettings & {
+        adapter: IEventBusAdapter;
+    }>;
+    setEventBus(eventBus: IGroupableEventBus<any>): EventBusSettingsBuilder<TSettings & {
+        eventBus: IGroupableEventBus<any>;
+    }>;
+    setDefultTtl(time: TimeSpan): EventBusSettingsBuilder<TSettings & {
+        defaultTtl: TimeSpan;
+    }>;
+    setRetryAttempts(attempts: number | null): EventBusSettingsBuilder<TSettings & {
+        retryAttempts: number | null;
+    }>;
+    setBackoffPolicy(policy: BackoffPolicy | null): EventBusSettingsBuilder<TSettings & {
+        backoffPolicy: BackoffPolicy | null;
+    }>;
+    setRetryPolicy(policy: RetryPolicy | null): EventBusSettingsBuilder<TSettings & {
+        retryPolicy: RetryPolicy | null;
+    }>;
+    setTimeout(time: TimeSpan | null): EventBusSettingsBuilder<TSettings & {
+        timeout: TimeSpan | null;
+    }>;
+    build(this: EventBusSettingsBuilder<EventBusSettings>): EventBusSettings;
+}

package/dist/types/event-bus/implementations/derivables/event-bus.d.ts

@@ -1,35 +1,47 @@
 /**
  * @module EventBus
  */
-import type { LazyPromiseSettings } from "../../../async/_module";
 import { LazyPromise } from "../../../async/_module";
-import type { SelectEvent, AllEvents, BaseEvents, Unsubscribe } from "../../../event-bus/contracts/_module";
-import { type IEventBus, type IGroupableEventBus, type IEventBusAdapter, type Listener } from "../../../event-bus/contracts/_module";
+import type { EventClass, EventInstance, Unsubscribe } from "../../../event-bus/contracts/_module";
+import { type IEventBus, type IGroupableEventBus, type Listener, type BaseEvent } from "../../../event-bus/contracts/_module";
 import type { OneOrMore } from "../../../utilities/_module";
-/**
- * @group Derivables
- */
-export type EventBusSettings = {
-    lazyPromiseSettings?: LazyPromiseSettings;
-};
+import type { EventBusSettings } from "../../../event-bus/implementations/derivables/event-bus-settings";
+import { EventBusSettingsBuilder } from "../../../event-bus/implementations/derivables/event-bus-settings";
 /**
  * <i>EventBus</i> class can be derived from any <i>{@link IEventBusAdapter}</i>.
  * @group Derivables
  */
-export declare class EventBus<TEvents extends BaseEvents = BaseEvents> implements IGroupableEventBus<TEvents> {
-    private readonly eventBusAdapter;
-    private readonly lazyPromiseSettings?;
-    constructor(eventBusAdapter: IEventBusAdapter, settings?: EventBusSettings);
+export declare class EventBus<TEvents extends BaseEvent = BaseEvent> implements IGroupableEventBus<TEvents> {
+    /**
+     * @example
+     * ```ts
+     * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     *
+     * const cache = new EventBus(
+     *   EventBus
+     *     .settings()
+     *     .setAdapter(new MemoryEventBusAdapter({ rootGroup: "@global" }))
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<EventBusSettings>>(): EventBusSettingsBuilder<TSettings>;
+    private readonly adapter;
+    private readonly retryAttempts;
+    private readonly backoffPolicy;
+    private readonly retryPolicy;
+    private readonly timeout;
+    constructor(settings: EventBusSettings);
     private createLayPromise;
     withGroup(group: OneOrMore<string>): IEventBus<TEvents>;
     getGroup(): string;
-    addListener<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    removeListener<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    dispatchMany(events: AllEvents<TEvents>[]): LazyPromise<void>;
-    dispatch(event: AllEvents<TEvents>): LazyPromise<void>;
-    addListenerMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    removeListenerMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    listenOnce<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    subscribe<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<Unsubscribe>;
-    subscribeMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<Unsubscribe>;
+    addListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListenerMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListenerMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    listenOnce<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    subscribe<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    dispatchMany(events: TEvents[]): LazyPromise<void>;
+    dispatch(event: TEvents): LazyPromise<void>;
 }

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

@@ -1,2 +1,6 @@
+export * from "../../serde/contracts/deserializer.contract";
+export * from "../../serde/contracts/flexible-serde.contract";
 export * from "../../serde/contracts/serde.contract";
 export * from "../../serde/contracts/serde.errors";
+export * from "../../serde/contracts/serializable.contract";
+export * from "../../serde/contracts/serializer.contract";

package/dist/types/serde/contracts/deserializer.contract.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serde
+ */
+/**
+ * The <i>IDeserializer</i> contract defines a standard way to deserialize plain data, excluding support for custom classes.
+ * @group Contracts
+ */
+export type IDeserializer<TSerializedValue = unknown> = {
+    /**
+     * @throws {DeserializationError} {@link DeserializationError}
+     */
+    deserialize<TValue>(serializedValue: TSerializedValue): TValue;
+};

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

@@ -0,0 +1,56 @@
+/**
+ * @module Serde
+ */
+import type { ISerializable } from "../../serde/contracts/serializable.contract";
+import type { ISerde } from "../../serde/contracts/serde.contract";
+/**
+ * The <i>SerializableClass</i> contract defines standard way to make a class instance serializable and deserializable.
+ * @group Contracts
+ */
+export type SerializableClass<TSerializedValue> = {
+    new (...arguments_: any[]): ISerializable<TSerializedValue>;
+    deserialize(serializedValue: TSerializedValue): ISerializable<TSerializedValue>;
+};
+/**
+ * The <i>IFlexibleSerde</i> contract defines a standard way to serialize and deserialize both plain data and custom classes.
+ * @group Contracts
+ */
+export type IFlexibleSerde<TSerializedValue = unknown> = ISerde<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>.
+     * @example
+     * ```ts
+     * import type { IFlexibleSerde } from "@daiso-tech/core";
+     *
+     * type SerializedUser = {
+     *   name: string;
+     *   age: number;
+     * };
+     *
+     * class User implements ISerializable<SerializedUser> {
+     *   static deserialize(serializedUser: SerializedUser): User {
+     *     return new User(serializedUser.name, serializedUser.age);
+     *   }
+     *
+     *   constructor(public readonly name: string, public readonly age: number) {}
+     *
+     *   getInfo(): string {
+     *     return `name: ${this.name}, age: ${this.age}`;
+     *   }
+     * }
+     *
+     * function main(serde: IFlexibleSerde) {
+     *   // You must register the class before trying to serialize or deserialize it.
+     *   serde.registerClass(User);
+     *
+     *   const user = serde.deserialize(serde.serialize(new User("Jacob", 50)));
+     *
+     *   console.log(user.getInfo());
+     *   // "name: Jacob, age: 50"
+     * }
+     *
+     * ```
+     */
+    registerClass<TSerializedClassInstance>(class_: SerializableClass<TSerializedClassInstance>): IFlexibleSerde<TSerializedValue>;
+};

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

@@ -1,41 +1,10 @@
 /**
- * @group Contracts
- */
-export type ISerializer<TSerializedValue = unknown> = {
-    /**
-     * @throws {SerializationError} {@link SerializationError}
-     */
-    serialize<TValue>(value: TValue): TSerializedValue;
-};
-/**
- * @group Contracts
- */
-export type IDeserde<TSerializedValue = unknown> = {
-    /**
-     * @throws {DeserializationError} {@link DeserializationError}
-     */
-    deserialize<TValue>(serializedValue: TSerializedValue): TValue;
-};
-/**
- * @group Contracts
- */
-export type ISerde<TSerializedValue = unknown> = ISerializer<TSerializedValue> & IDeserde<TSerializedValue>;
-/**
- * @group Contracts
- */
-export type ISerializable<TSerializedValue> = {
-    serialize(): TSerializedValue;
-};
-/**
- * @group Contracts
+ * @module Serde
  */
-export type SerializableClass<TSerializedValue> = {
-    new (...arguments_: any[]): ISerializable<TSerializedValue>;
-    deserialize(serializedValue: TSerializedValue): ISerializable<TSerializedValue>;
-};
+import type { ISerializer } from "../../serde/contracts/serializer.contract";
+import type { IDeserializer } from "../../serde/contracts/deserializer.contract";
 /**
+ * The <i>ISerde</i> contract defines a standard way to serialize and deserialize plain data, excluding support for custom classes.
  * @group Contracts
  */
-export type IFlexibleSerde<TSerializedValue = unknown> = ISerde<TSerializedValue> & {
-    registerClass<TSerializedValue>(class_: SerializableClass<TSerializedValue>): void;
-};
+export type ISerde<TSerializedValue = unknown> = ISerializer<TSerializedValue> & IDeserializer<TSerializedValue>;

package/dist/types/serde/contracts/serializable.contract.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module Serde
+ */
+/**
+ * The <i>ISerializable</i> contract defines standard way to make a class instance serializable.
+ * @group Contracts
+ */
+export type ISerializable<TSerializedValue> = {
+    serialize(): TSerializedValue;
+};

package/dist/types/serde/contracts/serializer.contract.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The <i>ISerializer</i> contract defines a standard way to serialize plain data, excluding support for custom classes.
+ * @group Contracts
+ */
+export type ISerializer<TSerializedValue = unknown> = {
+    /**
+     * @throws {SerializationError} {@link SerializationError}
+     */
+    serialize<TValue>(value: TValue): TSerializedValue;
+};

package/dist/types/serde/implementations/_module.d.ts

@@ -3,3 +3,4 @@ export * from "../../serde/implementations/mongodb-serde/_module";
 export * from "../../serde/implementations/redis-serde/_module";
 export * from "../../serde/implementations/sql-serde/_module";
 export * from "../../serde/implementations/super-json-serde/_module";
+export * from "../../serde/implementations/no-op-serde/_module";

package/dist/types/serde/implementations/_shared/test-utilities/_module.d.ts

@@ -1 +1,2 @@
 export * from "../../../../serde/implementations/_shared/test-utilities/serde.test-suite";
+export * from "../../../../serde/implementations/_shared/test-utilities/flexible-serde.test-suite";

package/dist/types/serde/implementations/_shared/test-utilities/flexible-serde.test-suite.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module Serde
+ */
+import { type TestAPI, type ExpectStatic } from "vitest";
+import type { IFlexibleSerde } from "../../../../serde/contracts/_module";
+/**
+ * @group Utilities
+ */
+export type FlexibleSerdeSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    createAdapter: () => IFlexibleSerde;
+};
+/**
+ * @group Utilities
+ */
+export declare function flexibleSerdeTestSuite(settings: FlexibleSerdeSuiteSettings): void;

package/dist/types/serde/implementations/_shared/test-utilities/serde.test-suite.d.ts

@@ -2,15 +2,14 @@
  * @module Serde
  */
 import { type TestAPI, type ExpectStatic } from "vitest";
-import { type ISerde } from "../../../../serde/contracts/_module";
-import { type Promisable } from "../../../../utilities/_module";
+import type { ISerde } from "../../../../serde/contracts/_module";
 /**
  * @group Utilities
  */
 export type SerdeSuiteSettings = {
     expect: ExpectStatic;
     test: TestAPI;
-    createAdapter: () => Promisable<ISerde>;
+    createAdapter: () => ISerde;
 };
 /**
  * @group Utilities

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

@@ -0,0 +1 @@
+export * from "../../../serde/implementations/no-op-serde/no-op-serde";

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

@@ -0,0 +1,13 @@
+/**
+ * @module EventBus
+ */
+import type { IFlexibleSerde, 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> {
+    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

@@ -19,7 +19,7 @@ export declare class SuperJsonSerde implements IFlexibleSerde<string> {
     private registerFloat32Array;
     private registerFloat64Array;
     private registerAll;
-    registerClass<TSerializedValue>(class_: SerializableClass<TSerializedValue>): void;
+    registerClass<TSerializedClassInstance>(class_: SerializableClass<TSerializedClassInstance>): IFlexibleSerde<string>;
     serialize<TValue>(value: TValue): string;
     deserialize<TValue>(value: string): TValue;
 }

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

@@ -1,2 +1,3 @@
+export * from "../../utilities/contracts/buildable.contract";
 export * from "../../utilities/contracts/deinitizable.contract";
 export * from "../../utilities/contracts/initizable.contract";

package/dist/types/utilities/contracts/buildable.contract.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module Utilities
+ */
+/**
+ * @group Contracts
+ */
+export type IBuildable<TReturn> = {
+    build(): TReturn;
+};

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

@@ -10,12 +10,12 @@ export declare class FactoryError extends Error {
 /**
  * @group Errors
  */
-export declare class DefaultDriverNotDefinedError extends FactoryError {
+export declare class DefaultAdapterNotDefinedError extends FactoryError {
     constructor(factoryName: string);
 }
 /**
  * @group Errors
  */
-export declare class UnregisteredDriverError extends FactoryError {
-    constructor(driverName: string);
+export declare class UnregisteredAdapterError extends FactoryError {
+    constructor(adapterName: string);
 }

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

@@ -23,3 +23,7 @@ export declare function isObjectEmpty(object: Record<string | number | symbol, a
  * @internal
  */
 export declare function simplifyGroupName(name: OneOrMore<string>): string;
+/**
+ * @internal
+ */
+export declare function getConstructorName(instance: object): string;

package/dist/types/utilities/time-span/time-span.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Utilities
  */
-import type { ISerializable } from "../../_module";
+import type { ISerializable } from "../../serde/contracts/_module";
 /**
  * @group Time utilities
  */
@@ -20,7 +20,7 @@ export declare class TimeSpan implements ISerializable<ISerializedTimeSpan> {
     private static hourInMilliseconds;
     private static dayInMilliseconds;
     static deserialize(serializedValue: ISerializedTimeSpan): TimeSpan;
-    constructor(milliseconds?: number);
+    private constructor();
     serialize(): ISerializedTimeSpan;
     static fromMilliseconds(milliseconds: number): TimeSpan;
     static fromSeconds(seconds: number): TimeSpan;

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

@@ -1,7 +1,6 @@
 /**
  * @module Utilities
  */
-export type Values<TValue> = TValue[keyof TValue];
 export type OneOrMore<TItem> = TItem | TItem[];
 export type Lazyable<TValue> = TValue | (() => TValue);
 export type Promisable<TValue> = TValue | PromiseLike<TValue>;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@daiso-tech/core",
     "private": false,
-    "version": "0.16.0",
+    "version": "0.17.4",
     "author": "Yousif Abdulkarim",
     "license": "Apache-2.0",
     "main": "./dist/cjs/_module.js",