@daiso-tech/core 0.7.0 → 0.8.1

package/dist/types/storage/implementations/storage/storage.d.ts

@@ -1,21 +1,94 @@
 /**
  * @module Storage
  */
-import { type IStorageAdapter } from "../../../storage/contracts/_module";
-import { type StorageValue, type IStorage } from "../../../storage/contracts/_module";
+import { type IStorage, type IStorageAdapter } from "../../../storage/contracts/_module";
+import { type StorageValue, type INamespacedStorage, type AllStorageEvents } from "../../../storage/contracts/_module";
 import { type AsyncLazyable, type GetOrAddValue } from "../../../_shared/types";
 import type { Validator } from "../../../utilities/_module";
 import { LazyPromise } from "../../../utilities/_module";
+import type { INamespacedEventBus, Listener, SelectEvent, Unsubscribe } from "../../../event-bus/contracts/_module";
+/**
+ * @group Derivables
+ */
 export type StorageSettings<TType> = {
-    namespace?: string;
+    /**
+     * You can prefix all keys with a given <i>rootNamespace</i>.
+     * This useful if you want to add multitenancy but still use the same database.
+     * @default {""}
+     * @example
+     * ```ts
+     * import { Storage, MemoryStorageAdapter } from "@daiso-tech/core";
+     *
+     * const storageA = new Storage(new MemoryStorageAdapter(), {
+     *   rootNamespace: "@a/"
+     * });
+     * const storageB = new Storage(new MemoryStorageAdapter(), {
+     *   rootNamespace: "@b/"
+     * });
+     *
+     * (async () => {
+     *   await storageA.add("a", 1);
+     *
+     *   // Will be "a"
+     *   console.log(await storageA.get("a"));
+     *
+     *   // Will be "null"
+     *   console.log(await storageB.get("a"));
+     * })();
+     * ```
+     */
+    rootNamespace?: string;
+    /**
+     * You can pass a custom <i>{@link Validator}</i> to validate, transform and sanitize your data.
+     * You could also use <i>{@link zodValidator}</i> which enables you to use zod for validating, transforming, and sanitizing.
+     * @example
+     * ```ts
+     * import { Storage, MemoryStorageAdapter, zodValidator } from "@daiso-tech/core";
+     * import { z } from "zod";
+     *
+     * const storage = new Storage(new MemoryStorageAdapter(), {
+     *   // Type will be infered from validator
+     *   validator: zodValidator(z.string())
+     * });
+     *
+     * (async () => {
+     *   // An Typescript error will be seen and ValidationError will be thrown during runtime.
+     *   await storageA.add("a", 1);
+     * })();
+     * ```
+     */
     validator?: Validator<TType>;
+    eventBus?: INamespacedEventBus<AllStorageEvents<TType>>;
 };
