@tstdl/base 0.92.124 → 0.92.125

package/data-structures/linked-list.d.ts

@@ -0,0 +1,57 @@
+import type { TryDereference } from '../serializer/serializable.js';
+import { Serializable } from '../serializer/serializable.js';
+import type { Predicate } from '../utils/iterable-helpers/types.js';
+import { List } from './list.js';
+export type LinkedListNode<T> = {
+    /** item of node */
+    item: T;
+    /** previous node. Warning: it is not safe to use this reference on a removed node */
+    previous: LinkedListNode<T> | undefined;
+    /** next node. Warning: it is not safe to use this reference on a removed node */
+    next: LinkedListNode<T> | undefined;
+};
+export declare class LinkedList<T> extends List<T, LinkedList<T>> implements Serializable<LinkedList<T>, T[]> {
+    private head;
+    private tail;
+    get firstNode(): LinkedListNode<T> | undefined;
+    get lastNode(): LinkedListNode<T> | undefined;
+    constructor(items?: Iterable<T>);
+    [Serializable.serialize](instance: LinkedList<T>): T[];
+    [Serializable.deserialize](data: T[], tryDereference: TryDereference): LinkedList<T>;
+    protected _at(index: number): T;
+    /** get node at index */
+    nodeAt(index: number): LinkedListNode<T>;
+    protected _indexOf(item: T, fromIndex?: number): number | undefined;
+    nodeOf(item: T): LinkedListNode<T> | undefined;
+    findIndex(predicate: Predicate<T>): number | undefined;
+    protected _lastIndexOf(item: T, fromIndex?: number): number | undefined;
+    findLastIndex(predicate: Predicate<T>): number | undefined;
+    lastNodeOf(item: T): LinkedListNode<T> | undefined;
+    protected _set(index: number, item: T): void;
+    includes(item: T): boolean;
+    add(item: T): LinkedListNode<T>;
+    prepend(item: T): LinkedListNode<T>;
+    /** add item after node */
+    addAfterNode(node: LinkedListNode<T>, item: T): LinkedListNode<T>;
+    /** add item before node */
+    addBeforeNode(node: LinkedListNode<T>, item: T): LinkedListNode<T>;
+    addMany(items: Iterable<T>): void;
+    /** add many items at the start */
+    prependMany(items: Iterable<T>): void;
+    remove(item: T): boolean;
+    protected _removeAt(index: number): T;
+    protected _removeManyAt(index: number, count?: number): T[];
+    /** remove node at index */
+    removeNodeAt(index: number): LinkedListNode<T>;
+    /** remove node */
+    removeNode(node: LinkedListNode<T>): void;
+    removeManyNodesAt(index: number, count?: number): LinkedListNode<T>[];
+    clone(): LinkedList<T>;
+    items(): IterableIterator<T>;
+    itemsReverse(): IterableIterator<T>;
+    /** yields all nodes from the list */
+    nodes(): IterableIterator<LinkedListNode<T>>;
+    /** yields all nodes from the list in reverse */
+    nodesReverse(): IterableIterator<LinkedListNode<T>>;
+    protected _clear(): void;
+}

package/data-structures/list.d.ts

