@daiso-tech/core 0.21.0 → 0.22.0

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

@@ -4,33 +4,23 @@
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import type { IDeinitizable } from "../../../../utilities/_module";
 import { type TimeSpan, type IInitizable } from "../../../../utilities/_module";
-import type { MongodbCacheAdapterSettings } from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter-settings";
-import { MongodbCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter-settings";
+import type { CollectionOptions, Db } from "mongodb";
+import type { ISerde } from "../../../../serde/contracts/_module";
+/**
+ * @group Adapters
+ */
+export type MongodbCacheAdapterSettings = {
+    database: Db;
+    serde: ISerde<string>;
+    rootGroup: string;
+    collectionName?: string;
+    collectionSettings?: CollectionOptions;
+};
 /**
  * To utilize the <i>MongodbCacheAdapter</i>, you must install the <i>"mongodb"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
 export declare class MongodbCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
-    /**
-     * @example
-     * ```ts
-     * import { MongodbCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
-     * import { MongoClient } from "mongodb";
-     *
-     * (async () => {
-     *   const client = await MongoClient.connect("YOUR_MONGODB_CONNECTION_STRING");
-     *   const cacheAdapter = new MongodbCacheAdapter(
-     *     MongodbCacheAdapter
-     *       .settings()
-     *       .setDatabase(client.db("database"))
-     *       .setSerde(new SuperJsonSerde())
-     *       .setRootGroup("@global")
-     *       .build()
-     *   );
-     * })();
-     * ```
-     */
-    static settings<TSettings extends Partial<MongodbCacheAdapterSettings>>(): MongodbCacheAdapterSettingsBuilder<TSettings>;
     private static isMongodbIncrementError;
     private readonly mongodbSerde;
     private readonly group;
@@ -38,6 +28,7 @@ export declare class MongodbCacheAdapter<TType = unknown> implements ICacheAdapt
     private readonly database;
     private readonly collection;
     private readonly collectionName;
+    private readonly collectionSettings?;
     /**
      * @example
      * ```ts
@@ -53,25 +44,23 @@ export declare class MongodbCacheAdapter<TType = unknown> implements ICacheAdapt
      *     serde,
      *     rootGroup: "@global"
      *   });
-     *
      *   await cacheAdapter.init();
-     *   await cacheAdapter.add("a", 1);
-     *   await cacheAdapter.deInit();
      * })();
      * ```
      */
-    constructor({ collectionName, collectionSettings, database, serde, rootGroup, }: MongodbCacheAdapterSettings);
+    constructor(settings: MongodbCacheAdapterSettings);
     getGroup(): string;
     withGroup(group: string): ICacheAdapter<TType>;
     /**
      * 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>;
-    exists(key: string): Promise<boolean>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;

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

@@ -10,7 +10,6 @@ import type { TimeSpan } from "../../../../utilities/_module";
 export declare class NoOpCacheAdapter<TType = unknown> implements ICacheAdapter<TType> {
     getGroup(): string;
     withGroup(_group: string): ICacheAdapter<TType>;
-    exists(_key: string): Promise<boolean>;
     get(_key: string): Promise<TType | null>;
     add(_key: string, _value: TType, _ttl: TimeSpan | null): Promise<boolean>;
     update(_key: string, _value: TType): Promise<boolean>;

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

@@ -1,2 +1 @@
-export * from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter-settings";
 export * from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter";

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

@@ -3,36 +3,26 @@
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import { type TimeSpan } from "../../../../utilities/_module";
-import { type Result } from "ioredis";
-import type { RedisCacheAdapterSettings } from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter-settings";
-import { RedisCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter-settings";
+import { type Redis, type Result } from "ioredis";
+import type { ISerde } from "../../../../serde/contracts/_module";
 declare module "ioredis" {
     interface RedisCommander<Context> {
         daiso_cache_increment(key: string, number: string): Result<number, Context>;
     }
 }
+/**
+ * @group Adapters
+ */
+export type RedisCacheAdapterSettings = {
+    database: Redis;
+    serde: ISerde<string>;
+    rootGroup: string;
+};
 /**
  * To utilize the <i>RedisCacheAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
 export declare class RedisCacheAdapter<TType = unknown> implements ICacheAdapter<TType> {
-    /**
-     * @example
-     * ```ts
-     * import { RedisCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
-     * import Redis from "ioredis";
-     *
-     * const cacheAdapter = new RedisCacheAdapter(
-     *   RedisCacheAdapter
-     *     .settings()
-     *     .setDatabase(new Redis("YOUR_REDIS_CONNECTION_STRING"))
-     *     .setSerde(new SuperJsonSerde())
-     *     .setRootGroup("@global")
-     *     .build()
-     * );
-     * ```
-     */
-    static settings<TSettings extends Partial<RedisCacheAdapterSettings>>(): RedisCacheAdapterSettingsBuilder<TSettings>;
     private static isRedisTypeError;
     private readonly baseSerde;
     private readonly redisSerde;
@@ -53,10 +43,9 @@ export declare class RedisCacheAdapter<TType = unknown> implements ICacheAdapter
      * });
      * ```
      */
-    constructor({ database, serde, rootGroup }: RedisCacheAdapterSettings);
-    private getGroupName;
+    constructor(settings: RedisCacheAdapterSettings);
+    private getPrefix;
     private withPrefix;
-    exists(key: string): Promise<boolean>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;

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

@@ -1,2 +1 @@
-export * from "../../../../cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter-settings";
 export * from "../../../../cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter";

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

@@ -3,30 +3,25 @@
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import type { TimeSpan, IInitizable, IDeinitizable } from "../../../../utilities/_module";
-import type { SqliteCacheAdapterSettings } from "../../../../cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter-settings";
-import { SqliteCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter-settings";
+import type { SqliteDatabase } from "kysely";
+import type { ISerde } from "../../../../serde/contracts/_module";
+/**
+ * @group Adapters
+ */
+export type SqliteCacheAdapterSettings = {
+    database: SqliteDatabase;
+    tableName?: string;
+    serde: ISerde<string>;
+    enableTransactions?: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+    rootGroup: string;
+};
 /**
  * To utilize the <i>SqliteCacheAdapter</i>, you must install the <i>"better-sqlite3"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
 export declare class SqliteCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
-    /**
-     * @example
-     * ```ts
-     * import { SqliteCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
-     * import Sqlite from "better-sqlite3";
-     *
-     * const cacheAdapter = new SqliteCacheAdapter(
-     *   SqliteCacheAdapter
-     *     .settings()
-     *     .setDatabase(new Sqlite("local.db"))
-     *     .setSerde(new SuperJsonSerde())
-     *     .setRootGroup("@global")
-     *     .build()
-     * );
-     * ```
-     */
-    static settings<TSettings extends Partial<SqliteCacheAdapterSettings>>(): SqliteCacheAdapterSettingsBuilder<TSettings>;
     private readonly cacheAdapter;
     /**
      * @example
@@ -34,18 +29,15 @@ export declare class SqliteCacheAdapter<TType = unknown> implements ICacheAdapte
      * import { SqliteCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
      * import Sqlite from "better-sqlite3";
      *
-     * const database = new Sqlite("local.db");
-     * const serde = new SuperJsonSerde();
-     * const cacheAdapter = new SqliteCacheAdapter({
-     *   database,
-     *   serde,
-     *   rootGroup: "@global"
-     * });
-     *
      * (async () => {
+     *   const database = new Sqlite("local.db");
+     *   const serde = new SuperJsonSerde();
+     *   const cacheAdapter = new SqliteCacheAdapter({
+     *     database,
+     *     serde,
+     *     rootGroup: "@global"
+     *   });
      *   await cacheAdapter.init();
-     *   await cacheAdapter.add("a", 1);
-     *   await cacheAdapter.deInit();
      * })();
      * ```
      */
@@ -55,13 +47,14 @@ export declare class SqliteCacheAdapter<TType = unknown> implements ICacheAdapte
     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>;
-    exists(key: string): Promise<boolean>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;

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

@@ -1,2 +1 @@
-export * from "../../../../cache/implementations/derivables/cache/cache-settings";
 export * from "../../../../cache/implementations/derivables/cache/cache";

package/dist/types/cache/implementations/derivables/cache/cache.d.ts

@@ -2,34 +2,53 @@
  * @module Cache
  */
 import type { CacheEvents, WithTtlValue } from "../../../../cache/contracts/_module";
-import { type ICache } from "../../../../cache/contracts/_module";
+import { type ICache, type ICacheAdapter } from "../../../../cache/contracts/_module";
 import { type IGroupableCache } from "../../../../cache/contracts/_module";
 import type { AsyncLazyable, GetOrAddValue, OneOrMore } from "../../../../utilities/_module";
 import type { TimeSpan } from "../../../../utilities/_module";
+import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module";
 import { LazyPromise } from "../../../../async/_module";
-import type { Listener, Unsubscribe, EventClass, EventInstance } from "../../../../event-bus/contracts/_module";
-import type { CacheSettings } from "../../../../cache/implementations/derivables/cache/cache-settings";
-import { CacheSettingsBuilder } from "../../../../cache/implementations/derivables/cache/cache-settings";
+import type { IGroupableEventBus, Listener, Unsubscribe, EventClass, EventInstance } from "../../../../event-bus/contracts/_module";
 /**
- * <i>Cache</i> class can be derived from any <i>{@link ICacheAdapter}</i>.
  * @group Derivables
  */
-export declare class Cache<TType = unknown> implements IGroupableCache<TType> {
+export type CacheSettings = {
+    adapter: ICacheAdapter<any>;
     /**
-     * @example
-     * ```ts
-     * import { Cache, MemoryCacheAdapter, TimeSpan, SuperJsonSerde } from "@daiso-tech/core";
-     *
-     * const cache = new Cache(
-     *   Cache
-     *     .settings()
-     *     .setAdapter(new MemoryCacheAdapter({ rootGroup: "@global" }))
-     *     .setEventBus(new EventBus(new MemoryEventBusAdapter({ rootGroup: "@global" })))
-     *     .build()
-     * );
-     * ```
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
      */
-    static settings<TSettings extends Partial<CacheSettings>>(): CacheSettingsBuilder<TSettings>;
+    eventBus?: IGroupableEventBus<any>;
+    /**
+     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     * @default {null}
+     */
+    defaultTtl?: TimeSpan | null;
+    /**
+     * 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;
+};
+/**
+ * <i>Cache</i> class can be derived from any <i>{@link ICacheAdapter}</i>.
+ * @group Derivables
+ */
+export declare class Cache<TType = unknown> implements IGroupableCache<TType> {
     private static defaultRetryPolicy;
     private readonly groupdEventBus;
     private readonly eventBus;
@@ -60,14 +79,6 @@ export declare class Cache<TType = unknown> implements IGroupableCache<TType> {
      */
     constructor(settings: CacheSettings);
     private createLayPromise;
-    private createKeyFoundEvent;
-    private createKeyNotFoundEvent;
-    private createKeyAddedEvent;
-    private createKeyUpdatedEvent;
-    private createKeyRemovedEvent;
-    private createKeysClearedEvent;
-    private createKeyIncrementedEvent;
-    private createKeyDecrementedEvent;
     addListener<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
     addListenerMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
     removeListener<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;

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

@@ -1,2 +1 @@
-export * from "../../../../cache/implementations/derivables/cache-factory/cache-factory-settings";
 export * from "../../../../cache/implementations/derivables/cache-factory/cache-factory";

package/dist/types/cache/implementations/derivables/cache-factory/cache-factory.d.ts

@@ -1,38 +1,72 @@
 /**
  * @module Cache
  */
+import type { IGroupableEventBus } from "../../../../event-bus/contracts/_module";
+import type { ICacheAdapter } from "../../../../cache/contracts/_module";
 import { type ICacheFactory, type IGroupableCache } from "../../../../cache/contracts/_module";
-import type { CacheFactorySettings } from "../../../../cache/implementations/derivables/cache-factory/cache-factory-settings";
-import { CacheFactorySettingsBuilder } from "../../../../cache/implementations/derivables/cache-factory/cache-factory-settings";
+import type { OneOrMore, TimeSpan } from "../../../../utilities/_module";
+import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module";
+import type { IFlexibleSerde } from "../../../../serde/contracts/_module";
 /**
  * @group Derivables
  */
-export declare class CacheFactory<TAdapters extends string = string> implements ICacheFactory<TAdapters> {
+export type CacheAdapters<TAdapters extends string> = Partial<Record<TAdapters, ICacheAdapter<any>>>;
+/**
+ * @group Derivables
+ */
+export type CacheFactorySettings<TAdapters extends string = string> = {
     /**
-     * @example
-     * ```ts
-     * import { CacheFactory, SuperJsonSerde. MemoryCacheAdapter, RedisCacheAdapter, EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
-     * import Redis from "ioredis";
-     *
-     * const serde = new SuperJsonSerde();
-     * const cacheFactory = new CacheFactory(
-     *   CacheFactory
-     *     .settings()
-     *     .setEventBus(new EventBus(new MemoryEventBusAdapter({ rootGroup: "@global" })))
-     *     .setAdapter("memory", new MemoryCacheAdapter({
-     *       rootGroup: "@global"
-     *     }))
-     *     .setAdapter("redis", new RedisCacheAdapter({
-     *       client: new Redis("YOUR_REDIS_CONNECTION"),
-     *       serde,
-     *       rootGroup: "@global"
-     *     }))
-     *     .setDefaultAdapter("memory")
-     *     .build()
-     * );
-     * ```
+     * You can pass one or more <i>{@link IFlexibleSerde}</i> that will be used to register all <i>{@link IGroupableCache}</i> related errors and events.
+     * @default {true}
+     */
+    serde: OneOrMore<IFlexibleSerde>;
+    /**
+     * If set to true, all <i>{@link IGroupableCache}</i> related errors will be registered with the specified <i>IFlexibleSerde</i> during constructor initialization.
+     * This ensures that all <i>{@link IGroupableCache}</i> related errors will be serialized correctly.
+     * @default {true}
+     */
+    shouldRegisterErrors?: boolean;
+    /**
+     * If set to true, all <i>{@link IGroupableCache}</i> related events will be registered with the specified <i>IFlexibleSerde</i> during constructor initialization.
+     * This ensures that all <i>{@link IGroupableCache}</i> related events will be serialized correctly.
+     * @default {true}
      */
-    static settings<TAdapters extends string, TSettings extends CacheFactorySettings<TAdapters>>(): CacheFactorySettingsBuilder<TSettings>;
+    shouldRegisterEvents?: boolean;
+    adapters: CacheAdapters<TAdapters>;
+    defaultAdapter?: NoInfer<TAdapters>;
+    /**
+     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     */
+    defaultTtl?: TimeSpan;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     */
+    eventBus: IGroupableEventBus<any>;
+    /**
+     * 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 CacheFactory<TAdapters extends string = string> implements ICacheFactory<TAdapters> {
     private readonly cacheRecord;
     private readonly defaultAdapter?;
     private readonly eventBus;

package/dist/types/collection/contracts/async-collection.contract.d.ts

@@ -1485,6 +1485,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      *   // 3
      * }
      * ```
+     * You can pass a function as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1493,10 +1494,11 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      * async function main(collection: IAsyncCollection<number>): Promise<void> {
      *   await collection
      *     .append([1, 2, 3, 4])
-     *     .firstOr(-1, item => item > 10);
+     *     .firstOr(() => -1, item => item > 10);
      *   // -1
      * }
      * ```
+     * You can pass an async function as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1505,7 +1507,20 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      * async function main(collection: IAsyncCollection<number>): Promise<void> {
      *   await collection
      *     .append([1, 2, 3, 4])
-     *     .firstOr(() => -1, item => item > 10);
+     *     .firstOr(async () => -1, item => item > 10);
+     *   // -1
+     * }
+     * ```
+     * You can pass a <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { IAsyncCollection, ICache } from "@daiso-tech/core";
+     *
+     * // Asume the inputed collection is empty.
+     * async function main(collection: IAsyncCollection<number>, cache: ICache<number>): Promise<void> {
+     *   await collection
+     *     .append([1, 2, 3, 4])
+     *     .firstOr(cache.get("a"), item => item > 10);
      *   // -1
      * }
      * ```
@@ -1621,6 +1636,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      *   // 3
      * }
      * ```
+     * You can pass a function as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1629,10 +1645,11 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      * async function main(collection: IAsyncCollection<number>): Promise<void> {
      *   await collection
      *     .append([1, 2, 3, 4])
-     *     .lastOr(-1, item => item > 10);
+     *     .lastOr(() => -1, item => item > 10);
      *   // -1
      * }
      * ```
+     * You can pass an async function as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1641,7 +1658,20 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      * async function main(collection: IAsyncCollection<number>): Promise<void> {
      *   await collection
      *     .append([1, 2, 3, 4])
-     *     .lastOr(() => -1, item => item > 10);
+     *     .lastOr(async () => -1, item => item > 10);
+     *   // -1
+     * }
+     * ```
+     * You can pass a <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { IAsyncCollection, ICache } from "@daiso-tech/core";
+     *
+     * // Asume the inputed collection is empty.
+     * async function main(collection: IAsyncCollection<number>, cache: ICache<number>): Promise<void> {
+     *   await collection
+     *     .append([1, 2, 3, 4])
+     *     .lastOr(cache.get("a"), item => item > 10);
      *   // -1
      * }
      * ```
@@ -1733,6 +1763,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      *   // 1
      * }
      * ```
+     * You can pass a function as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1741,10 +1772,11 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      * async function main(collection: IAsyncCollection<number>): Promise<void> {
      *   await collection
      *     .append([1, 2, 3, 4])
-     *     .beforeOr(-1, item => item === 1);
+     *     .beforeOr(() => -1, item => item === 1);
      *   // -1
      * }
      * ```
+     * You can pass an async function as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1753,7 +1785,20 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      * async function main(collection: IAsyncCollection<number>): Promise<void> {
      *   await collection
      *     .append([1, 2, 3, 4])
-     *     .beforeOr(() => -1, item => item === 1);
+     *     .beforeOr(async () => -1, item => item === 1);
+     *   // -1
+     * }
+     * ```
+     * You can pass a <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { IAsyncCollection, ICache } from "@daiso-tech/core";
+     *
+     * // Asume the inputed collection is empty.
+     * async function main(collection: IAsyncCollection<number>, cache: ICache<number>): Promise<void> {
+     *   await collection
+     *     .append([1, 2, 3, 4])
+     *     .beforeOr(cache.get("a"), item => item > 10);
      *   // -1
      * }
      * ```
@@ -1833,6 +1878,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      *   // 3
      * }
      * ```
+     * You can pass a function as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1841,10 +1887,11 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      * async function main(collection: IAsyncCollection<number>): Promise<void> {
      *   await collection
      *     .append([1, 2, 3, 4])
-     *     .afterOr(-1, item => item === 4);
+     *     .afterOr(() => -1, item => item === 4);
      *   // -1
      * }
      * ```
+     * You can pass an async function as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1853,7 +1900,20 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      * async function main(collection: IAsyncCollection<number>): Promise<void> {
      *   await collection
      *     .append([1, 2, 3, 4])
-     *     .afterOr(() => -1, item => item === 4);
+     *     .afterOr(async () => -1, item => item === 4);
+     *   // -1
+     * }
+     * ```
+     * You can pass a <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { IAsyncCollection, ICache } from "@daiso-tech/core";
+     *
+     * // Asume the inputed collection is empty.
+     * async function main(collection: IAsyncCollection<number>, cache: ICache<number>): Promise<void> {
+     *   await collection
+     *     .append([1, 2, 3, 4])
+     *     .afterOr(cache.get("a"), item => item > 10);
      *   // -1
      * }
      * ```

package/dist/types/event-bus/contracts/_shared.d.ts

@@ -1,7 +1,6 @@
 /**
  * @module EventBus
  */
-import type { ISerializable } from "../../serde/contracts/_module";
 import type { Promisable } from "../../utilities/_module";
 /**
  * @group Contracts
@@ -10,7 +9,7 @@ export type Listener<TEvent> = (event: TEvent) => Promisable<void>;
 /**
  * @group Contracts
  */
-export declare abstract class BaseEvent<TData extends Record<string, unknown> = Record<string, unknown>> implements ISerializable<TData> {
-    static deserialize(_serializedEvent: any): BaseEvent;
-    abstract serialize(): TData;
+export declare abstract class BaseEvent<TFields extends Record<string, unknown> = Record<string, unknown>> {
+    readonly fields: TFields;
+    constructor(fields: TFields);
 }

package/dist/types/event-bus/contracts/event-bus-adapter.contract.d.ts

@@ -5,7 +5,7 @@ import type { Listener } from "../../event-bus/contracts/_shared";
 import type { BaseEvent } from "../../event-bus/contracts/_shared";
 /**
  * The <i>IEventBusAdapter</i> contract defines a way for dispatching and listening to events independent of underlying technology.
- * This interface is not meant to be used directly, instead you should use <i>IEventBus</i>
+ * This contract is not meant to be used directly, instead you should use <i>IEventBus</i>
  * @group Contracts
  */
 export type IEventBusAdapter = {