@tstdl/base 0.92.167 → 0.93.0

package/utils/function/memoize.js

@@ -1,7 +1,8 @@
 import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
 import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
 import { createAccessorDecorator } from '../../reflection/index.js';
-import { assertDefinedPass, isDefined } from '../type-guards.js';
+import { assertDefinedPass, isDefined } from '../../utils/type-guards.js';
+import { hasOwnProperty } from '../object/object.js';
 /**
  * Memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
  * @param fn function memoize
@@ -46,47 +47,105 @@ export function memoizeClassSingle(type, options = {}) {
     return memoizeSingle((parameter) => new type(parameter), options);
 }
 /**
- * Memoizes an accessor (getter)
+ * Memoizes the result of a class getter, ensuring the getter's logic is
+ * executed only once per instance.
+ *
+ * Subsequent accesses to the getter will return the cached value.
+ *
+ * @param strategy The memoization strategy to use.
+ * - `attach`: (Default) Uses `Symbol` properties to store the cached value directly on the class instance. This is generally faster but adds hidden properties to the instance.
+ * - `weak-map`: Uses a `WeakMap` to store the cached value, with the class instance as the key. This avoids adding any properties to the instance, keeping it "clean".
  *
  * @example
  * ```typescript
- * class MyClass {
+ * class MyEvaluator {
  *   @Memoize()
- *   get myValue() {
- *     // expensive calculation
- *     return 123;
+ *   get result() {
+ *     // This expensive result creation only happens once per instance.
+ *     return this.computeExpensiveResult();
  *   }
  * }
+ *
+ * const service = new MyEvaluator();
+ * const s1 = service.result; // Logs "Creating new result..."
+ * const s2 = service.result; // Does not log anything, returns cached result.
+ * console.log(s1 === s2); // true
  * ```
  *
  * @remarks
- * The getter will be called only once for each instance of the class.
+ * If the decorated property has a corresponding setter, calling the setter will
+ * invalidate the cache. The getter will be re-evaluated on its next access.
+ *
+ * @returns An accessor decorator function.
  */