@@ -0,0 +1,78 @@
+import type { Predicate } from '../utils/iterable-helpers/types.js';
+import { Collection } from './collection.js';
+export declare abstract class List<T, TThis extends Collection<T, IterableIterator<T>, TThis>> extends Collection<T, IterableIterator<T>, TThis> {
+    /** Get item at index */
+    at(index: number): T;
+    /**
+     * Find index of first occurrence of item
+     * @param item item to search for
+     * @param fromIndex index to start search at
+     */
+    indexOf(item: T, fromIndex?: number): number | undefined;
+    /** Index of item (last occurrence) */
+    /**
+     * Find index of last occurrence of item
+     * @param item item to search for
+     * @param fromIndex index to start from (backwards)
+     */
+    lastIndexOf(item: T, fromIndex?: number): number | undefined;
+    /** Set item at index */
+    set(index: number, item: T): void;
+    /** Remove item at index */
+    removeAt(index: number): T;
+    /** Remove first item */
+    removeFirst(): T;
+    /** Remove last item */
+    removeLast(): T;
+    /**
+     * Remove many items at index
+     * @param index index to start removing at
+     * @param count how many items to remove. If not defined, all items starting at `index` are removed
+     */
+    removeManyAt(index: number, count?: number): T[];
+    /**
+     * Remove range of items at `fromIndex` to `toIndex`
+     * @param fromIndex index to start removing at
+     * @param toIndex index to remove to
+     */
+    removeRange(fromIndex: number, toIndex: number): T[];
+    protected ensureBounds(index: number, count?: number): void;
+    protected normalizeIndex(index: number): number;
+    /** Yields all items from the list in reverse */
+    abstract itemsReverse(): IterableIterator<T>;
+    /** Get item at index */
+    protected abstract _at(index: number): T;
+    /**
+     * Find index of first occurrence of item
+     * @param item item to search for
+     * @param fromIndex index to start search at
+     */
+    protected abstract _indexOf(item: T, fromIndex?: number): number | undefined;
+    /** Index of match (first occurrence) */
+    protected abstract findIndex(predicate: Predicate<T>): number | undefined;
+    /** Index of item (last occurrence) */
+    /**
+     * Find index of last occurrence of item
+     * @param item item to search for
+     * @param fromIndex index to start from (backwards)
+     */
+    protected abstract _lastIndexOf(item: T, fromIndex?: number): number | undefined;
+    /** Index of match (last occurrence) */
+    protected abstract findLastIndex(predicate: Predicate<T>): number | undefined;
+    /** Set item at index */
+    protected abstract _set(index: number, item: T): void;
+    /** Add item to start of list */
+    protected abstract prepend(item: T): void;
+    /** Add many items to start of list */
+    protected abstract prependMany(items: Iterable<T>): void;
+    /** Remove item */
+    protected abstract remove(item: T): boolean;
+    /** Remove item at index */
+    protected abstract _removeAt(index: number): T;
+    /**
+     * Remove many items at index
+     * @param index index to start removing at
+     * @param count how many items to remove. If not defined, all items starting at `index` are removed
+     */
+    protected abstract _removeManyAt(index: number, count?: number): T[];
+}

package/data-structures/sorted-array-list.d.ts

@@ -0,0 +1,49 @@
+import type { TryDereference } from '../serializer/serializable.js';
+import { Serializable } from '../serializer/serializable.js';
+import type { Predicate } from '../utils/iterable-helpers/types.js';
+import type { Comparator } from '../utils/sort.js';
+import { List } from './list.js';
+export type RangeType = 'inclusive' | 'exclusive';
+export declare class SortedArrayList<T extends TComparator, TComparator = T> extends List<T, SortedArrayList<T, TComparator>> implements Serializable<SortedArrayList<T, TComparator>, T[]> {
+    private readonly comparator;
+    private backingArray;
+    constructor(items?: Iterable<T>, comparator?: Comparator<TComparator>);
+    /**
+     * creates a new {@link SortedArrayList} from existing *sorted* array without copying data.
+     * If an unsorted array is provided, behaviour is undefined
+     * @param array array to use as new backing array for this {@link SortedArrayList}
+     */
+    static fromSortedArray<T extends TComparator, TComparator>(array: T[]): SortedArrayList<T, TComparator>;
+    [Serializable.serialize](instance: SortedArrayList<T, TComparator>): T[];
+    [Serializable.deserialize](data: T[], tryDereference: TryDereference): SortedArrayList<T, TComparator>;
+    protected _at(index: number): T;
+    /** find index of item, can be any occurrence of it */
+    fastIndexOf(item: TComparator, fromIndex?: number): number | undefined;
+    protected _indexOf(item: TComparator, fromIndex?: number): number | undefined;
+    findIndex(predicate: Predicate<T>): number | undefined;
+    protected _lastIndexOf(item: TComparator, fromIndex?: number): number | undefined;
+    findLastIndex(predicate: Predicate<T>): number | undefined;
+    includes(item: T): boolean;
+    /** same as {@link add} as it is sorted */
+    prepend(item: T): void;
+    /** same as {@link addMany} as it is sorted */
+    prependMany(items: Iterable<T>): void;
+    add(item: T): void;
+    addMany(items: Iterable<T>): void;
+    /** same as `removeAt(index); add(item);` as it is sorted */
+    protected _set(index: number, item: T): void;
+    remove(item: T): boolean;
+    protected _removeAt(index: number): T;
+    protected _removeManyAt(index: number, count: number): T[];
+    /**
+     * remove items
+     * @param from
+     * @param to
+     */
+    removeRangeByComparison(_from: TComparator, _fromType: RangeType, _to: TComparator, _toType: RangeType): void;
+    clone(): SortedArrayList<T, TComparator>;
+    items(): IterableIterator<T>;
+    itemsReverse(): IterableIterator<T>;
+    protected _clear(): void;
+    private updateSize;
+}

