@tstdl/base 0.92.167 → 0.93.0

package/database/mongo/index.js

@@ -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';

package/database/mongo/model/document.d.ts

@@ -1,29 +0,0 @@
-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/model/document.js

@@ -1,63 +0,0 @@
-import { getNewId } from '../../../database/index.js';
-import { isDefined } from '../../../utils/type-guards.js';
-import { ProjectionMode } from '../mongo-base.repository.js';
-export function toEntity(document) {
-    const { _id, ...entityRest } = document;
-    const entity = {
-        id: _id,
-        ...entityRest
-    };
-    return entity;
-}
-export function toNewEntity(entity) {
-    const { id, ...rest } = entity;
-    return rest;
-}
-export function toProjectedEntity(document) {
-    const { _id, ...documentRest } = document;
-    const partialIdObject = (_id != undefined) ? { id: _id } : undefined;
-    const entity = {
-        ...partialIdObject,
-        ...documentRest
-    };
-    return entity;
-}
-export function toMongoProjection(mode, projection) {
-    const { id, ...projectionRest } = projection;
-    const partialIdObject = (id != undefined) ? { _id: id } : (mode == ProjectionMode.Include) ? { _id: false } : undefined;
-    const mongoProjection = {
-        ...partialIdObject,
-        ...projectionRest
-    };
-    return mongoProjection;
-}
-export function toMongoDocument(entity) {
-    return renameIdPropertyToUnderscoreId(entity);
-}
-export function toMongoDocumentWithPartialId(entity) {
-    return renameIdPropertyToUnderscoreId(entity);
-}
-export function toMongoDocumentWithoutId(entity) {
-    const { id, ...entityRest } = entity; // eslint-disable-line @typescript-eslint/no-unused-vars
-    const document = {
-        ...entityRest
-    };
-    return document;
-}
-export function mongoDocumentFromMaybeNewEntity(entity) {
-    const { id, ...entityRest } = entity;
-    const document = {
-        _id: id ?? getNewId(),
-        ...entityRest
-    };
-    return document;
-}
-export function renameIdPropertyToUnderscoreId(object) {
-    const { id, ...rest } = object;
-    const partialIdObject = isDefined(id) ? { _id: id } : undefined;
-    const document = {
-        ...partialIdObject,
-        ...rest
-    };
-    return document;
-}

package/database/mongo/model/index.d.ts

@@ -1 +0,0 @@
-export * from './document.js';

package/database/mongo/model/index.js

@@ -1 +0,0 @@
-export * from './document.js';

package/database/mongo/module.d.ts

@@ -1,8 +0,0 @@
-import type { MongoConnection } from './types.js';
-export type MongoModuleConfig = {
-    defaultConnection: MongoConnection;
-    defaultDatabase: string | undefined;
-    logPrefix: string;
-};
-export declare const mongoModuleConfig: MongoModuleConfig;
-export declare function configureMongo(config: Partial<MongoModuleConfig>): void;

package/database/mongo/module.js

