@opra/mongodb 0.31.13 → 0.32.1

package/cjs/adapter-utils/prepare-filter.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("@opra/core");
 const common_1 = require("@opra/common");
 const opMap = {
     '=': '$eq',
@@ -12,17 +11,73 @@ const opMap = {
     'in': '$in',
     '!in': '$nin',
 };
-function prepareFilter(filter) {
-    if (!filter)
-        return;
-    if (typeof filter === 'string')
-        return prepareFilterAst(common_1.OpraFilter.parse(filter));
-    else if (filter instanceof common_1.OpraFilter.Expression)
-        return prepareFilterAst(filter);
-    else
-        return filter;
+/**
+ * Convert filter expressions to MongoDB filter objects.
+ * This method also merges multiple expressions into one single filter object
+ * @param filters
+ */
+function prepareFilter(filters, options) {
+    const filtersArray = Array.isArray(filters) ? filters : [filters];
+    if (!filtersArray.length)
+        return {};
+    let i = 0;
+    const out = {};
+    for (const filter of filtersArray) {
+        if (!filter)
+            continue;
+        let x;
+        if (typeof filter === 'string')
+            x = prepareFilterAst(common_1.OpraFilter.parse(filter));
+        else if (filter instanceof common_1.OpraFilter.Expression)
+            x = prepareFilterAst(filter);
+        else
+            x = filter;
+        if (Array.isArray(x))
+            x = { $and: out };
+        // Merge $and arrays
+        if (x.$and) {
+            out.$and = out.$and || [];
+            out.$and.push(...x.$and);
+            delete x.$and;
+        }
+        // Merge $or arrays
+        if (x.$or) {
+            out.$or = out.$or || [];
+            out.$or.push(...x.$or);
+            delete x.$or;
+        }
+        for (const k of Object.keys(x)) {
+            // If result object has filter field we convert it to $and
+            if (out[k]) {
+                out.$and = out.$and || [];
+                out.$and.push({ [k]: out[k] });
+                out.$and.push({ [k]: x[k] });
+                delete out[k];
+                continue;
+            }
+            out[k] = x[k];
+        }
+        i++;
+    }
+    return i
+        ? (options?.fieldPrefix ? addPrefix(out, options.fieldPrefix) : out)
+        : undefined;
 }
 exports.default = prepareFilter;
+function addPrefix(source, prefix) {
+    if (typeof source !== 'object')
+        return source;
+    if (Array.isArray(source))
+        return source.map(v => addPrefix(v, prefix));
+    const out = {};
+    for (const [k, v] of Object.entries(source)) {
+        if (k.startsWith('$'))
+            out[k] = addPrefix(v, prefix);
+        else
+            out[prefix + k] = addPrefix(v, prefix);
+    }
+    return out;
+}
 function prepareFilterAst(ast, negative) {
     if (!ast)
         return;

package/cjs/adapter-utils/prepare-patch.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 function preparePatch(doc, options) {
     const trg = {};
     _preparePatch(doc, trg, '', options);
+    trg.$set = trg.$set || {};
     return trg;
 }
 exports.default = preparePatch;

package/cjs/adapter-utils/prepare-projection.js

@@ -1,52 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._prepareExclusionProjection = exports._prepareInclusionProjection = void 0;
+exports._prepareProjection = void 0;
 const common_1 = require("@opra/common");
-function prepareProjection(dataType, args) {
+function prepareProjection(dataType, options) {
     const out = {};
-    // omitExclusiveFields(dataType, out);
-    const pick = args?.pick && (0, common_1.pathToObjectTree)(args.include ? [...args.pick, ...args.include] : args.pick);
-    const include = !args?.pick && args?.include && (0, common_1.pathToObjectTree)(args.include);
-    const omit = args?.omit && (0, common_1.pathToObjectTree)(args.omit);
-    if (pick || include) {
-        _prepareInclusionProjection(dataType, out, pick, include, omit);
-    }
-    else
-        _prepareExclusionProjection(dataType, out, omit, !omit);
+    const pick = options?.pick && (0, common_1.pathToObjectTree)(options.pick);
+    const include = options?.include && (0, common_1.pathToObjectTree)(options.include);
+    const omit = options?.omit && (0, common_1.pathToObjectTree)(options.omit);
+    // const exclusionProjection = !pick && !!omit;
+    _prepareProjection(dataType, out, {
+        pickActivated: !!pick,
+        pick,
+        include,
+        omit
+    });
     return Object.keys(out).length ? out : undefined;
 }
 exports.default = prepareProjection;
-function _prepareInclusionProjection(dataType, target, pick, include, omit, defaultFields) {
-    defaultFields = defaultFields ?? !pick;
-    let n;
+function _prepareProjection(dataType, target, 
+// exclusionProjection: boolean,
+options) {
+    // const defaultFields = options?.defaultFields ?? !options?.pick;
+    const optionsOmit = options?.omit;
+    const optionsPick = options?.pick;
+    const optionsInclude = options?.include;
+    const pickActivated = options?.pickActivated;
     for (const [k, f] of dataType.fields.entries()) {
-        if (omit?.[k] === true)
+        const fieldOmit = optionsOmit?.[k];
+        const fieldInclude = optionsInclude?.[k];
+        const fieldPick = optionsPick?.[k];
+        if (fieldOmit === true ||
+            !((pickActivated && fieldPick) ||
+                (!pickActivated && (!f.exclusive || fieldInclude))))
+            continue;
+        if (f.type instanceof common_1.ComplexType &&
+            (typeof fieldInclude === 'object' ||
+                typeof fieldPick === 'object' ||
+                typeof fieldOmit === 'object')) {
+            target[k] = {};
+            _prepareProjection(f.type, target[k], {
+                pickActivated: fieldPick != null && fieldPick !== true,
+                include: typeof fieldInclude === 'object' ? fieldInclude : undefined,
+                pick: typeof fieldPick === 'object' ? fieldPick : undefined,
+                omit: typeof fieldOmit === 'object' ? fieldOmit : undefined
+            });
             continue;
-        n = (defaultFields && !f.exclusive) ||
-            pick === true || pick?.[k] || include === true || include?.[k];
-        if (n) {
-            if (f.type instanceof common_1.ComplexType && (typeof n === 'object' || typeof omit?.[k] === 'object')) {
-                target[k] = {};
-                _prepareInclusionProjection(f.type, target[k], pick?.[k] || include?.[k], undefined, omit?.[k], defaultFields);
-                continue;
-            }
-            target[k] = 1;
-        }
-    }
-}
-exports._prepareInclusionProjection = _prepareInclusionProjection;
-function _prepareExclusionProjection(dataType, target, omit, omitExclusiveFields) {
-    let n;
-    for (const [k, f] of dataType.fields.entries()) {
-        n = omit?.[k] || (omitExclusiveFields && f.exclusive);
-        if (n) {
-            if (f.type instanceof common_1.ComplexType && typeof n === 'object') {
-                target[k] = {};
-                _prepareExclusionProjection(f.type, target[k], omit?.[k], omitExclusiveFields);
-                continue;
-            }
-            target[k] = 0;
         }
+        target[k] = 1;
     }
 }
-exports._prepareExclusionProjection = _prepareExclusionProjection;
+exports._prepareProjection = _prepareProjection;

package/cjs/index.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./mongo-adapter.js"), exports);
+tslib_1.__exportStar(require("./mongo-array-service.js"), exports);
 tslib_1.__exportStar(require("./mongo-collection-service.js"), exports);
 tslib_1.__exportStar(require("./mongo-service.js"), exports);
 tslib_1.__exportStar(require("./mongo-singleton-service.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/mongo-array-service.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoArrayService = void 0;
+const tslib_1 = require("tslib");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const mongodb_1 = require("mongodb");
+const common_1 = require("@opra/common");
+const mongo_adapter_js_1 = require("./mongo-adapter.js");
+const mongo_service_js_1 = require("./mongo-service.js");
+/**
+ *
+ * @class MongoArrayService
+ */
+class MongoArrayService extends mongo_service_js_1.MongoService {
+    constructor(dataType, fieldName, options) {
+        super(dataType, options);
+        this._encoders = {};
+        this.fieldName = fieldName;
+        this.defaultLimit = options?.defaultLimit || 10;
+        this.collectionKey = options?.collectionKey || '_id';
+        this.arrayKey = options?.arrayKey || '_id';
+    }
+    getArrayDataType() {
+        const t = this.getDataType()
+            .getField(this.fieldName).type;
+        if (!(t instanceof common_1.ComplexType))
+            throw new common_1.NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+        return t;
+    }
+    /**
+     * Checks if array item exists. Throws error if not.
+     *
+     * @param parentId
+     * @param id
+     */
+    async assert(parentId, id) {
+        if (!(await this.exists(parentId, id)))
+            throw new common_1.ResourceNotFoundError((this.resourceName || this.getCollectionName()) + '.' + this.arrayKey, parentId + '/' + id);
+    }
+    /**
+     * Adds a single item into array field.
+     *
+     * @param parentId
+     * @param input
+     * @param options
+     */
+    async create(parentId, input, options) {
+        const encode = this._getEncoder('create');
+        const doc = encode(input);
+        doc[this.arrayKey] = doc[this.arrayKey] || this._generateId();
+        const docFilter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]);
+        const r = await this.__updateOne(docFilter, {
+            $push: { [this.fieldName]: doc }
+        }, options);
+        if (r.modifiedCount)
+            try {
+                return this.get(parentId, doc[this.arrayKey], { ...options, filter: undefined, skip: undefined });
+            }
+            catch (e) {
+                Error.captureStackTrace(e);
+                throw e;
+            }
+        throw new common_1.ResourceNotFoundError(this.resourceName || this.getCollectionName(), parentId);
+    }
+    /**
+     * Gets the number of array items matching the filter.
+     * @param parentId
+     * @param options
+     */
+    async count(parentId, options) {
+        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]);
+        const stages = [
+            { $match: matchFilter },
+            { $unwind: { path: "$" + this.fieldName } },
+            { $replaceRoot: { newRoot: "$" + this.fieldName } }
+        ];
+        if (options?.filter) {
+            const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options.filter);
+            stages.push({ $match: optionsFilter });
+        }
+        stages.push({ $count: '*' });
+        const r = await this.__aggregate(stages, options);
+        try {
+            const n = await r.next();
+            return n?.['*'] || 0;
+        }
+        finally {
+            await r.close();
+        }
+    }
+    /**
+     * Removes one item from an array field
+     *
+     * @param parentId
+     * @param id
+     * @param options
+     */
+    async delete(parentId, id, options) {
+        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]);
+        const pullFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.arrayKey]),
+            options?.filter
+        ]);
+        const r = await this.__updateOne(matchFilter, {
+            $pull: { [this.fieldName]: pullFilter }
+        }, options);
+        return r.modifiedCount ? 1 : 0;
+    }
+    /**
+     * Removes multiple items from an array field
+     *
+     * @param parentId
+     * @param options
+     */
+    async deleteMany(parentId, options) {
+        const docFilter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]);
+        // Count matching items, we will use this as result
+        const matchCount = await this.count(parentId, options);
+        const pullFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
+        const r = await this.__updateOne(docFilter, {
+            $pull: { [this.fieldName]: pullFilter }
+        }, options);
+        if (r.modifiedCount)
+            return matchCount;
+        return 0;
+    }
+    /**
+     * Returns true if item exists, false otherwise
+     *
+     * @param parentId
+     * @param id
+     */
+    async exists(parentId, id) {
+        return !!(await this.findById(parentId, id, { pick: ['_id'] }));
+    }
+    /**
+     * Fetches the first item in an array field that matches by id.
+     *
+     * @param parentId
+     * @param id
+     * @param options
+     */
+    async findById(parentId, id, options) {
+        let filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.arrayKey]);
+        if (options?.filter)
+            filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([filter, options?.filter]);
+        return await this.findOne(parentId, { ...options, filter });
+    }
+    /**
+     * Fetches the first item in an array field that matches the filter. Returns undefined if not found.
+     *
+     * @param parentId
+     * @param options
+     */
+    async findOne(parentId, options) {
+        const rows = await this.findMany(parentId, {
+            ...options,
+            limit: 1
+        });
+        return rows?.[0];
+    }
+    /**
+     * Fetches all items in an array field that matches the filter
+     *
+     * @param parentId
+     * @param options
+     */
+    async findMany(parentId, options) {
+        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]);
+        const mongoOptions = {
+            ...(0, lodash_omit_1.default)(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) {
+            const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
+            dataStages.push({ $match: optionsFilter });
+        }
+        if (options?.skip)
+            dataStages.push({ $skip: options.skip });
+        if (options?.sort) {
+            const sort = mongo_adapter_js_1.MongoAdapter.prepareSort(options.sort);
+            if (sort)
+                dataStages.push({ $sort: sort });
+        }
+        dataStages.push({ $limit: limit });
+        const dataType = this.getArrayDataType();
+        const projection = mongo_adapter_js_1.MongoAdapter.prepareProjection(dataType, options);
+        if (projection)
+            dataStages.push({ $project: projection });
+        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;
+            }
+            else
+                return await cursor.toArray();
+        }
+        finally {
+            if (!cursor.closed)
+                await cursor.close();
+        }
+    }
+    /**
+     * Fetches the first item in an array field that matches the item id. Throws error undefined if not found.
+     *
+     * @param parentId
+     * @param id
+     * @param options
+     */
+    async get(parentId, id, options) {
+        const out = await this.findById(parentId, id, options);
+        if (!out)
+            throw new common_1.ResourceNotFoundError((this.resourceName || this.getCollectionName()) + '.' + this.arrayKey, parentId + '/' + id);
+        return out;
+    }
+    /**
+     * Update a single item in array field
+     *
+     * @param parentId
+     * @param id
+     * @param input
+     * @param options
+     */
+    async update(parentId, id, input, options) {
+        await this.updateOnly(parentId, id, input, options);
+        try {
+            return await this.findById(parentId, id, options);
+        }
+        catch (e) {
+            Error.captureStackTrace(e);
+            throw e;
+        }
+    }
+    /**
+     * Update a single item in array field
+     * Returns how many master documents updated (not array items)
+     *
+     * @param parentId
+     * @param id
+     * @param doc
+     * @param options
+     */
+    async updateOnly(parentId, id, doc, options) {
+        let filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.arrayKey]);
+        if (options?.filter)
+            filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([filter, options?.filter]);
+        return await this.updateMany(parentId, doc, { ...options, filter });
+    }
+    /**
+     * Update multiple items in array field, returns how many master documents updated (not array items)
+     *
+     * @param parentId
+     * @param input
+     * @param options
+     */
+    async updateMany(parentId, input, options) {
+        const encode = this._getEncoder('update');
+        const doc = encode(input);
+        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]),
+            { [this.fieldName]: { $exists: true } }
+        ]);
+        if (options?.filter) {
+            const elemMatch = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter, { fieldPrefix: 'elem.' });
+            options = options || {};
+            options.arrayFilters = [elemMatch];
+        }
+        const update = mongo_adapter_js_1.MongoAdapter.preparePatch(doc, {
+            fieldPrefix: this.fieldName + (options?.filter ? '.$[elem].' : '.$[].')
+        });
+        const r = await this.__updateOne(matchFilter, update, options);
+        return r.modifiedCount;
+    }
+    /**
+     * Update multiple items in array field and returns number of updated array items
+     *
+     * @param parentId
+     * @param doc
+     * @param options
+     */
+    async updateManyReturnCount(parentId, doc, options) {
+        const r = await this.updateMany(parentId, doc, options);
+        return r
+            // Count matching items that fits filter criteria
+            ? await this.count(parentId, options)
+            : 0;
+    }
+    /**
+     * Generates Id value
+     *
+     * @protected
+     */
+    _generateId() {
+        return new mongodb_1.ObjectId();
+    }
+    /**
+     * Generates a new Validator  for encoding or returns from cache if already generated before
+     * @param operation
+     * @protected
+     */
+    _getEncoder(operation) {
+        let encoder = this._encoders[operation];
+        if (encoder)
+            return encoder;
+        encoder = this._generateEncoder(operation);
+        this._encoders[operation] = encoder;
+        return encoder;
+    }
+    /**
+     * Generates a new Valgen Validator for encode operation
+     *
+     * @param operation
+     * @protected
+     */
+    _generateEncoder(operation) {
+        const dataType = this.getArrayDataType();
+        const options = {};
+        if (operation === 'update') {
+            options.omit = ['_id'];
+            options.partial = true;
+        }
+        return dataType.generateCodec('encode', options);
+    }
+}
+exports.MongoArrayService = MongoArrayService;