package/database/module.d.ts

@@ -0,0 +1,8 @@
+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/mongo/classes.d.ts

@@ -0,0 +1,21 @@
+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/model/document.d.ts

@@ -0,0 +1,29 @@
+import type { Entity, MaybeNewEntity, NewEntity } from '../../../database/index.js';
+import type { OptionalId, OptionalUnlessRequiredId, WithId } from 'mongodb';
+import type { ProjectedEntity, Projection } from '../mongo-base.repository.js';
+import { ProjectionMode } from '../mongo-base.repository.js';
+export type MongoDocument<T extends MaybeNewEntity> = OptionalUnlessRequiredId<Omit<T, 'id'> & {
+    _id: T['id'];
+}>;
+export type MongoDocumentWithPartialId<T extends MaybeNewEntity> = OptionalId<Omit<T, 'id'> & {
+    _id?: T['id'];
+}>;
+export type MongoDocumentWithoutId<T extends MaybeNewEntity> = Omit<T, 'id'>;
+export declare function toEntity<T extends Entity>(document: WithId<MongoDocument<T>> | MongoDocument<T>): T;
+export declare function toNewEntity<T extends MaybeNewEntity>(entity: T): NewEntity<T>;
+export declare function toProjectedEntity<T extends Entity, M extends ProjectionMode, P extends Projection<T, M>>(document: MongoDocument<T> | MongoDocumentWithPartialId<T>): ProjectedEntity<T, M, P>;
+export declare function toMongoProjection<T extends Entity, M extends ProjectionMode, P extends Projection<T, M>>(mode: M, projection: P): Projection<MongoDocument<T>, M>;
+export declare function toMongoDocument<T extends Entity>(entity: T): MongoDocument<T>;
+export declare function toMongoDocumentWithPartialId<T extends MaybeNewEntity>(entity: T): MongoDocumentWithPartialId<T>;
+export declare function toMongoDocumentWithoutId<T extends Entity>(entity: MaybeNewEntity<T>): MongoDocumentWithoutId<T>;
+export declare function mongoDocumentFromMaybeNewEntity<T extends Entity>(entity: MaybeNewEntity<T>): MongoDocument<T>;
+export declare function renameIdPropertyToUnderscoreId<T extends {
+    id: any;
+}>(object: T): Omit<T, 'id'> & {
+    _id: T['id'];
+};
+export declare function renameIdPropertyToUnderscoreId<T extends {
+    id?: any;
+}>(object: T): Omit<T, 'id'> & {
+    _id?: T['id'];
+};

package/database/mongo/mongo-base.repository.d.ts

