@daiso-tech/core 0.15.0 → 0.16.0

package/dist/types/event-bus/implementations/adapters/no-op-event-bus-adapter/no-op-event-bus-adapter.d.ts

@@ -1,6 +1,7 @@
 /**
  * @module EventBus
  */
+import type { OneOrMore } from "../../../../utilities/_module";
 import type { Listener, IBaseEvent } from "../../../../event-bus/contracts/_module";
 import type { IEventBusAdapter } from "../../../../event-bus/contracts/_module";
 /**
@@ -8,7 +9,9 @@ import type { IEventBusAdapter } from "../../../../event-bus/contracts/_module";
  * @group Adapters
  */
 export declare class NoOpEventBusAdapter implements IEventBusAdapter {
+    getGroup(): string;
+    withGroup(_group: OneOrMore<string>): IEventBusAdapter;
     addListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
     removeListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
-    dispatch(_events: IBaseEvent[]): Promise<void>;
+    dispatch(_event: IBaseEvent): Promise<void>;
 }

package/dist/types/event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/redis-pub-sub-event-bus-adapter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @module EventBus
+ */
+import { type ISerde } from "../../../../serde/contracts/_module";
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
+import type Redis from "ioredis";
+import type { OneOrMore } from "../../../../utilities/_module";
+/**
+ * @group Adapters
+ */
+export type RedisPubSubEventBusAdapterSettings = {
+    dispatcherClient: Redis;
+    listenerClient: Redis;
+    serde: ISerde<string>;
+    rootGroup: OneOrMore<string>;
+};
+/**
+ * To utilize the <i>RedisPubSubEventBusAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerde | string serde}</i>, such as <i>{@link SuperJsonSerde}</i>.
+ * @group Adapters
+ * @example
+ * ```ts
+ * import { RedisPubSubEventBusAdapter, SuperJsonSerde } from "@daiso-tech/core";
+ * import Redis from "ioredis";
+ *
+ * const dispatcherClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
+ * const listenerClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
+ * const serde = new SuperJsonSerde();
+ * const eventBusAdapter = new RedisPubSubEventBusAdapter({
+ *   dispatcherClient,
+ *   listenerClient,
+ *   serde,
+ * });
+ * ```
+ */
+export declare class RedisPubSubEventBusAdapter implements IEventBusAdapter {
+    private readonly group;
+    private readonly serde;
+    private readonly redisSerde;
+    private readonly dispatcherClient;
+    private readonly listenerClient;
+    private readonly eventEmitter;
+    constructor({ dispatcherClient, listenerClient, serde, rootGroup, }: RedisPubSubEventBusAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): IEventBusAdapter;
+    private withPrefix;
+    private redisListener;
+    addListener(eventName: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(eventName: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(event: IBaseEvent): Promise<void>;
+}

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

@@ -1,7 +1,7 @@
 /**
  * @module EventBus
  */
-import type { INamespacedEventBus, IEventBusAdapter, IEventBusFactory, BaseEvents } from "../../../event-bus/contracts/_module";
+import type { IGroupableEventBus, IEventBusAdapter, IEventBusFactory, BaseEvents } from "../../../event-bus/contracts/_module";
 /**
  * @group Derivables
  */
@@ -12,7 +12,7 @@ export type EventBusDrivers<TAdapters extends string = string> = Partial<Record<
 export type EventBusFactorySettings<TAdapters extends string = string> = {
     drivers: EventBusDrivers<TAdapters>;
     defaultDriver?: NoInfer<TAdapters>;
-    rootNamespace?: string;
+    rootGroup?: string;
 };
 /**
  * @group Derivables
@@ -24,21 +24,20 @@ export type EventBusFactorySettings<TAdapters extends string = string> = {
  * const eventBusFactory = new EventBusFactory({
  *   drivers: {
  *     memory: new MemoryEventBusAdapter(),
- *     redis: new RedisEventBusAdapter({
+ *     redis: new RedisPubSubEventBusAdapter({
  *       dispatcherClient: new Redis(),
  *       listenerClient: new Redis(),
  *     }),
  *   },
  *   defaultDriver: "memory",
- *   rootNamespace: "@events"
  * });
  * ```
  */
 export declare class EventBusFactory<TAdapters extends string = string, TEvents extends BaseEvents = BaseEvents> implements IEventBusFactory<TAdapters, TEvents> {
     private readonly drivers;
     private readonly defaultDriver?;
-    private readonly rootNamespace?;
+    private readonly lazyPromiseSettings?;
     constructor(settings: EventBusFactorySettings<TAdapters>);
-    use(driverName?: TAdapters | undefined): INamespacedEventBus<TEvents>;
+    use(driverName?: TAdapters | undefined): IGroupableEventBus<TEvents>;
     withType<TOutput extends BaseEvents = TEvents>(): IEventBusFactory<TAdapters, TOutput>;
 }

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

@@ -1,61 +1,35 @@
 /**
  * @module EventBus
  */
+import type { LazyPromiseSettings } from "../../../async/_module";
 import { LazyPromise } from "../../../async/_module";
-import type { SelectEvent, AllEvents, BaseEvents } from "../../../event-bus/contracts/_module";
-import { type IEventBus, type INamespacedEventBus, type IEventBusAdapter, type Listener } from "../../../event-bus/contracts/_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 { OneOrMore } from "../../../utilities/_module";
-import { BaseEventBus } from "../../../event-bus/implementations/derivables/base-event-bus";
 /**
  * @group Derivables
  */
 export type EventBusSettings = {
-    /**
-     * You can prefix all keys with a given <i>namespace</i>.
-     * This useful if you want to add multitenancy but still use the same database.
-     * @default {""}
-     * @example
-     * ```ts
-     * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
-     *
-     * const memoryEventBusAdapter = new MemoryEventBusAdapter();
-     * const eventBusA = new EventBus(memoryEventBusAdapter, {
-     *   rootNamespace: "@a"
-     * });
-     * const eventBusB = new EventBus(memoryEventBusAdapter, {
-     *   rootNamespace: "@b"
-     * });
-     *
-     * (async () => {
-     *   eventBusB.addListener("add", event => {
-     *     // This will never be logged because eventBusB has different namespace
-     *     console.log("eventBusB:", event);
-     *   });
-     *
-     *   eventBusB.addListener("add", event => {
-     *     // This will be logged
-     *     console.log("eventBusB:", event);
-     *   });
-     *
-     *   await eventBusA.dispatch([
-     *     { type: "add", a: 1, b: 2 }
-     *   ]);
-     * })();
-     * ```
-     */
-    rootNamespace?: OneOrMore<string>;
+    lazyPromiseSettings?: LazyPromiseSettings;
 };
 /**
  * <i>EventBus</i> class can be derived from any <i>{@link IEventBusAdapter}</i>.
  * @group Derivables
  */
-export declare class EventBus<TEvents extends BaseEvents = BaseEvents> extends BaseEventBus<TEvents> implements INamespacedEventBus<TEvents> {
+export declare class EventBus<TEvents extends BaseEvents = BaseEvents> implements IGroupableEventBus<TEvents> {
     private readonly eventBusAdapter;
-    private readonly namespace;
+    private readonly lazyPromiseSettings?;
     constructor(eventBusAdapter: IEventBusAdapter, settings?: EventBusSettings);
-    withNamespace(namespace: OneOrMore<string>): IEventBus<TEvents>;
-    getNamespace(): string;
+    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>;
-    dispatch(events: OneOrMore<AllEvents<TEvents>>): 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>;
 }

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

@@ -0,0 +1,2 @@
+export * from "../../serde/contracts/serde.contract";
+export * from "../../serde/contracts/serde.errors";

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

@@ -0,0 +1,41 @@
+/**
+ * @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
+ */
+export type SerializableClass<TSerializedValue> = {
+    new (...arguments_: any[]): ISerializable<TSerializedValue>;
+    deserialize(serializedValue: TSerializedValue): ISerializable<TSerializedValue>;
+};
+/**
+ * @group Contracts
+ */
+export type IFlexibleSerde<TSerializedValue = unknown> = ISerde<TSerializedValue> & {
+    registerClass<TSerializedValue>(class_: SerializableClass<TSerializedValue>): void;
+};

package/dist/types/{serializer/contracts/serializer.errors.d.ts → serde/contracts/serde.errors.d.ts}

@@ -1,21 +1,21 @@
 /**
- * @module Serializer
+ * @module Serde
  */
 /**
  * @group Errors
  */
-export declare class SerializerError extends Error {
+export declare class SerdeError extends Error {
     constructor(message: string, cause?: unknown);
 }
 /**
  * @group Errors
  */
-export declare class SerializationError extends SerializerError {
+export declare class SerializationError extends SerdeError {
     constructor(message: string, cause?: unknown);
 }
 /**
  * @group Errors
  */
-export declare class DeserializationError extends SerializerError {
+export declare class DeserializationError extends SerdeError {
     constructor(message: string, cause?: unknown);
 }

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

@@ -0,0 +1,5 @@
+export * from "../../serde/implementations/_shared/test-utilities/_module";
+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";

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * @module Serde
+ */
+import { type TestAPI, type ExpectStatic } from "vitest";
+import { type ISerde } from "../../../../serde/contracts/_module";
+import { type Promisable } from "../../../../utilities/_module";
+/**
+ * @group Utilities
+ */
+export type SerdeSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    createAdapter: () => Promisable<ISerde>;
+};
+/**
+ * @group Utilities
+ */
+export declare function serdeTestSuite(settings: SerdeSuiteSettings): void;

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

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

package/dist/types/serde/implementations/mongodb-serde/mongodb-serde.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serde
+ */
+import { type ISerde } from "../../../serde/contracts/_module";
+/**
+ * @internal
+ */
+export declare class MongodbSerde implements ISerde<string | number> {
+    private readonly serde;
+    constructor(serde: ISerde<string>);
+    serialize<TValue>(value: TValue): string | number;
+    deserialize<TValue>(value: string | number): TValue;
+}

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

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

package/dist/types/serde/implementations/redis-serde/redis-serde.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serde
+ */
+import { type ISerde } from "../../../serde/contracts/_module";
+/**
+ * @internal
+ */
+export declare class RedisSerde implements ISerde<string> {
+    private readonly serde;
+    constructor(serde: ISerde<string>);
+    serialize<TValue>(value: TValue): string;
+    deserialize<TValue>(value: string): TValue;
+}

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

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

package/dist/types/serde/implementations/sql-serde/sql-serde.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serde
+ */
+import { type ISerde } from "../../../serde/contracts/_module";
+/**
+ * @internal
+ */
+export declare class SqlSerde implements ISerde<string> {
+    private readonly serde;
+    constructor(serde: ISerde<string>);
+    serialize<TValue>(value: TValue): string;
+    deserialize<TValue>(value: string): TValue;
+}

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

@@ -0,0 +1 @@
+export * from "../../../serde/implementations/super-json-serde/super-json-serde";

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

@@ -0,0 +1,25 @@
+/**
+ * @module Serde
+ */
+import type { SerializableClass } from "../../../serde/contracts/_module";
+import { type IFlexibleSerde } from "../../../serde/contracts/_module";
+/**
+ * @group Adapters
+ */
+export declare class SuperJsonSerde implements IFlexibleSerde<string> {
+    private readonly superJson;
+    constructor();
+    private registerBuffer;
+    private registerUint8Array;
+    private registerInt8Array;
+    private registerUint16Array;
+    private registerInt16Array;
+    private registerUint32Array;
+    private registerInt32Array;
+    private registerFloat32Array;
+    private registerFloat64Array;
+    private registerAll;
+    registerClass<TSerializedValue>(class_: SerializableClass<TSerializedValue>): void;
+    serialize<TValue>(value: TValue): string;
+    deserialize<TValue>(value: string): TValue;
+}

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

@@ -22,4 +22,4 @@ export declare function isObjectEmpty(object: Record<string | number | symbol, a
 /**
  * @internal
  */
-export declare function simplifyNamespace(namepsace: OneOrMore<string>): string;
+export declare function simplifyGroupName(name: OneOrMore<string>): string;

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

@@ -1,18 +1,27 @@
 /**
  * @module Utilities
  */
+import type { ISerializable } from "../../_module";
+/**
+ * @group Time utilities
+ */
+export type ISerializedTimeSpan = {
+    timeInMs: number;
+};
 /**
  * The <i>TimeSpan</i> class is used for representing time interval that is the difference between two times measured in a number of days, hours, minutes, and seconds.
  * <i>TimeSpan</i> cannot be negative.
  * @group Time utilities
  */
-export declare class TimeSpan {
+export declare class TimeSpan implements ISerializable<ISerializedTimeSpan> {
     private readonly milliseconds;
     private static secondInMilliseconds;
     private static minuteInMilliseconds;
     private static hourInMilliseconds;
     private static dayInMilliseconds;
-    private constructor();
+    static deserialize(serializedValue: ISerializedTimeSpan): TimeSpan;
+    constructor(milliseconds?: number);
+    serialize(): ISerializedTimeSpan;
     static fromMilliseconds(milliseconds: number): TimeSpan;
     static fromSeconds(seconds: number): TimeSpan;
     static fromMinutes(minutes: number): TimeSpan;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@daiso-tech/core",
     "private": false,
-    "version": "0.15.0",
+    "version": "0.16.0",
     "author": "Yousif Abdulkarim",
     "license": "Apache-2.0",
     "main": "./dist/cjs/_module.js",
@@ -74,8 +74,7 @@
         "typedoc-plugin-merge-modules": "^6.0.0",
         "typescript": "^5.5.4",
         "vite-tsconfig-paths": "^4.3.2",
-        "vitest": "^2.0.5",
-        "zod": "^3.24.1"
+        "vitest": "^3.0.2"
     },
     "peerDependencies": {
         "@libsql/client": "^0.4.1",
@@ -95,16 +94,11 @@
         },
         "@libsql/client": {
             "optional": true
-        },
-        "zod": {
-            "optional": true
         }
     },
     "dependencies": {
         "@libsql/kysely-libsql": "^0.4.0",
-        "escape-string-regexp": "^5.0.0",
         "kysely": "^0.27.0",
-        "superjson": "^2.2.0",
-        "zod": "^3.24.0"
+        "superjson-cjs": "^2.2.3"
     }
 }