@tstdl/base 0.92.167 → 0.93.0

package/database/mongo/mongo-bulk.js

@@ -1,90 +0,0 @@
-import { mongoDocumentFromMaybeNewEntity, toEntity, toMongoDocument } from './model/document.js';
-import { deleteManyOperation, deleteOneOperation, insertOneOperation, replaceOneOperation, updateManyOperation, updateOneOperation } from './operations.js';
-export class MongoBulk {
-    collection;
-    operations;
-    executed;
-    constructor(collection) {
-        this.collection = collection;
-        this.operations = [];
-        this.executed = false;
-    }
-    /**
-     * execute operations
-     * @param ordered whether operations must be executed in order (slower) (default: false)
-     */
-    async execute(ordered = false) {
-        if (this.executed) {
-            throw new Error('already executed');
-        }
-        this.executed = true;
-        if (this.operations.length == 0) {
-            throw new Error('no operations specified');
-        }
-        const result = await this.collection.bulkWrite(this.operations, { ordered });
-        return {
-            insertedCount: result.insertedCount,
-            matchedCount: result.matchedCount,
-            modifiedCount: result.modifiedCount,
-            deletedCount: result.deletedCount,
-            upsertedCount: result.upsertedCount,
-            raw: result
-        };
-    }
-    insert(entity) {
-        const document = mongoDocumentFromMaybeNewEntity(entity);
-        const operation = insertOneOperation(document);
-        this.operations.push(operation);
-        return toEntity(document);
-    }
-    insertMany(entities) {
-        const documents = entities.map(mongoDocumentFromMaybeNewEntity);
-        const operations = documents.map(insertOneOperation);
-        this.operations.push(...operations);
-        return documents.map(toEntity);
-    }
-    update(filter, update, options) {
-        const operation = updateOneOperation(filter, update, options);
-        this.operations.push(operation);
-        return this;
-    }
-    updateMany(filter, update, options) {
-        const operation = updateManyOperation(filter, update, options);
-        this.operations.push(operation);
-        return this;
-    }
-    replace(entity, options) {
-        return this.replaceByFilter({ _id: entity.id }, entity, options);
-    }
-    replaceMany(entities, options) {
-        const documents = entities.map(toMongoDocument);
-        const operations = documents.map((document) => replaceOneOperation({ _id: document._id }, document, options));
-        this.operations.push(...operations);
-        return this;
-    }
-    replaceByFilter(filter, entity, options) {
-        const document = toMongoDocument(entity);
-        const operation = replaceOneOperation(filter, document, options);
-        this.operations.push(operation);
-        return this;
-    }
-    delete(entity) {
-        const filter = { _id: entity.id };
-        return this.deleteByFilter(filter);
-    }
-    deleteMany(entities) {
-        const ids = entities.map((entity) => entity.id);
-        const filter = { _id: { $in: ids } };
-        return this.deleteManyByFilter(filter);
-    }
-    deleteByFilter(filter) {
-        const operation = deleteOneOperation(filter);
-        this.operations.push(operation);
-        return this;
-    }
-    deleteManyByFilter(filter) {
-        const operation = deleteManyOperation(filter);
-        this.operations.push(operation);
-        return this;
-    }
-}

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

@@ -1,98 +0,0 @@
-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/mongo-entity-repository.js