@@ -0,0 +1,103 @@
+import type { Entity, MaybeNewEntity } from '../../database/index.js';
+import type { Record } from '../../types.js';
+import type { FindOneAndUpdateOptions } from 'mongodb';
+import type { Collection } from './classes.js';
+import { MongoBulk } from './mongo-bulk.js';
+import type { Filter, Sort, TypedIndexDescription, UpdateFilter } from './types.js';
+export declare const enum ProjectionMode {
+    Include = 0,
+    Exclude = 1
+}
+export type Projection<T, M extends ProjectionMode> = {
+    [P in keyof T]?: M extends ProjectionMode.Include ? true : false;
+};
+export type ProjectedEntity<T, M extends ProjectionMode, P extends Projection<T, M>> = M extends ProjectionMode.Include ? {
+    [K in keyof T]: P[K] extends true ? T[K] : undefined;
+} : {
+    [K in keyof T]: P[K] extends false ? undefined : T[K];
+};
+export type ReplaceOptions = {
+    upsert?: boolean;
+};
+export type UpdateOptions = {
+    upsert?: boolean;
+};
+export type UpdateResult = {
+    matchedCount: number;
+    modifiedCount: number;
+};
+export type LoadOptions<T extends Entity> = {
+    limit?: number;
+    skip?: number;
+    sort?: Sort<T>;
+};
+export type LoadAndDeleteOptions<T extends Entity> = LoadOptions<T>;
+export type LoadManyOptions<T extends Entity> = LoadOptions<T>;
+export type LoadAndUpdateOptions<T extends Entity> = LoadOptions<T> & {
+    upsert?: boolean;
+    returnDocument?: FindOneAndUpdateOptions['returnDocument'];
+    sort?: Sort<T>;
+};
+export type CountOptions = {
+    limit?: number;
+    skip?: number;
+};
+export type InsertIfNotExistsByFilterItem<T extends Entity> = {
+    filter: Filter<T>;
+    entity: MaybeNewEntity<T>;
+};
+export declare class MongoBaseRepository<T extends Entity> {
+    readonly collection: Collection<T>;
+    constructor(collection: Collection<T>);
+    createIndexes(indexes: TypedIndexDescription<T>[]): Promise<void>;
+    bulk(): MongoBulk<T>;
+    insert<U extends T>(entity: MaybeNewEntity<U>): Promise<U>;
+    insertMany<U extends T>(entities: MaybeNewEntity<U>[]): Promise<U[]>;
+    insertIfNotExists<U extends T>(entity: MaybeNewEntity<U>): Promise<U | undefined>;
+    insertManyIfNotExists<U extends T>(entities: MaybeNewEntity<U>[]): Promise<U[]>;
+    insertIfNotExistsByFilter<U extends T>(filter: Filter<T>, entity: MaybeNewEntity<U>): Promise<U | undefined>;
+    /**
+     *
+     * @param items
+     * @returns inserted entities - entities which are already in the database are not returned
+     */
+    insertManyIfNotExistsByFilter<U extends T>(items: InsertIfNotExistsByFilterItem<U>[]): Promise<U[]>;
+    load<U extends T = T>(id: string, options?: LoadOptions<U>): Promise<U>;
+    tryLoad<U extends T = T>(id: string, options?: LoadOptions<U>): Promise<U | undefined>;
+    loadAndUpdate<U extends T = T>(id: string, update: UpdateFilter<U>, options?: LoadAndUpdateOptions<U>): Promise<U>;
+    tryLoadAndUpdate<U extends T = T>(id: string, update: UpdateFilter<U>, options?: LoadAndUpdateOptions<U>): Promise<U | undefined>;
+    loadAndDelete<U extends T = T>(id: string, options?: LoadAndDeleteOptions<U>): Promise<U>;
+    loadByFilter<U extends T = T>(filter: Filter<U>, options?: LoadOptions<U>): Promise<U>;
+    tryLoadByFilter<U extends T = T>(filter: Filter<U>, options?: LoadOptions<U>): Promise<U | undefined>;
+    loadProjectedByFilter<U extends T = T, M extends ProjectionMode = ProjectionMode.Include, P extends Projection<U, M> = Record<string, never>>(filter: Filter<U>, mode: M, projection: P, options?: LoadOptions<U>): Promise<ProjectedEntity<U, M, P>>;
+    tryLoadProjectedByFilter<U extends T = T, M extends ProjectionMode = ProjectionMode.Include, P extends Projection<U, M> = Record<string, never>>(filter: Filter<U>, mode: M, projection: P, options?: LoadOptions<U>): Promise<ProjectedEntity<U, M, P> | undefined>;
+    loadByFilterAndDelete<U extends T = T>(filter: Filter<U>, options?: LoadAndDeleteOptions<U>): Promise<U>;
+    tryLoadAndDelete<U extends T = T>(id: string, options?: LoadAndDeleteOptions<U>): Promise<U | undefined>;
+    tryLoadByFilterAndDelete<U extends T = T>(filter: Filter<U>, options?: LoadAndDeleteOptions<U>): Promise<U | undefined>;
+    loadByFilterAndUpdate<U extends T = T>(filter: Filter<U>, update: UpdateFilter<U>, options?: LoadAndUpdateOptions<U>): Promise<U>;
+    tryLoadByFilterAndUpdate<U extends T = T>(filter: Filter<U>, update: UpdateFilter<U>, options?: LoadAndUpdateOptions<U>): Promise<U | undefined>;
+    loadManyById<U extends T = T>(ids: string[], options?: LoadManyOptions<U>): Promise<U[]>;
+    loadManyByFilter<U extends T = T>(filter: Filter<U>, options?: LoadManyOptions<U>): Promise<U[]>;
+    loadManyByIdWithCursor<U extends T = T>(ids: string[], options?: LoadManyOptions<U>): AsyncIterableIterator<U>;
+    loadManyByFilterWithCursor<U extends T = T>(filter: Filter<U>, options?: LoadManyOptions<U>): AsyncIterableIterator<U>;
+    loadManyProjectedById<U extends T = T, M extends ProjectionMode = ProjectionMode.Include, P extends Projection<U, M> = Record<string, never>>(ids: string[], mode: M, projection: P, options?: LoadManyOptions<U>): Promise<ProjectedEntity<U, M, P>[]>;
+    loadManyProjectedByFilter<U extends T = T, M extends ProjectionMode = ProjectionMode.Include, P extends Projection<U, M> = Record<string, never>>(filter: Filter<U>, mode: M, projection: P, options?: LoadManyOptions<U>): Promise<ProjectedEntity<U, M, P>[]>;
+    loadManyProjectedByFilterWithCursor<U extends T = T, M extends ProjectionMode = ProjectionMode.Include, P extends Projection<U, M> = Record<string, never>>(filter: Filter<U>, mode: M, projection: P, options?: LoadManyOptions<U>): AsyncIterableIterator<ProjectedEntity<U, M, P>>;
+    deleteById(id: string): Promise<boolean>;
+    deleteManyById(ids: string[]): Promise<number>;
+    deleteByFilter<U extends T = T>(filter: Filter<U>): Promise<boolean>;
+    deleteManyByFilter<U extends T = T>(filter: Filter<U>): Promise<number>;
+    replace<U extends T>(entity: U, options?: ReplaceOptions): Promise<boolean>;
+    replaceByFilter<U extends T>(filter: Filter<U>, entity: U, options?: ReplaceOptions): Promise<boolean>;
+    replaceMany<U extends T>(entities: U[], options?: ReplaceOptions): Promise<number>;
+    update<U extends T>(filter: Filter<U>, update: UpdateFilter<U>, options?: UpdateOptions): Promise<UpdateResult>;
+    updateMany<U extends T>(filter: Filter<U>, update: UpdateFilter<U>, options?: UpdateOptions): Promise<UpdateResult>;
+    has(id: string): Promise<boolean>;
+    hasByFilter<U extends T = T>(filter: Filter<U>): Promise<boolean>;
+    hasMany(ids: string[]): Promise<string[]>;
+    getIdsByFilter<U extends T>(filter: Filter<U>): Promise<string[]>;
+    hasAll(ids: string[]): Promise<boolean>;
+    countByFilter<U extends T = T>(filter: Filter<U>, { limit, skip }?: CountOptions): Promise<number>;
+    countByFilterEstimated(): Promise<number>;
+    drop(): Promise<void>;
+}