@@ -1,68 +0,0 @@
-import { connect } from '../../core.js';
-import { Injector } from '../../injector/injector.js';
-import { Logger } from '../../logger/index.js';
-import { assertDefined, isObject, isString } from '../../utils/type-guards.js';
-import { Collection, Database, MongoClient } from './classes.js';
-export const mongoModuleConfig = {
-    defaultConnection: { url: 'mongodb://localhost:27017/test-db' },
-    defaultDatabase: undefined,
-    logPrefix: 'Mongo',
-};
-export function configureMongo(config) {
-    mongoModuleConfig.defaultDatabase = config.defaultDatabase ?? mongoModuleConfig.defaultDatabase;
-    mongoModuleConfig.defaultConnection = config.defaultConnection ?? mongoModuleConfig.defaultConnection;
-    mongoModuleConfig.logPrefix = config.logPrefix ?? mongoModuleConfig.logPrefix;
-}
-Injector.registerSingleton(MongoClient, {
-    useFactory(argument, context) {
-        assertDefined(argument, 'mongo connection resolve argument missing');
-        const { url, ...options } = argument;
-        const logger = context.resolve(Logger, mongoModuleConfig.logPrefix);
-        const client = new MongoClient(url, options);
-        client
-            .on('fullsetup', () => logger.verbose('connection setup'))
-            .on('reconnect', () => logger.warn('reconnected'))
-            .on('timeout', () => logger.warn('connection timed out'))
-            .on('close', () => logger.verbose('connection closed'));
-        context.addDisposeHandler(async () => client.close());
-        context.data.logger = logger;
-        context.data.url = url;
-        return client;
-    },
-    async afterResolve(client, _argument, { cancellationSignal, data: { url, logger } }) {
-        await connect(`mongo at ${url}`, async () => client.connect(), logger, cancellationSignal);
-    },
-}, {
-    defaultArgumentProvider: () => mongoModuleConfig.defaultConnection,
-    argumentIdentityProvider: JSON.stringify,
-});
-Injector.registerSingleton(Database, {
-    useFactory: (argument, context) => {
-        const connection = isObject(argument) ? argument.connection : mongoModuleConfig.defaultConnection;
-        const name = (isString(argument) ? argument : isObject(argument) ? argument.database : undefined) ?? mongoModuleConfig.defaultDatabase;
-        const client = context.resolve(MongoClient, connection);
-        return client.db(name);
-    },
-    defaultArgumentProvider: () => ({ database: mongoModuleConfig.defaultDatabase, connection: mongoModuleConfig.defaultConnection }),
-}, {
-    argumentIdentityProvider: JSON.stringify,
-});
-Injector.registerSingleton(Collection, {
-    useFactory: (config, context) => {
-        assertDefined(config, 'mongo repository config resolve argument missing');
-        const database = context.resolve(Database, config);
-        context.data.database = database;
-        return database.collection(config.collection);
-    },
-    async afterResolve(_, config, { data: { database } }) {
-        const existingCollections = await database.collections();
-        for (const collection of existingCollections) {
-            if (collection.collectionName == config.collection) {
-                return;
-            }
-        }
-        await database.createCollection(config.collection);
-    },
-}, {
-    argumentIdentityProvider: JSON.stringify,
-});

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

@@ -1,103 +0,0 @@
-import type { Entity, MaybeNewEntity } from '../../database/index.js';
-import type { Record } from '../../types/index.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-base.repository.js