-export declare class Storage<TType = unknown> implements IStorage<TType> {
+/**
+ * <i>Storage</i> class can be derived from any <i>{@link IStorageAdapter}</i>.
+ * @group Derivables
+ */
+export declare class Storage<TType = unknown> implements INamespacedStorage<TType> {
     private readonly storageAdapter;
-    private readonly namespaceStorageAdapter;
-    private readonly settings;
-    constructor(storageAdapter: IStorageAdapter<any>, { namespace, validator, }?: StorageSettings<TType>);
-    namespace(name: string): IStorage<TType>;
+    static EVENTS: {
+        readonly KEYS_FOUND: "keys_found";
+        readonly KEYS_NOT_FOUND: "keys_not_found";
+        readonly KEYS_ADDED: "keys_added";
+        readonly KEYS_UPDATED: "keys_updated";
+        readonly KEYS_REMOVED: "keys_removed";
+        readonly KEYS_CLEARED: "keys_cleared";
+        readonly KEY_INCREMENTED: "key_incremented";
+        readonly KEY_DECREMENTED: "key_decremented";
+    };
+    private readonly withEventStorageAdapter;
+    private readonly namespace_;
+    private readonly validator;
+    private readonly eventBus;
+    constructor(storageAdapter: IStorageAdapter<any>, settings?: StorageSettings<TType>);
+    addListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
+    addListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
+    removeListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
+    removeListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
+    subscribe<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<Unsubscribe>;
+    subscribeMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<Unsubscribe>;
+    withNamespace(namespace: string): IStorage<TType>;
+    getNamespace(): string;
     exists(key: string): LazyPromise<boolean>;
     existsMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     missing(key: string): LazyPromise<boolean>;

package/dist/types/storage/implementations/storage/with-event-storage-adapter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module Storage
+ */
+import type { StorageEvent } from "../../../storage/contracts/_module";
+import { type IStorageAdapter, type AllStorageEvents } from "../../../storage/contracts/_module";
+import { type IEventBus } from "../../../event-bus/contracts/_module";
+import type { WithNamespaceStorageAdapter } from "../../../storage/implementations/storage/with-namespace-storage-adapter";
+/**
+ * @internal
+ */
+export declare class WithEventStorageAdapter<TType> implements Required<Omit<IStorageAdapter<TType>, "clear">> {
+    private readonly withNamespaceStorageAdapter;
+    private readonly eventBus;
+    private readonly eventAttributes;
+    constructor(withNamespaceStorageAdapter: WithNamespaceStorageAdapter<TType>, eventBus: IEventBus<AllStorageEvents<TType>>, eventAttributes: StorageEvent);
+    private triggerGetManyEvents;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    private triggerAddManyEvents;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private triggerUpdateManyEvents;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private triggerPutManyEvents;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private triggerRemoveManyEvents;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    private triggerIncrementEvents;
+    private triggerDecrementEvents;
+    increment(key: string, value: number): Promise<boolean>;
+    private triggerClearEvents;
+    clear(): Promise<void>;
+}

package/dist/types/storage/implementations/storage/with-namespace-storage-adapter.d.ts

@@ -20,6 +20,5 @@ export declare class WithNamespaceStorageAdapter<TType> implements Required<Omit
     putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
     removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
     increment(key: string, value: number): Promise<boolean>;
-    decrement(key: string, value: number): Promise<boolean>;
     clear(): Promise<void>;
 }

package/dist/types/storage/implementations/storage/with-validation-storage-adapter.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @module Storage
+ */
 import type { Validator } from "../../../utilities/_module";
 import type { IStorageAdapter } from "../../../storage/contracts/_module";
 /**

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

@@ -1,5 +1,4 @@
-export * from "../utilities/_module";
 export * from "../utilities/async/_module";
-export * from "../utilities/async-iterable/_module";
+export * from "../utilities/backof-policies/_module";
 export * from "../utilities/time-span/_module";
 export * from "../utilities/validation/_module";

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

@@ -1,7 +1,10 @@
 export * from "../../utilities/async/_shared";
 export * from "../../utilities/async/abortable/_module";
-export * from "../../utilities/async/backof-policies/_module";
+export * from "../../utilities/async/abortable-iterable/_module";
 export * from "../../utilities/async/delay/_module";
+export * from "../../utilities/async/delay-iterable/_module";
 export * from "../../utilities/async/lazy-promise/_module";
 export * from "../../utilities/async/retry/_module";
+export { retryIterable as unstable_retryIterable } from "../../utilities/async/retry-iterable/_module";
 export * from "../../utilities/async/timeout/_module";
+export * from "../../utilities/async/timeout-iterable/_module";

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

@@ -1,33 +1,33 @@
 /**
- * @module Async
+ * @module Utilities
  */
 /**
- * @group Errors
+ * @group Async
  */
 export declare class AsyncError extends Error {
     constructor(message: string, cause?: unknown);
 }
 /**
- * @group Errors
+ * @group Async
  */
 export declare class AbortAsyncError extends AsyncError {
     constructor(message: string, cause?: unknown);
 }
 /**
- * @group Errors
+ * @group Async
  */
 export declare class TimeoutAsyncError extends AsyncError {
     constructor(message: string, cause?: unknown);
 }
 /**
- * @group Errors
+ * @group Async
  */
 export type RetryAsyncErrorData = {
     cause?: unknown;
     maxAttempts: number;
 };
 /**
- * @group Errors
+ * @group Async
  */
 export declare class RetryAsyncError extends AsyncError {
     readonly maxAttempts: number;

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

@@ -1,10 +1,10 @@
 /**
- * @module Async
+ * @module Utilities
  */
 import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
 /**
  * The <i>abortable</i> function makes a <i>{@link PromiseLike}</i> object abortable.
- * @group Promise utilities
+ * @group Async utilities
  * @throws {AsyncError} {@link AsyncError}
  * @throws {AbortAsyncError} {@link AbortAsyncError}
  * @example

package/dist/types/utilities/async/abortable-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async/abortable-iterable/abortable-iterable";

package/dist/types/utilities/{async-iterable → async}/abortable-iterable/abortable-iterable.d.ts

@@ -1,9 +1,9 @@
 /**
- * @module Async
+ * @module Utilities
  */
 /**
  * The <i>abortableIterable</i> function makes a <i>{@link AsyncIterable}</i> abortable.
- * @group AsyncIterable utilities
+ * @group Async utilities
  * @throws {AsyncError} {@link AsyncError}
  * @throws {AbortAsyncError} {@link AbortAsyncError}
  * @example

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

@@ -1,11 +1,11 @@
 /**
- * @module Async
+ * @module Utilities
  */
 import type { TimeSpan } from "../../../utilities/_module";
 import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
 /**
  * The <i>delay</i> function creates a promise that will be fulfilled after given <i>time</i> and can be aborted by providing <i>abortSignal</i>.
- * @group Promise utilities
+ * @group Async utilities
  * @throws {AsyncError} {@link AsyncError}
  * @throws {AbortAsyncError} {@link AbortAsyncError}
  * @example

package/dist/types/utilities/async/delay-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async/delay-iterable/delay-iterable";

package/dist/types/utilities/{async-iterable → async}/delay-iterable/delay-iterable.d.ts

@@ -1,10 +1,10 @@
 /**
- * @module Async
+ * @module Utilities
  */
 import type { TimeSpan } from "../../../utilities/_module";
 /**
  * The <i>delayIterable</i> function adds delay to each iteration of <i>{@link AsyncIterable}</i> and the delay can be aborted by providing <i>abortSignal</i>.
- * @group AsyncIterable utilities
+ * @group Async utilities
  * @throws {AsyncError} {@link AsyncError}
  * @throws {AbortAsyncError} {@link AbortAsyncError}
  * @example

package/dist/types/utilities/async/lazy-promise/lazy-promise.d.ts

@@ -1,9 +1,9 @@
 /**
- * @module Async
+ * @module Utilities
  */
 /**
  * The <i>LazyPromise</i> class is used for creating lazy <i>{@link PromiseLike}<i> object that will only execute when awaited or when then method is called.
- * @group Promise utilities
+ * @group Async utilities
  * @example
  * ```ts
  * (async () => {
@@ -23,6 +23,6 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
 }
 /**
  * The <i>deferLazyPromise</i> function will execute <i>{@link LazyPromise}</i> without awaiting it.
- * @group Promise utilities
+ * @group Async utilities
  */
 export declare function deferLazyPromise<TValue>(promise: LazyPromise<TValue>): void;

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

@@ -1,12 +1,15 @@
 /**
- * @module Async
+ * @module Utilities
  */
-import type { BackoffPolicy } from "../../../utilities/async/backof-policies/_module";
+import type { BackoffPolicy } from "../../../utilities/backof-policies/_module";
 import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
 import { TimeSpan } from "../../../utilities/_module";
+/**
+ * @group Async utilities
+ */
 export type RetryPolicy = (error: unknown) => boolean;
 /**
- * @group Promise utilities
+ * @group Async utilities
  */
 export type RetrySettings = {
     /**
@@ -25,7 +28,7 @@ export type RetrySettings = {
  * The <i>retry</i> function will retry a async function if it throws an error until given <i>settings.maxAttempts</i>.
  * You can add timeout for each retry by passing <i>settings.retryTimeout</i> and <i>settings.abortSignal</i> for aborting it on your own.
  * You can also customize the retry policy by passing <i>settings.retryPolicy</i> and custom backof policy by passing <i>settings.backoffPolicy</i>.
- * @group Promise utilities
+ * @group Async utilities
  * @throws {AsyncError} {@link AsyncError}
  * @throws {AbortAsyncError} {@link AbortAsyncError}
  * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}

package/dist/types/utilities/async/retry-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async/retry-iterable/retry-iterable";

package/dist/types/utilities/{async-iterable → async}/retry-iterable/retry-iterable.d.ts

@@ -3,7 +3,7 @@ import type { RetrySettings } from "../../../utilities/async/retry/_module";
  * The <i>retryIterable</i> function will retry each iteration of {@link AsyncIterable} if it throws an error until given <i>settings.maxAttempts</i>.
  * You can add timeout for each retry by passing <i>settings.retryTimeout</i> and <i>settings.abortSignal</i> for aborting it on your own.
  * You can also customize the retry policy by passing <i>settings.retryPolicy</i> and custom backof policy by passing <i>settings.backoffPolicy</i>.
- * @group AsyncIterable utilities
+ * @group Async utilities
  * @throws {AsyncError} {@link AsyncError}
  * @throws {AbortAsyncError} {@link AbortAsyncError}
  * @throws {RetryAsyncError} {@link RetryAsyncError}

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

@@ -1,11 +1,11 @@
 /**
- * @module Async
+ * @module Utilities
  */
 import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
 import type { TimeSpan } from "../../../utilities/_module";
 /**
  * The <i>timeout</i> function makes a <i>{@link PromiseLike}</i> object abort after a given <i>time</i> and you can also abort it on your own by passing <i>abortSignal</i>.
- * @group Promise utilities
+ * @group Async utilities
  * @throws {AsyncError} {@link AsyncError}
  * @throws {AbortAsyncError} {@link AbortAsyncError}
  * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}

package/dist/types/utilities/async/timeout-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async/timeout-iterable/timeout-iterable";

package/dist/types/utilities/{async-iterable → async}/timeout-iterable/timeout-iterable.d.ts

@@ -1,10 +1,10 @@
 /**
- * @module Async
+ * @module Utilities
  */
 import type { TimeSpan } from "../../../utilities/_module";
 /**
  * The <i>timeoutIterable</i> function makes a <i>{@link AsyncIterable}</i> abort after a given <i>time</i> and you can also abort it on your own by passing <i>abortSignal</i>.
- * @group AsyncIterable utilities
+ * @group Async utilities
  * @throws {AsyncError} {@link AsyncError}
  * @throws {AbortAsyncError} {@link AbortAsyncError}
  * @example

package/dist/types/utilities/backof-policies/_module.d.ts

@@ -0,0 +1,5 @@
+export { type BackoffPolicy } from "../../utilities/backof-policies/_shared";
+export * from "../../utilities/backof-policies/constant-backoff-policy/_module";
+export * from "../../utilities/backof-policies/exponential-backoff-policy/_module";
+export * from "../../utilities/backof-policies/linear-backoff-policy/_module";
+export * from "../../utilities/backof-policies/polynomial-backoff-policy/_module";

package/dist/types/utilities/{async/backof-policies → backof-policies}/_shared.d.ts

@@ -1,9 +1,9 @@
 /**
- * @module Async
+ * @module Utilities
  */
 /**
- * @group Backoff policies
  * @returns Amount milliseconds to wait
+ * @group Backoff policies
  */
 export type BackoffPolicy = (attempt: number, error: unknown) => number;
 /**

package/dist/types/utilities/backof-policies/constant-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/backof-policies/constant-backoff-policy/constant-backoff-policy";

package/dist/types/utilities/{async/backof-policies → backof-policies}/constant-backoff-policy/constant-backoff-policy.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Async
+ * @module Utilities
  */
-import { TimeSpan } from "../../../../utilities/_module";
-import { type BackoffPolicy } from "../../../../utilities/async/backof-policies/_shared";
+import { TimeSpan } from "../../../utilities/_module";
+import { type BackoffPolicy } from "../../../utilities/backof-policies/_shared";
 /**
  * @group Backoff policies
  */

package/dist/types/utilities/backof-policies/exponential-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/backof-policies/exponential-backoff-policy/exponential-backoff-policy";

package/dist/types/utilities/{async/backof-policies → backof-policies}/exponential-backoff-policy/exponential-backoff-policy.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Async
+ * @module Utilities
  */
-import { TimeSpan } from "../../../../utilities/_module";
-import type { BackoffPolicy } from "../../../../utilities/async/backof-policies/_shared";
+import { TimeSpan } from "../../../utilities/_module";
+import type { BackoffPolicy } from "../../../utilities/backof-policies/_shared";
 /**
  * @group Backoff policies
  */

package/dist/types/utilities/backof-policies/linear-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/backof-policies/linear-backoff-policy/linear-backoff-policy";

package/dist/types/utilities/{async/backof-policies → backof-policies}/linear-backoff-policy/linear-backoff-policy.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Async
+ * @module Utilities
  */
-import { TimeSpan } from "../../../../utilities/_module";
-import type { BackoffPolicy } from "../../../../utilities/async/backof-policies/_shared";
+import { TimeSpan } from "../../../utilities/_module";
+import type { BackoffPolicy } from "../../../utilities/backof-policies/_shared";
 /**
  * @group Backoff policies
  */

package/dist/types/utilities/backof-policies/polynomial-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/backof-policies/polynomial-backoff-policy/polynomial-backoff-policy";

package/dist/types/utilities/{async/backof-policies → backof-policies}/polynomial-backoff-policy/polynomial-backoff-policy.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Async
+ * @module Utilities
  */
-import { TimeSpan } from "../../../../utilities/_module";
-import type { BackoffPolicy } from "../../../../utilities/async/backof-policies/_shared";
+import { TimeSpan } from "../../../utilities/_module";
+import type { BackoffPolicy } from "../../../utilities/backof-policies/_shared";
 /**
  * @group Backoff policies
  */

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

@@ -1,9 +1,10 @@
 /**
- * @module Time
+ * @module Utilities
  */
 /**
  * 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 {
     private readonly milliseconds;

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

@@ -1,12 +1,32 @@
+/**
+ * @module Utilities
+ */
 import { type ZodSchema, type infer as Infer } from "zod";
 /**
- * @module Validation
+ * @group Validation
  */
 export declare class ValidationError extends Error {
     constructor(message: string, cause: unknown);
 }
 /**
+ * @group Validation
  * @throws {ValidationError} {@link ValidationError}
  */
 export type Validator<TType> = (value: unknown) => TType;
+/**
+ * @group Validation
+ * @example
+ * ```ts
+ * import { zodValidator } from "@daiso-tech/core";
+ * import { z } from "zod";
+ *
+ * const validator = zodValidator(z.string().trim());
+ *
+ * // Will throw error
+ * validator(2);
+ *
+ * const validatedValue = validator(" a ");
+ * // Will be "a"
+ * ```
+ */
 export declare function zodValidator<TSchema extends ZodSchema>(schema: TSchema): Validator<Infer<TSchema>>;

package/package.json

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

package/dist/cjs/serializer/_module.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../src/serializer/_module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8FAA4E;AAC5E,0FAAwE;AACxE,wFAAsE;AACtE,sFAAoE;AACpE,6FAA2E"}