-export function Memoize() {
-    const cache = new WeakMap();
+export function Memoize(strategy = 'attach') {
     return createAccessorDecorator({
         handler: (data) => {
             const getter = assertDefinedPass(data.descriptor.get, 'Memoize requires an getter for accessors.'); // eslint-disable-line @typescript-eslint/unbound-method
             const setter = data.descriptor.set; // eslint-disable-line @typescript-eslint/unbound-method
-            function cachedGetter() {
-                if (cache.has(this)) {
-                    return cache.get(this); // eslint-disable-line @typescript-eslint/no-unsafe-return
-                }
-                const value = getter.call(this);
-                cache.set(this, value);
-                return value; // eslint-disable-line @typescript-eslint/no-unsafe-return
+            if (strategy == 'attach') {
+                return createAttachMemoizeHandler(data.propertyKey, getter, setter);
             }
-            function cachedSetter(value) {
-                setter?.call(this, value);
-                cache.delete(this);
+            else {
+                return createWeakMapMemoizeHandler(getter, setter);
             }
-            return {
-                get: cachedGetter,
-                set: isDefined(setter) ? cachedSetter : undefined,
-            };
+            ;
         },
     });
 }
+function createAttachMemoizeHandler(propertyKey, getter, setter) {
+    const stateKey = Symbol(`memoization[${String(propertyKey)}]`);
+    function getState(instance) {
+        if (!hasOwnProperty(instance, stateKey)) {
+            Object.defineProperty(instance, stateKey, {
+                value: { hasValue: false, value: undefined },
+                writable: false,
+                configurable: true,
+                enumerable: false,
+            });
+        }
+        return instance[stateKey];
+    }
+    function cachedGetter() {
+        const state = getState(this);
+        if (state.hasValue) {
+            return state.value;
+        }
+        const value = getter.call(this);
+        state.hasValue = true;
+        state.value = value;
+        return value;
+    }
+    function cachedSetter(value) {
+        setter.call(this, value);
+        if (hasOwnProperty(this, stateKey)) {
+            this[stateKey].hasValue = false;
+            this[stateKey].value = undefined;
+        }
+    }
+    return {
+        get: cachedGetter,
+        set: isDefined(setter) ? cachedSetter : undefined,
+    };
+}
+function createWeakMapMemoizeHandler(getter, setter) {
+    const cache = new WeakMap();
+    function cachedGetter() {
+        if (cache.has(this)) {
+            return cache.get(this);
+        }
+        const value = getter.call(this);
+        cache.set(this, value);
+        return value;
+    }
+    ;
+    function cachedSetter(value) {
+        setter.call(this, value);
+        cache.delete(this);
+    }
+    ;
+    return { get: cachedGetter, set: isDefined(setter) ? cachedSetter : undefined };
+}
 function getMemoizedName(fn) {
     return `memoized${fn.name[0]?.toUpperCase() ?? ''}${fn.name.slice(1)}`;
 }

package/utils/index.d.ts

@@ -49,6 +49,7 @@ export * from './sort.js';
 export * from './throw.js';
 export * from './timer.js';
 export * from './timing.js';
+export * from './try-chain.js';
 export * from './try-ignore.js';
 export * from './type-guards.js';
 export * from './type-of.js';

package/utils/index.js

@@ -49,6 +49,7 @@ export * from './sort.js';
 export * from './throw.js';
 export * from './timer.js';
 export * from './timing.js';
+export * from './try-chain.js';
 export * from './try-ignore.js';
 export * from './type-guards.js';
 export * from './type-of.js';

package/utils/object/dereference.d.ts

@@ -1,34 +1,66 @@
 import { type JsonPathInput } from '../../json-path/index.js';
+type CachedDereferencer<TOptional extends boolean | undefined> = TOptional extends true ? (<T = unknown>(object: object, reference: JsonPathInput) => T | undefined) : (<T = unknown>(object: object, reference: JsonPathInput) => T);
 export type DereferenceOptions = {
+    /**
+     * If true, the dereferencer will not throw an error if an intermediate
+     * property is null or undefined, and will return `undefined` instead.
+     * @default false
+     */
     optional?: boolean;
+    /**
+     * Method to use for dereferencing.
+     * - 'loop': Uses a simple loop to traverse the object. More robust, works in all environments.
+     * - 'function': Dynamically generates a function for dereferencing. Slow to compile, but faster at runtime - may not work in all environments. Automatically falls back to 'loop' if generation fails.
+     *
+     * @default 'loop' for `dereference`; 'function' for `compileDereferencer` and `getCachedDereference`
+     */
+    method?: 'loop' | 'function';
 };
 /**
- * Compiles a dereferencer for a specific reference
- * @param object object to dereference
- * @param reference path to property in dot notation or {@link JsonPath}
- * @returns referenced value
+ * Compiles a dereferencer for a specific reference path.
+ * This is the most performant option if you need to access the same path on many different objects.
+ *
+ * @param reference - Path to a property, e.g., 'a.b.c' or ['a', 'b', 'c'].
+ * @param options - Dereferencing options.
+ * @returns A specialized function to retrieve a value from an object.
  */
-export declare function compileDereferencer(reference: JsonPathInput, options?: DereferenceOptions): (object: object) => unknown;
+export declare function compileDereferencer<T = unknown>(reference: JsonPathInput, options: DereferenceOptions & {
+    optional: true;
+}): (object: object) => T | undefined;
+export declare function compileDereferencer<T = unknown>(reference: JsonPathInput, options?: DereferenceOptions): (object: object) => T;
 /**
- * Dereference a reference
+ * Dereferences a value from an object using a reference path.
  *
- * @description useful if you dereference a reference a few times at most
+ * @description
+ * Best for one-off use. For repeated access, use `compileDereferencer` or `getCachedDereference`.
  *
- * also take a look at {@link getCachedDereference} and {@link compileDereferencer} if you need to dereference multiple times
- * @param object object to dereference
- * @param reference path to property in dot notation or {@link JsonPath}
- * @returns referenced value
+ * @param object - The object to access.
+ * @param reference - Path to a property, e.g., 'a.b.c' or ['a', 'b', 'c'].
+ * @param options - Dereferencing options.
+ * @returns The referenced value.
  */
-export declare function dereference(object: object, reference: JsonPathInput, options?: DereferenceOptions): unknown;
+export declare function dereference<T = unknown>(object: object, reference: JsonPathInput, options: DereferenceOptions & {
+    optional: true;
+}): T | undefined;
+export declare function dereference<T = unknown>(object: object, reference: JsonPathInput, options?: DereferenceOptions): T;
 /**
- * Cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
+ * Returns a cached dereferencing function.
+ * The function caches the compiled dereferencer for each path, but not the resulting values.
  *
  * @description
- * useful if you dereference multiple references, each multiple times
+ * Ideal for applications that frequently access various, but repeating, paths on different objects.
+ *
+ * @example
+ * const optionalDeref = getCachedDereference({ optional: true });
+ * const value = optionalDeref(myObj, 'a.b.c'); // value is T | undefined
+ *
+ * const requiredDeref = getCachedDereference();
+ * const value2 = requiredDeref(myObj, 'a.b.c'); // value2 is T
  *
- * also take a look at {@link dereference} and {@link compileDereferencer} for other use cases
- * @param object object to dereference
- * @param reference path to property in dot notation or {@link JsonPath}
- * @returns referenced value
+ * @param options - Dereferencing options. These options are fixed for the lifetime of the returned function.
+ * @returns A function that takes an object and a reference and returns the value.
  */
-export declare function getCachedDereference(options?: DereferenceOptions): typeof dereference;
+export declare function getCachedDereference<TOptional extends boolean | undefined>(options?: DereferenceOptions & {
+    optional: TOptional;
+}): CachedDereferencer<TOptional>;
+export {};

package/utils/object/dereference.js

@@ -1,62 +1,71 @@
 import { JsonPath } from '../../json-path/index.js';
 import { memoizeSingle } from '../function/memoize.js';
-import { isNullOrUndefined } from '../type-guards.js';
-/**
- * Compiles a dereferencer for a specific reference
- * @param object object to dereference
- * @param reference path to property in dot notation or {@link JsonPath}
- * @returns referenced value
- */
-export function compileDereferencer(reference, options) {
-    const nodes = JsonPath.from(reference).nodes;
-    if (options?.optional == true) {
-        return function optionalDereferencer(object) {
-            let target = object;
-            for (let i = 0; i < nodes.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
-                if (isNullOrUndefined(target)) {
-                    return undefined;
-                }
-                target = target[nodes[i]];
-            }
-            return target;
-        };
-    }
+import { isNullOrUndefined, isSymbol } from '../type-guards.js';
+function compileLoopDereferencer(nodes, isOptional) {
     return function dereferencer(object) {
         let target = object;
         for (let i = 0; i < nodes.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
+            if (isOptional && isNullOrUndefined(target)) {
+                return undefined;
+            }
             target = target[nodes[i]];
         }
         return target;
     };
 }
-/**
- * Dereference a reference
- *
- * @description useful if you dereference a reference a few times at most
- *
- * also take a look at {@link getCachedDereference} and {@link compileDereferencer} if you need to dereference multiple times
- * @param object object to dereference
- * @param reference path to property in dot notation or {@link JsonPath}
- * @returns referenced value
- */
+function compileFunctionDereferencer(nodes, isOptional) {
+    const accessor = isOptional
+        // Generates code like: obj?.['prop1']?.['prop2']
+        ? nodes.map((node) => `?.['${node.replace(/'/g, '\\\'')}']`).join('')
+        // Generates code like: obj['prop1']['prop2']
+        : nodes.map((node) => `['${node.replace(/'/g, '\\\'')}']`).join('');
+    const body = `
+    "use strict";
+    return object${accessor};
+  `;
+    return new Function('object', body);
+}
+export function compileDereferencer(reference, options) {
+    const nodes = JsonPath.from(reference).nodes;
+    const isOptional = options?.optional ?? false;
+    if (options?.method === 'loop') {
+        return compileLoopDereferencer(nodes, isOptional);
+    }
+    try {
+        for (const node of nodes) {
+            if (isSymbol(node)) {
+                throw new Error('Cannot compile function dereferencer for paths containing symbols');
+            }
+        }
+        return compileFunctionDereferencer(nodes, isOptional);
+    }
+    catch {
+        return compileLoopDereferencer(nodes, isOptional);
+    }
+}
 export function dereference(object, reference, options) {
-    return compileDereferencer(reference, options)(object);
+    return compileDereferencer(reference, { method: 'loop', ...options })(object);
 }
 /**
- * Cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
+ * Returns a cached dereferencing function.
+ * The function caches the compiled dereferencer for each path, but not the resulting values.
  *
  * @description
- * useful if you dereference multiple references, each multiple times
+ * Ideal for applications that frequently access various, but repeating, paths on different objects.
+ *
+ * @example
+ * const optionalDeref = getCachedDereference({ optional: true });
+ * const value = optionalDeref(myObj, 'a.b.c'); // value is T | undefined
  *
- * also take a look at {@link dereference} and {@link compileDereferencer} for other use cases
- * @param object object to dereference
- * @param reference path to property in dot notation or {@link JsonPath}
- * @returns referenced value
+ * const requiredDeref = getCachedDereference();
+ * const value2 = requiredDeref(myObj, 'a.b.c'); // value2 is T
+ *
+ * @param options - Dereferencing options. These options are fixed for the lifetime of the returned function.
+ * @returns A function that takes an object and a reference and returns the value.
  */
 export function getCachedDereference(options) {
-    const memoizedDereferencer = memoizeSingle(compileDereferencer);
-    function cachedDereference(object, reference) {
-        return memoizedDereferencer(reference, options)(object);
-    }
-    return cachedDereference;
+    const memoizedCompiler = memoizeSingle((reference) => compileDereferencer(reference, options));
+    return function cachedDereference(object, reference) {
+        return memoizedCompiler(reference)(object);
+    };
 }

package/utils/timing.js

@@ -29,8 +29,8 @@ export async function cancelableTimeout(milliseconds, cancelSignal) {
 }
 /** Timeout until specified time */
 export async function cancelableTimeoutUntil(timestamp, cancelSignal) {
-    const left = timestamp.valueOf() - Date.now();
-    return await cancelableTimeout(left, cancelSignal);
+    const millisecondsLeft = timestamp.valueOf() - Date.now();
+    return await cancelableTimeout(millisecondsLeft, cancelSignal);
 }
 export async function withTimeout(milliseconds, promiseOrProvider, options) {
     const abortController = new AbortController();

package/utils/try-chain.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Executes a series of functions (strategies) in order until one succeeds.
+ * If all strategies fail by throwing an error, the fallback function is executed.
+ *
+ * @template T The expected return type.
+ * @param strategies An array of functions to attempt, in order.
+ * @param fallback Optional function to execute if all strategies fail.
+ * @param onError Optional callback to handle/log errors from failing strategies.
+ * @returns The result of the first successful strategy or the fallback.
+ */
+export declare function tryChain<T>(strategies: (() => T)[], onError?: (error: unknown, index: number) => void): T;
+/**
+ * Executes a series of functions (strategies) in order until one succeeds.
+ * If all strategies fail by throwing an error, the fallback function is executed.
+ *
+ * @template T The expected return type.
+ * @param strategies An array of functions to attempt, in order.
+ * @param fallback Optional function to execute if all strategies fail.
+ * @param onError Optional callback to handle/log errors from failing strategies.
+ * @returns The result of the first successful strategy or the fallback.
+ */
+export declare function tryChainAsync<T>(strategies: (() => T | Promise<T>)[], onError?: (error: unknown, index: number) => void): Promise<T>;

package/utils/try-chain.js

@@ -0,0 +1,46 @@
+/**
+ * Executes a series of functions (strategies) in order until one succeeds.
+ * If all strategies fail by throwing an error, the fallback function is executed.
+ *
+ * @template T The expected return type.
+ * @param strategies An array of functions to attempt, in order.
+ * @param fallback Optional function to execute if all strategies fail.
+ * @param onError Optional callback to handle/log errors from failing strategies.
+ * @returns The result of the first successful strategy or the fallback.
+ */
+export function tryChain(strategies, onError) {
+    const errors = [];
+    for (const [index, strategy] of strategies.entries()) {
+        try {
+            return strategy();
+        }
+        catch (error) {
+            errors.push(error);
+            onError?.(error, index);
+        }
+    }
+    throw new AggregateError(errors, 'All strategies failed and no fallback provided');
+}
+/**
+ * Executes a series of functions (strategies) in order until one succeeds.
+ * If all strategies fail by throwing an error, the fallback function is executed.
+ *
+ * @template T The expected return type.
+ * @param strategies An array of functions to attempt, in order.
+ * @param fallback Optional function to execute if all strategies fail.
+ * @param onError Optional callback to handle/log errors from failing strategies.
+ * @returns The result of the first successful strategy or the fallback.
+ */
+export async function tryChainAsync(strategies, onError) {
+    const errors = [];
+    for (const [index, strategy] of strategies.entries()) {
+        try {
+            return await strategy();
+        }
+        catch (error) {
+            errors.push(error);
+            onError?.(error, index);
+        }
+    }
+    throw new AggregateError(errors, 'All strategies failed and no fallback provided');
+}

package/database/entity-repository.d.ts

@@ -1,50 +0,0 @@
-import type { Entity, MaybeNewEntity } from './entity.js';
-import type { Query, QueryOptions } from './query.js';
-export declare const repositoryType: unique symbol;
-export type UpdateOptions = {
-    upsert?: boolean;
-};
-export type EntityPatch<T extends Entity = Entity> = Partial<Omit<T, 'id'>>;
-export declare abstract class EntityRepository<T extends Entity = Entity> {
-    readonly [repositoryType]: T;
-    abstract load<U extends T = T>(id: string): Promise<U>;
-    abstract tryLoad<U extends T = T>(id: string): Promise<U | undefined>;
-    abstract loadByFilter<U extends T = T>(query: Query<U>, options?: QueryOptions<U>): Promise<U>;
-    abstract tryLoadByFilter<U extends T = T>(query: Query<U>, options?: QueryOptions<U>): Promise<U | undefined>;
-    abstract loadMany<U extends T = T>(ids: string[], options?: QueryOptions<U>): Promise<U[]>;
-    abstract loadManyCursor<U extends T = T>(ids: string[], options?: QueryOptions<U>): AsyncIterableIterator<U>;
-    abstract loadManyByFilter<U extends T = T>(query: Query<U>, options?: QueryOptions<U>): Promise<U[]>;
-    abstract loadManyByFilterCursor<U extends T = T>(query: Query<U>, options?: QueryOptions<U>): AsyncIterableIterator<U>;
-    abstract loadAll<U extends T = T>(options?: QueryOptions<U>): Promise<U[]>;
-    abstract loadAllCursor<U extends T = T>(options?: QueryOptions<U>): AsyncIterableIterator<U>;
-    abstract loadAndDelete<U extends T = T>(id: string): Promise<U>;
-    abstract tryLoadAndDelete<U extends T = T>(id: string): Promise<U | undefined>;
-    abstract loadByFilterAndDelete<U extends T = T>(query: Query<U>, options?: QueryOptions<U>): Promise<U>;
-    abstract tryLoadByFilterAndDelete<U extends T = T>(query: Query<U>, options?: QueryOptions<U>): Promise<U | undefined>;
-    abstract loadAndPatch<U extends T = T>(id: string, patch: EntityPatch<U>, includePatch: boolean): Promise<U>;
-    abstract tryLoadAndPatch<U extends T = T>(id: string, patch: EntityPatch<U>, includePatch: boolean): Promise<U | undefined>;
-    abstract loadByFilterAndPatch<U extends T = T>(query: Query<U>, patch: EntityPatch<U>, includePatch: boolean, options?: QueryOptions<U>): Promise<U>;
-    abstract tryLoadByFilterAndPatch<U extends T = T>(query: Query<U>, patch: EntityPatch<U>, includePatch: boolean, options?: QueryOptions<U>): Promise<U | undefined>;
-    abstract count(allowEstimation?: boolean): Promise<number>;
-    abstract countByFilter<U extends T>(query: Query<U>, allowEstimation?: boolean): Promise<number>;
-    abstract has(id: string): Promise<boolean>;
-    abstract hasByFilter<U extends T>(query: Query<U>): Promise<boolean>;
-    abstract hasMany(ids: string[]): Promise<string[]>;
-    abstract hasAll(ids: string[]): Promise<boolean>;
-    abstract insert<U extends T>(entity: MaybeNewEntity<U>): Promise<U>;
-    abstract insertMany<U extends T>(entities: MaybeNewEntity<U>[]): Promise<U[]>;
-    abstract insertIfNotExists<U extends T>(entity: MaybeNewEntity<U>): Promise<U | undefined>;
-    abstract insertIfNotExistsByFilter<U extends T>(query: Query<U>, entity: MaybeNewEntity<U>): Promise<U | undefined>;
-    abstract update<U extends T>(entity: U, options?: UpdateOptions): Promise<boolean>;
-    abstract updateMany<U extends T>(entities: U[], options?: UpdateOptions): Promise<number>;
-    abstract patch<U extends T = T>(entity: U, patch: EntityPatch<U>): Promise<boolean>;
-    abstract patchMany<U extends T = T>(entities: U[], patch: EntityPatch<U>): Promise<number>;
-    abstract patchByFilter<U extends T = T>(query: Query<U>, patch: EntityPatch<U>): Promise<boolean>;
-    abstract patchManyByFilter<U extends T = T>(query: Query<U>, patch: EntityPatch<U>): Promise<number>;
-    abstract delete<U extends T>(entity: U): Promise<boolean>;
-    abstract deleteMany<U extends T>(entities: U[]): Promise<number>;
-    abstract deleteById(id: string): Promise<boolean>;
-    abstract deleteManyById(ids: string[]): Promise<number>;
-    abstract deleteByFilter<U extends T = T>(query: Query<U>): Promise<boolean>;
-    abstract deleteManyByFilter<U extends T = T>(query: Query<U>): Promise<number>;
-}

package/database/entity-repository.js

@@ -1,3 +0,0 @@
-export const repositoryType = Symbol('repositoryType');
-export class EntityRepository {
-}

package/database/entity.d.ts

@@ -1,7 +0,0 @@
-export type Entity<Id = string> = {
-    id: Id;
-};
-export type NewEntity<T extends Entity | MaybeNewEntity = Entity> = Omit<T, 'id'>;
-export type MaybeNewEntity<T extends Entity = Entity> = NewEntity<T> & {
-    id?: T['id'];
-};

package/database/entity.js

@@ -1 +0,0 @@
-export {};

package/database/id.d.ts

@@ -1 +0,0 @@
-export declare function getNewId(): string;

package/database/id.js

@@ -1,9 +0,0 @@
-import { Alphabet } from '../utils/alphabet.js';
-import { getRandomString } from '../utils/random.js';
-import { isDefined } from '../utils/type-guards.js';
-import { databaseModuleConfig } from './module.js';
-export function getNewId() {
-    return isDefined(databaseModuleConfig.idGenerator)
-        ? databaseModuleConfig.idGenerator()
-        : getRandomString(databaseModuleConfig.idLength ?? 15, databaseModuleConfig.idAlphabet ?? Alphabet.LowerUpperCaseNumbers);
-}

package/database/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Repository abstractions
- *
- * @module Database
- */
-export * from './entity-repository.js';
-export * from './entity.js';
-export * from './id.js';
-export * from './module.js';
-export * from './query.js';
-export * from './utils.js';

package/database/index.js

@@ -1,11 +0,0 @@
-/**
- * Repository abstractions
- *
- * @module Database
- */
-export * from './entity-repository.js';
-export * from './entity.js';
-export * from './id.js';
-export * from './module.js';
-export * from './query.js';
-export * from './utils.js';

package/database/module.d.ts

@@ -1,8 +0,0 @@
-import { Alphabet } from '../utils/alphabet.js';
-export type DatabaseModuleConfig = {
-    idLength?: number;
-    idAlphabet?: Alphabet;
-    idGenerator?: () => string;
-};
-export declare const databaseModuleConfig: DatabaseModuleConfig;
-export declare function configureDatabase(config: DatabaseModuleConfig): void;

package/database/module.js

@@ -1,11 +0,0 @@
-import { Alphabet } from '../utils/alphabet.js';
-export const databaseModuleConfig = {
-    idLength: 15,
-    idAlphabet: Alphabet.LowerUpperCaseNumbers,
-    idGenerator: undefined
-};
-export function configureDatabase(config) {
-    databaseModuleConfig.idLength = config.idLength;
-    databaseModuleConfig.idAlphabet = config.idAlphabet;
-    databaseModuleConfig.idGenerator = config.idGenerator;
-}

package/database/mongo/classes.d.ts

@@ -1,21 +0,0 @@
-import type { Entity } from '../../database/index.js';
-import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import { Db, Collection as MongoCollection, MongoClient as MongoMongoClient } from 'mongodb';
-import type { MongoDocument } from './model/document.js';
-import type { MongoConnection, MongoRepositoryConfig } from './types.js';
-export type MongoClientArgument = MongoConnection;
-/** database name */
-export type DatabaseArgument = string | {
-    connection?: MongoConnection;
-    database?: string;
-};
-export type CollectionArgument<T extends Entity<any> = Entity, TDb extends Entity<any> = T> = MongoRepositoryConfig<T, TDb>;
-export declare class MongoClient extends MongoMongoClient implements Resolvable<MongoClientArgument> {
-    readonly [resolveArgumentType]: MongoClientArgument;
-}
-export declare class Database extends Db implements Resolvable<DatabaseArgument> {
-    readonly [resolveArgumentType]: DatabaseArgument;
-}
-export declare class Collection<T extends Entity<any> = Entity, TDb extends Entity<any> = T> extends MongoCollection<MongoDocument<TDb>> implements Resolvable<CollectionArgument<T, TDb>> {
-    readonly [resolveArgumentType]: CollectionArgument<T, TDb>;
-}

package/database/mongo/classes.js

@@ -1,26 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { ReplaceClass } from '../../injector/decorators.js';
-import { Db, Collection as MongoCollection, MongoClient as MongoMongoClient } from 'mongodb';
-let MongoClient = class MongoClient extends MongoMongoClient {
-};
-MongoClient = __decorate([
-    ReplaceClass(MongoMongoClient)
-], MongoClient);
-export { MongoClient };
-let Database = class Database extends Db {
-};
-Database = __decorate([
-    ReplaceClass(Db)
-], Database);
-export { Database };
-let Collection = class Collection extends MongoCollection {
-};
-Collection = __decorate([
-    ReplaceClass(MongoCollection)
-], Collection);
-export { Collection };

package/database/mongo/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * MongoDB implemenation for Database module
- *
- * @module Database - MongoDB
- */
-export * from './classes.js';
-export * from './model/index.js';
-export * from './module.js';
-export * from './mongo-base.repository.js';
-export * from './mongo-bulk.js';
-export * from './mongo-entity-repository.js';
-export * from './operations.js';
-export * from './query-converter.js';
-export * from './simple-entity-repository.js';
-export * from './types.js';