@@ -1,278 +0,0 @@
-import { EntityRepository } from '../../database/index.js';
-import { afterResolve } from '../../injector/index.js';
-import { equals } from '../../utils/equals.js';
-import { filterUndefinedObjectProperties, objectEntries, objectKeys } from '../../utils/object/object.js';
-import { _throw } from '../../utils/throw.js';
-import { isDefined, isUndefined } from '../../utils/type-guards.js';
-import { MongoBaseRepository } from './mongo-base.repository.js';
-import { convertQuery, convertSort } from './query-converter.js';
-export function mapTo(key, transform) {
-    return { key, transform };
-}
-export const noopTransformerFunction = (item) => item;
-export const noopTransformer = {
-    transform: noopTransformerFunction,
-    untransform: noopTransformerFunction
-};
-export function getNoopTransformer() {
-    return noopTransformer;
-}
-export class MongoEntityRepository extends EntityRepository {
-    collection;
-    transformer;
-    logger;
-    indexes;
-    baseRepository;
-    transformerMappingMap;
-    constructor(collection, transformer, { logger, indexes }) {
-        super();
-        this.collection = collection;
-        this.transformer = transformer;
-        this.logger = logger.prefix(`${collection.collectionName}: `);
-        this.indexes = indexes?.map(normalizeIndex);
-        this.baseRepository = new MongoBaseRepository(collection);
-        this.transformerMappingMap = new Map(objectEntries(transformer.mapping ?? {}));
-    }
-    async [afterResolve]() {
-        await this.initialize();
-    }
-    async initialize() {
-        const indexes = this.indexes?.map((index) => ({ index, normalizedIndex: normalizeIndex(index) }));
-        if (isUndefined(indexes)) {
-            return;
-        }
-        const existingRawIndexes = await this.collection.indexes();
-        const existingIndexes = existingRawIndexes.map(normalizeIndex).filter((index) => index.name != '_id_');
-        const unwantedIndexes = existingIndexes.filter((existingIndex) => !indexes.some(({ normalizedIndex }) => equals(existingIndex, normalizedIndex, { deep: true, sortArray: false })));
-        const requiredIndexes = indexes.filter(({ normalizedIndex: wantedNormalizedIndex }) => !existingIndexes.some((index) => equals(wantedNormalizedIndex, index, { deep: true, sortArray: false })));
-        for (const unwantedIndex of unwantedIndexes) {
-            this.logger.warn(`dropping index ${unwantedIndex.name}`);
-            await this.collection.dropIndex(unwantedIndex.name);
-        }
-        if (requiredIndexes.length > 0) {
-            const indexexToCreate = requiredIndexes.map(({ index }) => index);
-            const indexNames = indexexToCreate.map((index) => index.name ?? _throw(new Error('index name missing')));
-            this.logger.warn(`creating indexes ${indexNames.join(', ')}`);
-            await this.baseRepository.createIndexes(indexexToCreate);
-        }
-    }
-    async load(id) {
-        return this.loadByFilter({ id });
-    }
-    async tryLoad(id) {
-        return this.tryLoadByFilter({ id });
-    }
-    async loadMany(ids, options) {
-        return this.loadManyByFilter({ id: { $in: ids } }, options);
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async *loadManyCursor(ids, options) {
-        yield* this.loadManyByFilterCursor({ id: { $in: ids } }, options);
-    }
-    async loadByFilter(filter, options) {
-        const transformedFilter = this.transformFilter(filter);
-        const entity = await this.baseRepository.loadByFilter(transformedFilter, convertOptions(options, this.transformerMappingMap));
-        return this.transformer.untransform(entity);
-    }
-    async tryLoadByFilter(filter, options) {
-        const transformedFilter = this.transformFilter(filter);
-        const entity = await this.baseRepository.tryLoadByFilter(transformedFilter, convertOptions(options, this.transformerMappingMap));
-        return entity == undefined ? undefined : this.transformer.untransform(entity);
-    }
-    async loadManyByFilter(filter, options) {
-        const transformedFilter = this.transformFilter(filter);
-        const entities = await this.baseRepository.loadManyByFilter(transformedFilter, convertOptions(options, this.transformerMappingMap));
-        return entities.map(this.transformer.untransform);
-    }
-    async *loadManyByFilterCursor(filter, options) {
-        const transformedFilter = this.transformFilter(filter);
-        for await (const entity of this.baseRepository.loadManyByFilterWithCursor(transformedFilter, convertOptions(options, this.transformerMappingMap))) {
-            yield this.transformer.untransform(entity);
-        }
-    }
-    async loadAll(options) {
-        const entities = await this.baseRepository.loadManyByFilter({}, convertOptions(options, this.transformerMappingMap));
-        return entities.map((entity) => this.transformer.untransform(entity));
-    }
-    async *loadAllCursor(options) {
-        for await (const entity of this.baseRepository.loadManyByFilterWithCursor({}, convertOptions(options, this.transformerMappingMap))) {
-            yield this.transformer.untransform(entity);
-        }
-    }
-    async loadAndDelete(id) {
-        return this.loadByFilterAndDelete({ id });
-    }
-    async tryLoadAndDelete(id) {
-        return this.tryLoadByFilterAndDelete({ id });
-    }
-    async loadByFilterAndDelete(filter, options) {
-        const transformedFilter = this.transformFilter(filter);
-        const entity = await this.baseRepository.loadByFilterAndDelete(transformedFilter, convertOptions(options, this.transformerMappingMap));
-        return this.transformer.untransform(entity);
-    }
-    async tryLoadByFilterAndDelete(filter, options) {
-        const transformedFilter = this.transformFilter(filter);
-        const entity = await this.baseRepository.tryLoadByFilterAndDelete(transformedFilter, convertOptions(options, this.transformerMappingMap));
-        return entity == undefined ? undefined : this.transformer.untransform(entity);
-    }
-    async loadAndPatch(id, patch, includePatch) {
-        return this.loadByFilterAndPatch({ id }, patch, includePatch);
-    }
-    async tryLoadAndPatch(id, patch, includePatch) {
-        return this.tryLoadByFilterAndPatch({ id }, patch, includePatch);
-    }
-    async loadByFilterAndPatch(filter, patch, includePatch, options) {
-        const transformedFilter = this.transformFilter(filter);
-        const update = this.transformPatch(patch);
-        const loadOptions = convertOptions(options, this.transformerMappingMap) ?? {};
-        const entity = await this.baseRepository.loadByFilterAndUpdate(transformedFilter, update, { ...loadOptions, returnDocument: includePatch ? 'after' : 'before' });
-        return this.transformer.untransform(entity);
-    }
-    async tryLoadByFilterAndPatch(filter, patch, includePatch, options) {
-        const transformedFilter = this.transformFilter(filter);
-        const update = this.transformPatch(patch);
-        const loadOptions = convertOptions(options, this.transformerMappingMap) ?? {};
-        const entity = await this.baseRepository.tryLoadByFilterAndUpdate(transformedFilter, update, { ...loadOptions, returnDocument: includePatch ? 'after' : 'before' });
-        return entity == undefined ? undefined : this.transformer.untransform(entity);
-    }
-    async has(id) {
-        return this.hasByFilter({ id });
-    }
-    async hasByFilter(filter) {
-        const transformedFilter = this.transformFilter(filter);
-        return this.baseRepository.hasByFilter(transformedFilter);
-    }
-    async hasMany(ids) {
-        const transformedFilter = this.transformFilter({ id: { $in: ids } });
-        return this.baseRepository.getIdsByFilter(transformedFilter);
-    }
-    async hasAll(ids) {
-        const transformedFilter = this.transformFilter({ id: { $in: ids } });
-        const count = await this.baseRepository.countByFilter(transformedFilter);
-        return count == ids.length;
-    }
-    async count(allowEstimation = false) {
-        if (allowEstimation) {
-            return this.baseRepository.countByFilterEstimated();
-        }
-        return this.baseRepository.countByFilter({});
-    }
-    async countByFilter(filter, _allowEstimation = false) {
-        const transformedFilter = this.transformFilter(filter);
-        return this.baseRepository.countByFilter(transformedFilter);
-    }
-    async patch(entity, patch) {
-        return this.patchByFilter({ _id: entity.id }, patch);
-    }
-    async patchMany(entities, patch) {
-        const ids = entities.map((entity) => entity.id);
-        return this.patchManyByFilter({ _id: { $in: ids } }, patch);
-    }
-    async patchByFilter(filter, patch) {
-        const transformedFilter = this.transformFilter(filter);
-        const transformedPatch = this.transformPatch(patch);
-        const { matchedCount } = await this.baseRepository.update(transformedFilter, transformedPatch);
-        return matchedCount > 0;
-    }
-    async patchManyByFilter(filter, patch) {
-        const transformedFilter = this.transformFilter(filter);
-        const transformedPatch = this.transformPatch(patch);
-        const { matchedCount } = await this.baseRepository.updateMany(transformedFilter, transformedPatch);
-        return matchedCount;
-    }
-    async insert(entity) {
-        const transformed = this.transformer.transform(entity);
-        const insertedEntity = await this.baseRepository.insert(transformed);
-        return this.transformer.untransform(insertedEntity);
-    }
-    async insertMany(entities) {
-        const transformed = entities.map((entity) => this.transformer.transform(entity));
-        const insertedEntities = await this.baseRepository.insertMany(transformed);
-        return insertedEntities.map((insertedEntity) => this.transformer.untransform(insertedEntity));
-    }
-    async insertIfNotExists(entity) {
-        const transformed = this.transformer.transform(entity);
-        const insertedEntity = await this.baseRepository.insertIfNotExists(transformed);
-        return isUndefined(insertedEntity) ? undefined : this.transformer.untransform(insertedEntity);
-    }
-    async insertManyIfNotExists(entities) {
-        const transformed = entities.map((entity) => this.transformer.transform(entity));
-        const insertedEntities = await this.baseRepository.insertManyIfNotExists(transformed);
-        return insertedEntities.map((insertedEntity) => this.transformer.untransform(insertedEntity));
-    }
-    async insertIfNotExistsByFilter(query, entity) {
-        const transformedFilter = this.transformFilter(query);
-        const transformed = this.transformer.transform(entity);
-        const document = await this.baseRepository.insertIfNotExistsByFilter(transformedFilter, transformed);
-        return isUndefined(document) ? undefined : this.transformer.untransform(document);
-    }
-    async insertManyIfNotExistsByFilter(items) {
-        const transformedItems = items.map((item) => ({
-            filter: this.transformFilter(item.query),
-            entity: this.transformer.transform(item.entity)
-        }));
-        const insertedEntities = await this.baseRepository.insertManyIfNotExistsByFilter(transformedItems);
-        return insertedEntities.map((insertedEntity) => this.transformer.untransform(insertedEntity));
-    }
-    async update(entity, options) {
-        const transformed = this.transformer.transform(entity);
-        return this.baseRepository.replace(transformed, options);
-    }
-    async updateMany(entities, options) {
-        const transformed = entities.map((entity) => this.transformer.transform(entity));
-        return this.baseRepository.replaceMany(transformed, options);
-    }
-    async delete(entity) {
-        return this.deleteById(entity.id);
-    }
-    async deleteMany(entities) {
-        const ids = entities.map((entity) => entity.id);
-        return this.deleteManyByFilter({ id: { $in: ids } });
-    }
-    async deleteById(id) {
-        return this.deleteByFilter({ id });
-    }
-    async deleteManyById(ids) {
-        return this.deleteManyByFilter({ id: { $in: ids } });
-    }
-    async deleteByFilter(filter) {
-        const transformedFilter = this.transformFilter(filter);
-        return this.baseRepository.deleteByFilter(transformedFilter);
-    }
-    async deleteManyByFilter(filter) {
-        const transformedFilter = this.transformFilter(filter);
-        return this.baseRepository.deleteManyByFilter(transformedFilter);
-    }
-    transformFilter(filter) {
-        return convertQuery(filter, this.transformerMappingMap);
-    }
-    transformPatch(patch) {
-        const transformedPatch = {};
-        for (const [property, value] of objectEntries(patch)) {
-            const mapping = this.transformerMappingMap.get(property);
-            if (isDefined(mapping)) {
-                transformedPatch[mapping.key] = mapping.transform(value);
-            }
-            else {
-                transformedPatch[property] = value;
-            }
-        }
-        return { $set: { ...transformedPatch } };
-    }
-}
-function normalizeIndex(index) {
-    const { name: providedName, unique, v, background, ns, ...indexRest } = index; // eslint-disable-line @typescript-eslint/no-unused-vars
-    const name = providedName ?? objectKeys(index.key).join('_');
-    return filterUndefinedObjectProperties({ name, unique: (unique == true) ? true : undefined, ...indexRest });
-}
-function convertOptions(options, mappingMap) {
-    if (options == undefined) {
-        return undefined;
-    }
-    const loadOptions = {
-        skip: options.skip,
-        limit: options.limit,
-        sort: options.sort?.map((item) => convertSort(item, mappingMap))
-    };
-    return loadOptions;
-}

package/database/mongo/operations.d.ts

@@ -1,10 +0,0 @@
-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/operations.js

@@ -1,54 +0,0 @@
-export function insertOneOperation(document) {
-    const operation = {
-        insertOne: {
-            document: document
-        }
-    };
-    return operation;
-}
-export function replaceOneOperation(filter, replacement, options = {}) {
-    const operation = {
-        replaceOne: {
-            filter,
-            replacement,
-            upsert: options.upsert
-        }
-    };
-    return operation;
-}
-export function updateOneOperation(filter, update, options = {}) {
-    const operation = {
-        updateOne: {
-            filter,
-            update,
-            upsert: options.upsert
-        }
-    };
-    return operation;
-}
-export function updateManyOperation(filter, update, options = {}) {
-    const operation = {
-        updateMany: {
-            filter,
-            update,
-            upsert: options.upsert
-        }
-    };
-    return operation;
-}
-export function deleteOneOperation(filter) {
-    const operation = {
-        deleteOne: {
-            filter
-        }
-    };
-    return operation;
-}
-export function deleteManyOperation(filter) {
-    const operation = {
-        deleteMany: {
-            filter
-        }
-    };
-    return operation;
-}

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

@@ -1,6 +0,0 @@
-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/query-converter.js

@@ -1,83 +0,0 @@
-import { allQueryTypes } from '../../database/index.js';
-import { objectEntries } from '../../utils/object/object.js';
-import { assertDefinedPass, isDefined, isObject, isPrimitive, isRegExp, isString } from '../../utils/type-guards.js';
-const operatorsSet = new Set(allQueryTypes);
-export function convertQuery(query, mappingMap = new Map(), transform) {
-    let filterQuery = {};
-    const entries = objectEntries(query);
-    for (const [property, value] of entries) {
-        const mapping = mappingMap.get(property);
-        switch (property) {
-            case '$and':
-                filterQuery.$and = value.map((innerQuery) => convertQuery(innerQuery, mappingMap, transform));
-                break;
-            case '$or':
-                filterQuery.$or = value.map((innerQuery) => convertQuery(innerQuery, mappingMap, transform));
-                break;
-            case '$nor':
-                filterQuery.$nor = value.map((innerQuery) => convertQuery(innerQuery, mappingMap, transform));
-                break;
-            default:
-                if (operatorsSet.has(property)) {
-                    const operatorQuery = convertOperator(property, value, mapping?.transform ?? transform, mappingMap);
-                    filterQuery = { ...filterQuery, ...operatorQuery };
-                }
-                else {
-                    const mappedPropertyName = getPropertyName(mapping?.key ?? property);
-                    filterQuery[mappedPropertyName] = convertInnerQuery(value, mapping?.transform ?? transform, mappingMap);
-                }
-        }
-    }
-    return filterQuery;
-}
-function getPropertyName(property) {
-    return (property == 'id') ? '_id' : property;
-}
-function convertInnerQuery(query, transform, mapping) {
-    if (isPrimitive(query)) {
-        return transform?.(query) ?? query;
-    }
-    const queryEntries = objectEntries(query);
-    if (queryEntries.length > 1) {
-        const operators = queryEntries.map((entry) => entry[0]);
-        throw new Error(`only one operator allowed but got ${JSON.stringify(operators)}`);
-    }
-    const [operator, value] = assertDefinedPass(queryEntries[0], 'missing query body');
-    return convertOperator(operator, value, transform, mapping);
-}
-// eslint-disable-next-line complexity
-function convertOperator(operator, value, transform, mapping) {
-    switch (operator) {
-        case '$eq':
-        case '$not':
-        case '$exists':
-        case '$gt':
-        case '$gte':
-        case '$lt':
-        case '$lte':
-            return { [operator]: convertInnerQuery(value, transform) };
-        case '$neq':
-            return { $ne: convertInnerQuery(value, transform) };
-        case '$in':
-            return { $in: isDefined(transform) ? value.map(transform) : value };
-        case '$nin':
-            return { $nin: isDefined(transform) ? value.map(transform) : value };
-        case '$all':
-            return { $all: isDefined(transform) ? value.map(transform) : value };
-        case '$item':
-            return { $elemMatch: isObject(value) ? convertQuery(value, mapping, transform) : transform?.(value) ?? value };
-        case '$regex':
-            if (isString(value) || isRegExp(value)) {
-                return { $regex: value };
-            }
-            return {
-                $regex: value.pattern,
-                $options: value.flags
-            };
-        default: throw new Error(`unsupported inner-operator ${operator}`);
-    }
-}
-export function convertSort(sort, mappingMap) {
-    const field = mappingMap.get(sort.field)?.key ?? sort.field;
-    return [field, sort.order == 'desc' ? -1 : 1];
-}

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

@@ -1,7 +0,0 @@
-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/simple-entity-repository.js

@@ -1,6 +0,0 @@
-import { MongoEntityRepository, noopTransformer } from './mongo-entity-repository.js';
-export class SimpleMongoEntityRepository extends MongoEntityRepository {
-    constructor(collection, logger) {
-        super(collection, noopTransformer, { logger });
-    }
-}