package/database/mongo/mongo-bulk.d.ts

@@ -0,0 +1,35 @@
+import type { Entity, MaybeNewEntity } from '../../database/index.js';
+import type { BulkWriteResult } from 'mongodb';
+import type { Collection } from './classes.js';
+import type { ReplaceOptions, UpdateOptions } from './mongo-base.repository.js';
+import type { Filter, UpdateFilter } from './types.js';
+export type BulkResult = {
+    insertedCount: number;
+    matchedCount: number;
+    modifiedCount: number;
+    deletedCount: number;
+    upsertedCount: number;
+    raw: BulkWriteResult;
+};
+export declare class MongoBulk<T extends Entity> {
+    private readonly collection;
+    private readonly operations;
+    private executed;
+    constructor(collection: Collection<T>);
+    /**
+     * execute operations
+     * @param ordered whether operations must be executed in order (slower) (default: false)
+     */
+    execute(ordered?: boolean): Promise<BulkResult>;
+    insert<U extends T>(entity: MaybeNewEntity<U>): U;
+    insertMany<U extends T>(entities: MaybeNewEntity<U>[]): U[];
+    update<U extends T>(filter: Filter<U>, update: UpdateFilter<U>, options?: UpdateOptions): this;
+    updateMany<U extends T>(filter: Filter<U>, update: UpdateFilter<U>, options?: UpdateOptions): this;
+    replace<U extends T>(entity: U, options?: ReplaceOptions): this;
+    replaceMany<U extends T>(entities: U[], options?: ReplaceOptions): this;
+    replaceByFilter<U extends T>(filter: Filter<U>, entity: U, options?: ReplaceOptions): this;
+    delete<U extends T>(entity: U): this;
+    deleteMany<U extends T>(entities: U[]): this;
+    deleteByFilter<U extends T>(filter: Filter<U>): this;
+    deleteManyByFilter<U extends T>(filter: Filter<U>): this;
+}

package/database/mongo/mongo-entity-repository.d.ts