@@ -1,263 +0,0 @@
-import { NotFoundError } from '../../errors/not-found.error.js';
-import { objectKeys } from '../../utils/object/object.js';
-import { assertDefined, isNull, isNullOrUndefined } from '../../utils/type-guards.js';
-import { mongoDocumentFromMaybeNewEntity, toEntity, toMongoDocument, toMongoProjection, toNewEntity, toProjectedEntity } from './model/document.js';
-import { MongoBulk } from './mongo-bulk.js';
-import { replaceOneOperation, updateOneOperation } from './operations.js';
-export var ProjectionMode;
-(function (ProjectionMode) {
-    ProjectionMode[ProjectionMode["Include"] = 0] = "Include";
-    ProjectionMode[ProjectionMode["Exclude"] = 1] = "Exclude";
-})(ProjectionMode || (ProjectionMode = {}));
-export class MongoBaseRepository {
-    collection;
-    constructor(collection) {
-        this.collection = collection;
-    }
-    async createIndexes(indexes) {
-        await this.collection.createIndexes(indexes);
-    }
-    bulk() {
-        return new MongoBulk(this.collection);
-    }
-    async insert(entity) {
-        const document = mongoDocumentFromMaybeNewEntity(entity);
-        await this.collection.insertOne(document); // eslint-disable-line @typescript-eslint/no-unsafe-argument
-        return toEntity(document);
-    }
-    async insertMany(entities) {
-        if (entities.length == 0) {
-            return [];
-        }
-        const bulk = this.bulk();
-        const documents = bulk.insertMany(entities);
-        await bulk.execute();
-        return documents;
-    }
-    async insertIfNotExists(entity) {
-        const filter = toNewEntity(entity);
-        return this.insertIfNotExistsByFilter(filter, entity);
-    }
-    async insertManyIfNotExists(entities) {
-        const items = entities.map((entity) => ({ filter: toNewEntity(entity), entity }));
-        return this.insertManyIfNotExistsByFilter(items);
-    }
-    async insertIfNotExistsByFilter(filter, entity) {
-        const document = mongoDocumentFromMaybeNewEntity(entity);
-        const result = await this.collection.updateOne(filter, { $setOnInsert: document }, { upsert: true });
-        if (result.upsertedCount == 0) {
-            return undefined;
-        }
-        return toEntity(document);
-    }
-    /**
-     *
-     * @param items
-     * @returns inserted entities - entities which are already in the database are not returned
-     */
-    async insertManyIfNotExistsByFilter(items) {
-        if (items.length == 0) {
-            return [];
-        }
-        const documents = items.map(({ filter, entity }) => ({ filter, document: mongoDocumentFromMaybeNewEntity(entity) }));
-        const documentOperations = documents.map(({ filter, document }) => ({ document, operation: updateOneOperation(filter, { $setOnInsert: document }, { upsert: true }) }));
-        const operations = documentOperations.map((o) => o.operation);
-        const result = await this.collection.bulkWrite(operations, { ordered: false });
-        assertDefined(result.upsertedIds);
-        const entities = objectKeys(result.upsertedIds).map((index) => toEntity(documentOperations[index].document));
-        return entities;
-    }
-    async load(id, options) {
-        const entity = await this.tryLoad(id, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoad(id, options) {
-        return this.tryLoadByFilter({ _id: id }, options);
-    }
-    async loadAndUpdate(id, update, options) {
-        const entity = await this.tryLoadAndUpdate(id, update, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoadAndUpdate(id, update, options) {
-        return this.tryLoadByFilterAndUpdate({ _id: id }, update, options);
-    }
-    async loadAndDelete(id, options) {
-        const entity = await this.tryLoadAndDelete(id, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async loadByFilter(filter, options) {
-        const entity = await this.tryLoadByFilter(filter, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoadByFilter(filter, options) {
-        const document = await this.collection.findOne(filter, options);
-        if (isNullOrUndefined(document)) {
-            return undefined;
-        }
-        return toEntity(document);
-    }
-    async loadProjectedByFilter(filter, mode, projection, options) {
-        const id = await this.tryLoadProjectedByFilter(filter, mode, projection, options);
-        return throwIfUndefinedElsePass(id, this.collection.collectionName);
-    }
-    async tryLoadProjectedByFilter(filter, mode, projection, options) {
-        const document = await this.collection.findOne(filter, { ...options, projection: toMongoProjection(mode, projection) });
-        if (isNullOrUndefined(document)) {
-            return undefined;
-        }
-        return toProjectedEntity(document);
-    }
-    async loadByFilterAndDelete(filter, options) {
-        const entity = await this.tryLoadByFilterAndDelete(filter, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoadAndDelete(id, options) {
-        return this.tryLoadByFilterAndDelete({ _id: id }, options);
-    }
-    async tryLoadByFilterAndDelete(filter, options) {
-        const result = await this.collection.findOneAndDelete(filter, options);
-        if (isNull(result)) {
-            return undefined;
-        }
-        return toEntity(result);
-    }
-    async loadByFilterAndUpdate(filter, update, options) {
-        const entity = await this.tryLoadByFilterAndUpdate(filter, update, options);
-        return throwIfUndefinedElsePass(entity, this.collection.collectionName);
-    }
-    async tryLoadByFilterAndUpdate(filter, update, options) {
-        const document = await this.collection.findOneAndUpdate(filter, update, options);
-        if (isNull(document)) {
-            return undefined;
-        }
-        return toEntity(document);
-    }
-    async loadManyById(ids, options) {
-        const filter = { _id: { $in: ids } };
-        return this.loadManyByFilter(filter, options);
-    }
-    async loadManyByFilter(filter, options) {
-        const documents = await this.collection.find(filter, options).toArray();
-        return documents.map(toEntity);
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    loadManyByIdWithCursor(ids, options) {
-        const filter = { _id: { $in: ids } };
-        return this.loadManyByFilterWithCursor(filter, options);
-    }
-    async *loadManyByFilterWithCursor(filter, options) {
-        const cursor = this.collection.find(filter, options);
-        for await (const document of cursor) {
-            if (isNullOrUndefined(document)) {
-                continue;
-            }
-            yield toEntity(document);
-        }
-    }
-    async loadManyProjectedById(ids, mode, projection, options) {
-        const filter = { _id: { $in: ids } };
-        return this.loadManyProjectedByFilter(filter, mode, projection, options);
-    }
-    async loadManyProjectedByFilter(filter, mode, projection, options) {
-        const documents = await this.collection.find(filter, { ...options, projection: toMongoProjection(mode, projection) }).toArray();
-        return documents.map(toProjectedEntity);
-    }
-    async *loadManyProjectedByFilterWithCursor(filter, mode, projection, options) {
-        const cursor = this.collection.find(filter, { ...options, projection: toMongoProjection(mode, projection) });
-        for await (const document of cursor) {
-            if (isNullOrUndefined(document)) {
-                continue;
-            }
-            yield toProjectedEntity(document);
-        }
-    }
-    async deleteById(id) {
-        return this.deleteByFilter({ _id: id });
-    }
-    async deleteManyById(ids) {
-        if (ids.length == 0) {
-            return 0;
-        }
-        const filter = { _id: { $in: ids } };
-        return this.deleteManyByFilter(filter);
-    }
-    async deleteByFilter(filter) {
-        const { deletedCount } = await this.collection.deleteOne(filter);
-        return deletedCount == 1;
-    }
-    async deleteManyByFilter(filter) {
-        const { deletedCount } = await this.collection.deleteMany(filter);
-        return deletedCount;
-    }
-    async replace(entity, options = {}) {
-        return this.replaceByFilter({ _id: entity.id }, entity, options);
-    }
-    async replaceByFilter(filter, entity, options = {}) {
-        const document = toMongoDocument(entity);
-        const result = await this.collection.replaceOne(filter, document, options);
-        return (result.matchedCount + result.upsertedCount) > 0;
-    }
-    async replaceMany(entities, options) {
-        if (entities.length == 0) {
-            return 0;
-        }
-        const documents = entities.map(toMongoDocument);
-        const operations = documents.map((document) => replaceOneOperation({ _id: document._id }, document, options));
-        const result = await this.collection.bulkWrite(operations);
-        if (result.matchedCount + result.upsertedCount != entities.length) {
-            throw new NotFoundError(`${entities.length - (result.matchedCount + result.upsertedCount)} entities in ${this.collection.collectionName} not found`);
-        }
-        return (result.matchedCount + result.upsertedCount);
-    }
-    async update(filter, update, options = {}) {
-        const { matchedCount, modifiedCount } = await this.collection.updateOne(filter, update, options);
-        const updateResult = {
-            matchedCount,
-            modifiedCount
-        };
-        return updateResult;
-    }
-    async updateMany(filter, update, options = {}) {
-        const { matchedCount, modifiedCount } = await this.collection.updateMany(filter, update, options);
-        const updateResult = {
-            matchedCount,
-            modifiedCount
-        };
-        return updateResult;
-    }
-    async has(id) {
-        return this.hasByFilter({ _id: id });
-    }
-    async hasByFilter(filter) {
-        const count = await this.countByFilter(filter, { limit: 1 });
-        return count > 0;
-    }
-    async hasMany(ids) {
-        const filter = { _id: { $in: ids } };
-        return this.getIdsByFilter(filter);
-    }
-    async getIdsByFilter(filter) {
-        const result = await this.collection.distinct('_id', filter);
-        return result;
-    }
-    async hasAll(ids) {
-        const filter = { _id: { $in: ids } };
-        const count = await this.countByFilter(filter);
-        return count == ids.length;
-    }
-    async countByFilter(filter, { limit, skip } = {}) {
-        return this.collection.countDocuments(filter, { limit, skip });
-    }
-    async countByFilterEstimated() {
-        return this.collection.estimatedDocumentCount();
-    }
-    async drop() {
-        await this.collection.drop();
-    }
-}
-function throwIfUndefinedElsePass(value, collectionName) {
-    if (value == undefined) {
-        throw new NotFoundError(`entity not found in ${collectionName}`);
-    }
-    return value;
-}

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

@@ -1,35 +0,0 @@
-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;
-}