@opra/mongodb 0.33.13 → 1.0.0-alpha.2

package/esm/mongo-array-service.js

@@ -1,563 +0,0 @@
-import omit from 'lodash.omit';
-import { ObjectId } from 'mongodb';
-import { ComplexType, NotAcceptableError, ResourceNotAvailableError } from '@opra/common';
-import { MongoAdapter } from './mongo-adapter.js';
-import { MongoService } from './mongo-service.js';
-/**
- * A class that provides methods to perform operations on an array field in a MongoDB collection.
- * @template T The type of the array item.
- */
-export class MongoArrayService extends MongoService {
-    /**
-     * Constructs a new instance
-     *
-     * @param {Type | string} dataType - The data type of the array elements.
-     * @param {string} fieldName - The name of the field in the document representing the array.
-     * @param {MongoArrayService.Options} [options] - The options for the array service.
-     * @constructor
-     */
-    constructor(dataType, fieldName, options) {
-        super(dataType, options);
-        this.fieldName = fieldName;
-        this.defaultLimit = options?.defaultLimit || 10;
-        this.collectionKey = options?.collectionKey || '_id';
-        this.arrayKey = options?.arrayKey || '_id';
-        this.$documentFilter = options?.documentFilter;
-        this.$arrayFilter = options?.arrayFilter;
-        this.$interceptor = this.$interceptor || options?.interceptor;
-    }
-    /**
-     * Asserts whether a resource with the specified parentId and id exists.
-     * Throws a ResourceNotFoundError if the resource does not exist.
-     *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {AnyId} id - The ID of the resource.
-     * @param {MongoArrayService.ExistsOptions} [options] - Optional parameters for checking resource existence.
-     * @return {Promise<void>} - A promise that resolves with no value upon success.
-     * @throws {ResourceNotAvailableError} - If the resource does not exist.
-     */
-    async assert(documentId, id, options) {
-        if (!(await this.exists(documentId, id, options)))
-            throw new ResourceNotAvailableError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
-    }
-    /**
-     * Adds a single item into the array field.
-     *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {T} input - The item to be added to the array field.
-     * @param {MongoArrayService.CreateOptions} [options] - Optional options for the create operation.
-     * @return {Promise<PartialDTO<T>>} - A promise that resolves with the partial output of the created item.
-     * @throws {ResourceNotAvailableError} - If the parent document is not found.
-     */
-    async create(documentId, input, options) {
-        const info = {
-            crud: 'create',
-            method: 'create',
-            byId: false,
-            documentId,
-            itemId: input._id,
-            input,
-            options
-        };
-        return this._intercept(() => this._create(documentId, input, options), info);
-    }
-    async _create(documentId, input, options) {
-        const encode = this.getEncoder('create');
-        const doc = encode(input, { coerce: true });
-        doc._id = doc._id || this._generateId();
-        const docFilter = MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]);
-        const r = await this.__updateOne(docFilter, {
-            $push: { [this.fieldName]: doc }
-        }, options);
-        if (r.matchedCount) {
-            if (!options)
-                return doc;
-            const id = doc[this.arrayKey];
-            const out = await this._findById(documentId, id, {
-                ...options,
-                filter: undefined,
-                skip: undefined
-            });
-            if (out)
-                return out;
-        }
-        throw new ResourceNotAvailableError(this.getResourceName(), documentId);
-    }
-    /**
-     * Counts the number of documents in the collection that match the specified parentId and options.
-     *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {object} options - Optional parameters for counting.
-     * @param {object} options.filter - The filter object to apply to the count operation.
-     * @returns {Promise<number>} - A promise that resolves to the count of documents.
-     */
-    async count(documentId, options) {
-        const info = {
-            crud: 'read',
-            method: 'count',
-            byId: false,
-            documentId,
-            options
-        };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._count(documentId, { ...options, filter, documentFilter });
-        }, info);
-    }
-    async _count(documentId, options) {
-        const matchFilter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            options?.documentFilter
-        ]);
-        const stages = [
-            { $match: matchFilter },
-            { $unwind: { path: "$" + this.fieldName } },
-            { $replaceRoot: { newRoot: "$" + this.fieldName } }
-        ];
-        if (options?.filter) {
-            const filter = MongoAdapter.prepareFilter(options?.filter);
-            stages.push({ $match: filter });
-        }
-        stages.push({ $count: '*' });
-        const r = await this.__aggregate(stages, options);
-        try {
-            const n = await r.next();
-            return n?.['*'] || 0;
-        }
-        finally {
-            await r.close();
-        }
-    }
-    /**
-     * Deletes an element from an array within a document in the MongoDB collection.
-     *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {AnyId} id - The ID of the element to delete from the array.
-     * @param {MongoArrayService.DeleteOptions<T>} [options] - Additional options for the delete operation.
-     * @return {Promise<number>} - A Promise that resolves to the number of elements deleted (1 if successful, 0 if not).
-     */
-    async delete(documentId, id, options) {
-        const info = {
-            crud: 'delete',
-            method: 'delete',
-            byId: true,
-            documentId,
-            itemId: id,
-            options
-        };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._delete(documentId, id, { ...options, filter, documentFilter });
-        }, info);
-    }
-    async _delete(documentId, id, options) {
-        const matchFilter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            options?.documentFilter
-        ]);
-        const pullFilter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(id, [this.arrayKey]),
-            options?.filter
-        ]) || {};
-        const r = await this.__updateOne(matchFilter, {
-            $pull: { [this.fieldName]: pullFilter }
-        }, options);
-        return r.modifiedCount ? 1 : 0;
-    }
-    /**
-     * Deletes multiple items from a collection based on the parent ID and optional filter.
-     *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {MongoArrayService.DeleteManyOptions<T>} options - Optional options to specify a filter.
-     * @returns {Promise<number>} - A Promise that resolves to the number of items deleted.
-     */
-    async deleteMany(documentId, options) {
-        const info = {
-            crud: 'delete',
-            method: 'deleteMany',
-            byId: false,
-            documentId,
-            options
-        };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._deleteMany(documentId, { ...options, filter, documentFilter });
-        }, info);
-    }
-    async _deleteMany(documentId, options) {
-        const matchFilter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            options?.documentFilter
-        ]);
-        // Count matching items, we will use this as result
-        const matchCount = await this.count(documentId, options);
-        const pullFilter = MongoAdapter.prepareFilter(options?.filter) || {};
-        const r = await this.__updateOne(matchFilter, {
-            $pull: { [this.fieldName]: pullFilter }
-        }, options);
-        if (r.modifiedCount)
-            return matchCount;
-        return 0;
-    }
-    /**
-     * Checks if an array element with the given parentId and id exists.
-     *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {AnyId} id - The id of the record.
-     * @param {MongoArrayService.ExistsOptions} [options] - The options for the exists method.
-     * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating if the record exists or not.
-     */
-    async exists(documentId, id, options) {
-        return !!(await this.findById(documentId, id, { ...options, pick: ['_id'], omit: undefined, include: undefined }));
-    }
-    /**
-     * Finds an element in array field by its parent ID and ID.
-     *
-     * @param {AnyId} documentId - The ID of the document.
-     * @param {AnyId} id - The ID of the document.
-     * @param {MongoArrayService.FindOneOptions} [options] - The optional options for the operation.
-     * @returns {Promise<PartialDTO<T> | undefined>} - A promise that resolves to the found document or undefined if not found.
-     */
-    async findById(documentId, id, options) {
-        const info = {
-            crud: 'read',
-            method: 'findById',
-            byId: true,
-            documentId,
-            itemId: id,
-            options
-        };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._findById(documentId, id, { ...options, filter, documentFilter });
-        }, info);
-    }
-    async _findById(documentId, id, options) {
-        const filter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(id, [this.arrayKey]),
-            options?.filter
-        ]);
-        const rows = await this._findMany(documentId, {
-            ...options,
-            filter,
-            limit: 1,
-            skip: undefined,
-            sort: undefined
-        });
-        return rows?.[0];
-    }
-    /**
-     * Finds the first array element that matches the given parentId.
-     *
-     * @param {AnyId} documentId - The ID of the document.
-     * @param {MongoArrayService.FindOneOptions} [options] - Optional options to customize the query.
-     * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the first matching document, or `undefined` if no match is found.
-     */
-    async findOne(documentId, options) {
-        const info = {
-            crud: 'read',
-            method: 'findOne',
-            byId: false,
-            documentId,
-            options
-        };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._findOne(documentId, { ...options, filter, documentFilter });
-        }, info);
-    }
-    async _findOne(documentId, options) {
-        const rows = await this._findMany(documentId, {
-            ...options,
-            limit: 1
-        });
-        return rows?.[0];
-    }
-    /**
-     * Finds multiple elements in an array field.
-     *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {MongoArrayService.FindManyOptions<T>} [options] - The options for finding the documents.
-     * @returns {Promise<PartialDTO<T>[]>} - The found documents.
-     */
-    async findMany(documentId, options) {
-        const args = {
-            crud: 'read',
-            method: 'findMany',
-            byId: false,
-            documentId,
-            options
-        };
-        return this._intercept(async () => {
-            const documentFilter = await this._getDocumentFilter(args);
-            const arrayFilter = await this._getArrayFilter(args);
-            return this._findMany(documentId, { ...options, documentFilter, arrayFilter });
-        }, args);
-    }
-    async _findMany(documentId, options) {
-        const matchFilter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            options.documentFilter
-        ]);
-        const mongoOptions = {
-            ...omit(options, ['pick', 'include', 'omit', 'sort', 'skip', 'limit', 'filter', 'count'])
-        };
-        const limit = options?.limit || this.defaultLimit;
-        const stages = [
-            { $match: matchFilter },
-            { $unwind: { path: "$" + this.fieldName } },
-            { $replaceRoot: { newRoot: "$" + this.fieldName } }
-        ];
-        let dataStages = stages;
-        if (options?.count) {
-            dataStages = [];
-            stages.push({
-                $facet: {
-                    data: dataStages,
-                    count: [{ $count: 'totalMatches' }]
-                }
-            });
-        }
-        if (options?.filter || options.arrayFilter) {
-            const optionsFilter = MongoAdapter.prepareFilter([
-                options?.filter,
-                options.arrayFilter
-            ]);
-            dataStages.push({ $match: optionsFilter });
-        }
-        if (options?.skip)
-            dataStages.push({ $skip: options.skip });
-        if (options?.sort) {
-            const sort = MongoAdapter.prepareSort(options.sort);
-            if (sort)
-                dataStages.push({ $sort: sort });
-        }
-        dataStages.push({ $limit: limit });
-        const dataType = this.getDataType();
-        const projection = MongoAdapter.prepareProjection(dataType, options);
-        if (projection)
-            dataStages.push({ $project: projection });
-        const decode = this.getDecoder();
-        const cursor = await this.__aggregate(stages, {
-            ...mongoOptions
-        });
-        try {
-            if (options?.count) {
-                const facetResult = await cursor.toArray();
-                this.context.response.totalMatches = facetResult[0].count[0].totalMatches || 0;
-                return facetResult[0].data.map((r) => decode(r, { coerce: true }));
-            }
-            else
-                return await cursor.toArray();
-        }
-        finally {
-            if (!cursor.closed)
-                await cursor.close();
-        }
-    }
-    /**
-     * Retrieves a specific item from the array of a document.
-     *
-     * @param {AnyId} documentId - The ID of the document.
-     * @param {AnyId} id - The ID of the item.
-     * @param {MongoArrayService.FindOneOptions<T>} [options] - The options for finding the item.
-     * @returns {Promise<PartialDTO<T>>} - The item found.
-     * @throws {ResourceNotAvailableError} - If the item is not found.
-     */
-    async get(documentId, id, options) {
-        const out = await this.findById(documentId, id, options);
-        if (!out)
-            throw new ResourceNotAvailableError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
-        return out;
-    }
-    /**
-     * Updates an array element with new data and returns the updated element
-     *
-     * @param {AnyId} documentId - The ID of the document to update.
-     * @param {AnyId} id - The ID of the item to update within the document.
-     * @param {PatchDTO<T>} input - The new data to update the item with.
-     * @param {MongoArrayService.UpdateOptions<T>} [options] - Additional update options.
-     * @returns {Promise<PartialDTO<T> | undefined>} The updated item or undefined if it does not exist.
-     * @throws {Error} If an error occurs while updating the item.
-     */
-    async update(documentId, id, input, options) {
-        const r = await this.updateOnly(documentId, id, input, options);
-        if (!r)
-            return;
-        const out = await this._findById(documentId, id, options);
-        if (out)
-            return out;
-        throw new ResourceNotAvailableError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
-    }
-    /**
-     * Update an array element with new data. Returns 1 if document updated 0 otherwise.
-     *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {AnyId} id - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
-     * @param {MongoArrayService.UpdateOptions<T>} [options] - Optional update options.
-     * @returns {Promise<number>} - A promise that resolves to the number of elements updated.
-     */
-    async updateOnly(documentId, id, input, options) {
-        const info = {
-            crud: 'update',
-            method: 'update',
-            byId: true,
-            documentId,
-            itemId: id,
-            options
-        };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._updateOnly(documentId, id, input, { ...options, filter, documentFilter });
-        }, info);
-    }
-    async _updateOnly(documentId, id, input, options) {
-        let filter = MongoAdapter.prepareKeyValues(id, [this.arrayKey]);
-        if (options?.filter)
-            filter = MongoAdapter.prepareFilter([filter, options?.filter]);
-        return await this._updateMany(documentId, input, { ...options, filter });
-    }
-    /**
-     * Updates multiple array elements in document
-     *
-     * @param {AnyId} documentId - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The updated data for the document(s).
-     * @param {MongoArrayService.UpdateManyOptions<T>} [options] - Additional options for the update operation.
-     * @returns {Promise<number>} - A promise that resolves to the number of documents updated.
-     */
-    async updateMany(documentId, input, options) {
-        const info = {
-            crud: 'update',
-            method: 'updateMany',
-            documentId,
-            byId: false,
-            input,
-            options
-        };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._updateMany(documentId, input, { ...options, filter, documentFilter });
-        }, info);
-    }
-    async _updateMany(documentId, input, options) {
-        const encode = this.getEncoder('update');
-        const doc = encode(input, { coerce: true });
-        if (!Object.keys(doc).length)
-            return 0;
-        const matchFilter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            options?.documentFilter,
-            { [this.fieldName]: { $exists: true } }
-        ]);
-        if (options?.filter) {
-            const elemMatch = MongoAdapter.prepareFilter([options?.filter], { fieldPrefix: 'elem.' });
-            options = options || {};
-            options.arrayFilters = [elemMatch];
-        }
-        const update = MongoAdapter.preparePatch(doc, {
-            fieldPrefix: this.fieldName + (options?.filter ? '.$[elem].' : '.$[].')
-        });
-        const r = await this.__updateOne(matchFilter, update, options);
-        if (!options?.count)
-            return r.modifiedCount;
-        return r.modifiedCount
-            // Count matching items that fits filter criteria
-            ? await this._count(documentId, options)
-            : 0;
-    }
-    /**
-     * Retrieves the data type of the array field
-     *
-     * @returns {ComplexType} The complex data type of the field.
-     * @throws {NotAcceptableError} If the data type is not a ComplexType.
-     */
-    getDataType() {
-        const t = super.getDataType()
-            .getField(this.fieldName).type;
-        if (!(t instanceof ComplexType))
-            throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
-        return t;
-    }
-    /**
-     * Generates an ID.
-     *
-     * @protected
-     * @returns {AnyId} The generated ID.
-     */
-    _generateId() {
-        return typeof this.$idGenerator === 'function' ?
-            this.$idGenerator(this) : new ObjectId();
-    }
-    /**
-     * Retrieves the common filter used for querying documents.
-     * This method is mostly used for security issues like securing multi-tenant applications.
-     *
-     * @protected
-     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
-     * that resolves to the common filter, or undefined if not available.
-     */
-    _getDocumentFilter(args) {
-        return typeof this.$documentFilter === 'function' ?
-            this.$documentFilter(args, this) : this.$documentFilter;
-    }
-    /**
-     * Retrieves the common filter used for querying array elements.
-     * This method is mostly used for security issues like securing multi-tenant applications.
-     *
-     * @protected
-     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
-     * that resolves to the common filter, or undefined if not available.
-     */
-    _getArrayFilter(args) {
-        return typeof this.$arrayFilter === 'function' ?
-            this.$arrayFilter(args, this) : this.$arrayFilter;
-    }
-    async _intercept(callback, args) {
-        if (this.$interceptor)
-            return this.$interceptor(callback, args, this);
-        return callback();
-    }
-}

package/esm/types.js

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