@@ -0,0 +1,98 @@
+import type { Entity, EntityPatch, MaybeNewEntity, Query, QueryOptions, UpdateOptions } from '../../database/index.js';
+import { EntityRepository } from '../../database/index.js';
+import type { AfterResolve } from '../../injector/index.js';
+import { afterResolve } from '../../injector/index.js';
+import type { Logger } from '../../logger/index.js';
+import type { Collection } from './classes.js';
+import { MongoBaseRepository } from './mongo-base.repository.js';
+import type { Filter, TypedIndexDescription, UpdateFilter } from './types.js';
+export type MongoEntityRepositoryOptions<T extends Entity<any>> = {
+    logger: Logger;
+    indexes?: TypedIndexDescription<T>[];
+};
+export type MappingItemTransformer<T extends Entity<any> = any, TKey extends keyof T = any> = (value: T[TKey]) => any;
+export type MappingItem<T extends Entity<any>, TDb extends Entity<any>, TKey extends keyof T = keyof T, TDbKey extends keyof TDb = keyof TDb> = {
+    key: TDbKey;
+    transform: MappingItemTransformer<T, TKey>;
+};
+export declare function mapTo<T extends Entity<any>, TDb extends Entity<any>, TKey extends keyof T, TDbKey extends keyof TDb>(key: TDbKey, transform: (value: T[TKey]) => TDb[TDbKey]): MappingItem<T, TDb, TKey, TDbKey>;
+export type TransformerMapping<T extends Entity<any>, TDb extends Entity<any>> = {
+    [P in keyof T]?: MappingItem<T, TDb, P>;
+};
+export type TransformerMappingMap<T extends Entity<any> = any, TDb extends Entity<any> = any> = Map<keyof T, MappingItem<T, TDb>>;
+export type EntityTransformer<T extends Entity<any>, TDb extends Entity<any>> = {
+    /**
+     * function to transform the base entity to the mongo entity
+     */
+    transform: (item: MaybeNewEntity<T>) => MaybeNewEntity<TDb>;
+    /**
+     * function to transform the mongo entity to the base entity
+     */
+    untransform: (item: TDb) => T;
+    /**
+     * maps a single property, required if an existing property changes its name or value. Not required for additional properties.
+     */
+    mapping?: TransformerMapping<T, TDb>;
+};
+export type InsertIfNotExistsByQueryItem<T extends Entity<any>> = {
+    query: Query<T>;
+    entity: MaybeNewEntity<T>;
+};
+export declare const noopTransformerFunction: <T>(item: T) => T;
+export declare const noopTransformer: EntityTransformer<any, any>;
+export declare function getNoopTransformer<T extends Entity<any> = any>(): EntityTransformer<T, T>;
+export declare class MongoEntityRepository<T extends Entity<any>, TDb extends Entity<any> = T> extends EntityRepository<T> implements AfterResolve {
+    readonly collection: Collection<TDb>;
+    readonly transformer: EntityTransformer<T, TDb>;
+    readonly logger: Logger;
+    readonly indexes?: TypedIndexDescription<TDb>[];
+    readonly baseRepository: MongoBaseRepository<TDb>;
+    readonly transformerMappingMap: TransformerMappingMap<T, TDb>;
+    constructor(collection: Collection<TDb>, transformer: EntityTransformer<T, TDb>, { logger, indexes }: MongoEntityRepositoryOptions<TDb>);
+    [afterResolve](): Promise<void>;
+    initialize(): Promise<void>;
+    load<U extends T = T>(id: string): Promise<U>;
+    tryLoad<U extends T = T>(id: string): Promise<U | undefined>;
+    loadMany<U extends T = T>(ids: string[], options?: QueryOptions<U>): Promise<U[]>;
+    loadManyCursor<U extends T = T>(ids: string[], options?: QueryOptions<U>): AsyncIterableIterator<U>;
+    loadByFilter<U extends T = T>(filter: Query<U>, options?: QueryOptions<U>): Promise<U>;
+    tryLoadByFilter<U extends T = T>(filter: Query<U>, options?: QueryOptions<U>): Promise<U | undefined>;
+    loadManyByFilter<U extends T = T>(filter: Query<U>, options?: QueryOptions<U>): Promise<U[]>;
+    loadManyByFilterCursor<U extends T = T>(filter: Query<U>, options?: QueryOptions<U>): AsyncIterableIterator<U>;
+    loadAll<U extends T = T>(options?: QueryOptions<U>): Promise<U[]>;
+    loadAllCursor<U extends T = T>(options?: QueryOptions<U>): AsyncIterableIterator<U>;
+    loadAndDelete<U extends T = T>(id: string): Promise<U>;
+    tryLoadAndDelete<U extends T = T>(id: string): Promise<U | undefined>;
+    loadByFilterAndDelete<U extends T = T>(filter: Query<U>, options?: QueryOptions<U>): Promise<U>;
+    tryLoadByFilterAndDelete<U extends T = T>(filter: Query<U>, options?: QueryOptions<U>): Promise<U | undefined>;
+    loadAndPatch<U extends T = T>(id: string, patch: EntityPatch<U>, includePatch: boolean): Promise<U>;
+    tryLoadAndPatch<U extends T = T>(id: string, patch: EntityPatch<U>, includePatch: boolean): Promise<U | undefined>;
+    loadByFilterAndPatch<U extends T = T>(filter: Query<U>, patch: EntityPatch<U>, includePatch: boolean, options?: QueryOptions<U>): Promise<U>;
+    tryLoadByFilterAndPatch<U extends T = T>(filter: Query<U>, patch: EntityPatch<U>, includePatch: boolean, options?: QueryOptions<U>): Promise<U | undefined>;
+    has(id: string): Promise<boolean>;
+    hasByFilter<U extends T>(filter: Query<U>): Promise<boolean>;
+    hasMany(ids: string[]): Promise<string[]>;
+    hasAll(ids: string[]): Promise<boolean>;
+    count(allowEstimation?: boolean): Promise<number>;
+    countByFilter<U extends T>(filter: Query<U>, _allowEstimation?: boolean): Promise<number>;
+    patch<U extends T = T>(entity: U, patch: EntityPatch<U>): Promise<boolean>;
+    patchMany<U extends T = T>(entities: U[], patch: EntityPatch<U>): Promise<number>;
+    patchByFilter<U extends T = T>(filter: Query<U>, patch: EntityPatch<U>): Promise<boolean>;
+    patchManyByFilter<U extends T = T>(filter: Query<U>, patch: EntityPatch<U>): Promise<number>;
+    insert<U extends T>(entity: MaybeNewEntity<U>): Promise<U>;
+    insertMany<U extends T>(entities: MaybeNewEntity<U>[]): Promise<U[]>;
+    insertIfNotExists<U extends T>(entity: MaybeNewEntity<U>): Promise<U | undefined>;
+    insertManyIfNotExists<U extends T>(entities: MaybeNewEntity<U>[]): Promise<U[]>;
+    insertIfNotExistsByFilter<U extends T>(query: Query<U>, entity: MaybeNewEntity<U>): Promise<U | undefined>;
+    insertManyIfNotExistsByFilter<U extends T>(items: InsertIfNotExistsByQueryItem<U>[]): Promise<U[]>;
+    update<U extends T>(entity: U, options?: UpdateOptions): Promise<boolean>;
+    updateMany<U extends T>(entities: U[], options?: UpdateOptions): Promise<number>;
+    delete<U extends T>(entity: U): Promise<boolean>;
+    deleteMany<U extends T>(entities: U[]): Promise<number>;
+    deleteById(id: string): Promise<boolean>;
+    deleteManyById(ids: string[]): Promise<number>;
+    deleteByFilter<U extends T = T>(filter: Query<U>): Promise<boolean>;
+    deleteManyByFilter<U extends T = T>(filter: Query<U>): Promise<number>;
+    transformFilter<U extends T = T>(filter: Query<U>): Filter<TDb>;
+    transformPatch<U extends T = T>(patch: EntityPatch<U>): UpdateFilter<TDb>;
+}

