@tstdl/base 0.92.166 → 0.92.168

package/queue/postgres/job.model.js

@@ -8,8 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Index, Table } from '../../orm/decorators.js';
-import { EntityWithoutMetadata } from '../../orm/entity.js';
-import { Integer, Json, Timestamp } from '../../orm/index.js';
+import { EntityWithoutMetadata, Integer, Json, Timestamp } from '../../orm/index.js';
 import { StringProperty } from '../../schema/index.js';
 let PostgresJob = class PostgresJob extends EntityWithoutMetadata {
     queue;

package/queue/postgres/module.js

@@ -24,6 +24,6 @@ export async function migratePostgresQueueSchema() {
     await migrate(database, {
         migrationsSchema: 'queue',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', '')
+        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
     });
 }

package/threading/thread-pool.d.ts

@@ -1,7 +1,5 @@
 import type * as NodeWorkerThreads from 'node:worker_threads';
 import type { LiteralUnion } from 'type-fest';
-import type { AsyncDisposable } from '../disposable/index.js';
-import { disposeAsync } from '../disposable/index.js';
 import type { Logger } from '../logger/index.js';
 import type { ThreadWorker } from './thread-worker.js';
 export type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
@@ -13,7 +11,7 @@ export declare class ThreadPool implements AsyncDisposable {
     readonly options: ThreadOptions | undefined;
     constructor(url: string | URL, logger: Logger, options?: ThreadOptions);
     dispose(): Promise<void>;
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
     getProcessor<T extends ThreadWorker>(name?: string): (...args: Parameters<T>) => Promise<ReturnType<T>>;
     process<T extends ThreadWorker>(name: LiteralUnion<'default', string>, ...args: Parameters<T>): Promise<ReturnType<T>>;
     private spawn;

package/threading/thread-pool.js

@@ -1,4 +1,3 @@
-import { disposeAsync } from '../disposable/index.js';
 import { isNode } from '../environment.js';
 import { dynamicImport } from '../import.js';
 import { Pool } from '../pool/index.js';
@@ -9,7 +8,7 @@ if (isNode) {
     spawnWorker = async (url, options) => {
         const workerThreads = await dynamicImport('node:worker_threads');
         spawnWorker = () => new workerThreads.Worker(url, options);
-        return spawnWorker(url, options);
+        return await spawnWorker(url, options);
     };
 }
 else {
@@ -22,26 +21,26 @@ export class ThreadPool {
     constructor(url, logger, options) {
         this.url = url;
         this.options = options;
-        this.pool = new Pool(async () => this.spawn(), async ({ worker }) => worker.terminate(), logger, { size: options?.threadCount });
+        this.pool = new Pool(async () => await this.spawn(), async ({ worker }) => await worker.terminate(), logger, { size: options?.threadCount });
     }
     async dispose() {
-        return this[disposeAsync]();
+        await this[Symbol.asyncDispose]();
     }
-    async [disposeAsync]() {
+    async [Symbol.asyncDispose]() {
         await this.pool.dispose();
     }
     getProcessor(name = 'default') {
-        const processor = async (...args) => this.process(name, ...args);
+        const processor = async (...args) => await this.process(name, ...args);
         return processor;
     }
     async process(name, ...args) {
-        return this.pool.use(async (entry) => {
+        return await this.pool.use(async (entry) => {
             if (!entry.remotes.has(name)) {
                 const rpcEndpoint = MessagePortRpcEndpoint.from(entry.worker);
                 const remote = await Rpc.connect(rpcEndpoint, `thread-worker:${name}`);
                 entry.remotes.set(name, remote);
             }
-            return entry.remotes.get(name)(...args);
+            return await entry.remotes.get(name)(...args);
         });
     }
     async spawn() {

package/utils/format-error.d.ts

@@ -16,9 +16,16 @@ export type FormatErrorOptions = {
      * Include stack trace
      */
     includeStack?: boolean;
+    /**
+     * Maximum recursion depth for nested causes and aggregate errors (default: 5)
+     */
+    depth?: number;
 };
 export interface ErrorExtraInfo {
     /** Format extra data (without message and stack) as JSON */
     getExtraInfo(): UndefinableJson | undefined;
 }
+/**
+ * Enhanced error formatting
+ */
 export declare function formatError(error: any, options?: FormatErrorOptions): string;

package/utils/format-error.js

@@ -1,35 +1,77 @@
 import { unwrapError } from '../errors/utils.js';
 import { decycle } from './object/decycle.js';
 import { objectKeys } from './object/object.js';
-import { isDefined, isFunction, isUndefined } from './type-guards.js';
+import { tryChain } from './try-chain.js';
+import { isDefined, isFunction, isObject, isUndefined } from './type-guards.js';
+/**
+ * Enhanced error formatting
+ */
 export function formatError(error, options = {}) {
-    const { includeRest = 'if-no-extra-info', includeExtraInfo = true, includeStack = true } = options;
+    const { includeName = true, includeRest = 'if-no-extra-info', includeExtraInfo = true, includeStack = true, depth = 5, } = options;
+    if (depth <= 0) {
+        return '[Max recursion depth reached]';
+    }
+    const actualError = unwrapError(error);
     let name;
     let message;
     let stack;
     let rest;
     let extraInfo;
-    const actualError = unwrapError(error);
-    if ((actualError instanceof Error)) {
-        ({ name, message, stack, ...rest } = actualError);
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        if (includeExtraInfo && isFunction(actualError.getExtraInfo)) {
+    let cause;
+    let aggregateErrors;
+    if (isObject(actualError)) {
+        if (actualError instanceof Error) {
+            ({ name, message, stack, cause, ...rest } = actualError);
+            if (actualError instanceof AggregateError) {
+                aggregateErrors = actualError.errors;
+            }
+        }
+        else {
+            // Handle plain objects that might have error-like properties
+            ({ name, message, stack, cause, ...rest } = actualError);
+        }
+        // Check for extra info (duck-typing)
+        if (includeExtraInfo && isFunction(actualError.getExtraInfo)) { // eslint-disable-line @typescript-eslint/unbound-method
             extraInfo = actualError.getExtraInfo();
         }
     }
-    if (isUndefined(name) && (isUndefined(message) || message.trim().length == 0)) {
-        try {
-            const decycledError = decycle(actualError);
-            message = JSON.stringify(decycledError, null, 2);
+    // If no message, serialize the whole object as a fallback
+    if (isUndefined(message) || String(message).trim().length === 0) { // eslint-disable-line @typescript-eslint/no-unnecessary-type-conversion
+        // Handle primitives directly
+        if (!isObject(actualError)) {
+            message = String(actualError);
         }
-        catch {
-            throw actualError;
+        else {
+            message = tryChain([
+                () => JSON.stringify(actualError, null, 2), // Try normal serialization first
+                () => {
+                    // Fallback with decycle for objects with circular references
+                    const decycledError = decycle(actualError);
+                    return JSON.stringify(decycledError, null, 2);
+                },
+                // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                () => `[Unstringifiable object: ${String(actualError)}]`, // Safe fallback if JSON.stringify still fails
+            ]);
         }
     }
-    const nameString = (options.includeName ?? true) ? `${name ?? 'Error'}: ` : '';
-    const decycledRest = isDefined(rest) ? decycle(rest) : undefined;
-    const restString = (((includeRest == true) || ((includeRest == 'if-no-extra-info') && isUndefined(extraInfo))) && isDefined(decycledRest) && (objectKeys(rest ?? {}).length > 0)) ? `\n${JSON.stringify(decycledRest, null, 2)}` : '';
+    // --- String Assembly ---
+    const nameString = includeName ? `${name ?? 'Error'}: ` : '';
+    let restString = '';
+    const shouldIncludeRest = (includeRest == true) || (includeRest == 'if-no-extra-info' && isUndefined(extraInfo));
+    if (shouldIncludeRest && isDefined(rest) && objectKeys(rest).length > 0) {
+        restString = `\n${JSON.stringify(decycle(rest), null, 2)}`;
+    }
     const extraInfoString = isDefined(extraInfo) ? `\n${JSON.stringify(extraInfo, null, 2)}` : '';
     const stackString = (includeStack && isDefined(stack)) ? `\n${stack}` : '';
-    return `${nameString}${message}${restString}${extraInfoString}${stackString}`;
+    const causeString = includeStack && cause
+        ? formatNestedError('Caused by:', cause, { ...options, depth: depth - 1 })
+        : '';
+    const aggregateErrorsString = Array.isArray(aggregateErrors)
+        ? aggregateErrors.map((err, i) => formatNestedError(`Sub-error #${i + 1}:`, err, { ...options, depth: depth - 1 })).join('')
+        : '';
+    return `${nameString}${message}${restString}${extraInfoString}${stackString}${causeString}${aggregateErrorsString}`;
+}
+function formatNestedError(prefix, error, options) {
+    const formatted = formatError(error, options).replace(/\n/g, '\n  ');
+    return `\n\n${prefix}\n  ${formatted}`;
 }

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;
-}