package/database/mongo/operations.d.ts

@@ -0,0 +1,10 @@
+import type { Entity, UpdateOptions } from '../../database/index.js';
+import type { MongoDocument } from './model/document.js';
+import type { ReplaceOptions } from './mongo-base.repository.js';
+import type { DeleteManyOperation, DeleteOneOperation, Filter, InsertOneOperation, ReplaceOneOperation, UpdateFilter, UpdateManyOperation, UpdateOneOperation } from './types.js';
+export declare function insertOneOperation<T extends Entity>(document: MongoDocument<T>): InsertOneOperation<T>;
+export declare function replaceOneOperation<T extends Entity>(filter: Filter<T>, replacement: MongoDocument<T>, options?: ReplaceOptions): ReplaceOneOperation<T>;
+export declare function updateOneOperation<T extends Entity>(filter: Filter<T>, update: UpdateFilter<T>, options?: UpdateOptions): UpdateOneOperation<T>;
+export declare function updateManyOperation<T extends Entity>(filter: Filter<T>, update: UpdateFilter<T>, options?: UpdateOptions): UpdateManyOperation<T>;
+export declare function deleteOneOperation<T extends Entity>(filter: Filter<T>): DeleteOneOperation<T>;
+export declare function deleteManyOperation<T extends Entity>(filter: Filter<T>): DeleteManyOperation<T>;

package/database/mongo/query-converter.d.ts

@@ -0,0 +1,6 @@
+import type { Entity } from '../../database/index.js';
+import type { Query, Sort } from '../../database/query.js';
+import type { MappingItemTransformer, TransformerMappingMap } from './mongo-entity-repository.js';
+import type { Filter, SortArrayItem } from './types.js';
+export declare function convertQuery<T extends Entity, TDb extends Entity>(query: Query<T>, mappingMap?: TransformerMappingMap<T, TDb>, transform?: MappingItemTransformer): Filter<TDb>;
+export declare function convertSort<T extends Entity, TDb extends Entity>(sort: Sort<T>, mappingMap: TransformerMappingMap<T, TDb>): SortArrayItem<TDb>;

package/database/mongo/simple-entity-repository.d.ts

@@ -0,0 +1,7 @@
+import type { Entity } from '../../database/index.js';
+import type { Logger } from '../../logger/index.js';
+import type { Collection } from './classes.js';
+import { MongoEntityRepository } from './mongo-entity-repository.js';
+export declare class SimpleMongoEntityRepository<T extends Entity> extends MongoEntityRepository<T> {
+    constructor(collection: Collection<T>, logger: Logger);
+}

package/database/mongo/types.d.ts

@@ -0,0 +1,50 @@
+import type { Entity } from '../../database/index.js';
+import type { Paths, TypedOmit } from '../../types.js';
+import type * as Mongo from 'mongodb';
+import type { MongoDocument } from './model/document.js';
+export type MongoConnection = {
+    url: string;
+} & Mongo.MongoClientOptions;
+export type MongoRepositoryConfig<T extends Entity, TDb extends Entity = T> = {
+    connection?: MongoConnection;
+    database?: string;
+    collection: string;
+    types?: {
+        entity: T;
+        database: TDb;
+    };
+};
+export type Filter<T extends Entity = Entity> = Mongo.Filter<MongoDocument<T>>;
+export type UpdateFilter<T extends Entity = Entity> = Mongo.UpdateFilter<MongoDocument<T>>;
+export type BulkOperation<T extends Entity = Entity> = InsertOneOperation<T> | ReplaceOneOperation<T> | UpdateOneOperation<T> | UpdateManyOperation<T> | DeleteOneOperation<T> | DeleteManyOperation<T>;
+export type InsertOneOperation<T extends Entity = Entity> = {
+    insertOne: Mongo.InsertOneModel<MongoDocument<T>>;
+};
+export type ReplaceOneOperation<T extends Entity = Entity> = {
+    replaceOne: Mongo.ReplaceOneModel<MongoDocument<T>>;
+};
+export type UpdateOneOperation<T extends Entity = Entity> = {
+    updateOne: Mongo.UpdateOneModel<MongoDocument<T>>;
+};
+export type UpdateManyOperation<T extends Entity = Entity> = {
+    updateMany: Mongo.UpdateManyModel<MongoDocument<T>>;
+};
+export type DeleteOneOperation<T extends Entity = Entity> = {
+    deleteOne: Mongo.DeleteOneModel<MongoDocument<T>>;
+};
+export type DeleteManyOperation<T extends Entity = Entity> = {
+    deleteMany: Mongo.DeleteManyModel<MongoDocument<T>>;
+};
+export type SortObject<T extends Entity = Entity> = {
+    [P in keyof MongoDocument<T>]?: 1 | -1;
+};
+export type SortArrayItem<T extends Entity = Entity> = [keyof MongoDocument<T> & string, 1 | -1];
+export type SortArray<T extends Entity = Entity> = SortArrayItem<T>[];
+export type Sort<T extends Entity = Entity> = SortArray<T> | SortObject<T>;
+export type TypedIndexDescription<T extends Entity = Entity> = Omit<Mongo.IndexDescription, 'key' | 'partialFilterExpression'> & {
+    key: {
+        [P in Paths<T>]?: Mongo.IndexDirection;
+    };
+    partialFilterExpression?: Filter<T>;
+};
+export declare function getMongoRepositoryConfig<T extends Entity, TDb extends Entity = T>(config: TypedOmit<MongoRepositoryConfig<T, TDb>, 'types'>): MongoRepositoryConfig<T, TDb>;