@opra/mongodb 0.31.13 → 0.32.0

package/cjs/mongo-singleton-service.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoSingletonService = void 0;
-const tslib_1 = require("tslib");
 const mongodb_1 = require("mongodb");
 const common_1 = require("@opra/common");
-const OpraCommon = tslib_1.__importStar(require("@opra/common"));
 const mongo_adapter_js_1 = require("./mongo-adapter.js");
 const mongo_service_js_1 = require("./mongo-service.js");
 /**
@@ -14,75 +12,90 @@ const mongo_service_js_1 = require("./mongo-service.js");
 class MongoSingletonService extends mongo_service_js_1.MongoService {
     constructor(dataType, options) {
         super(dataType, options);
+        this.collectionKey = options?.collectionKey || '_id';
         this._id = options?._id || new mongodb_1.ObjectId('655608925cad472b75fc6485');
     }
-    get resource() {
-        const resource = this.context.request.resource;
-        if (resource instanceof OpraCommon.Singleton)
-            return resource;
-        throw new TypeError(`"${resource}" resource is not a Singleton`);
+    /**
+     * Fetches the Document. Throws error undefined if not found.
+     *
+     * @param options
+     */
+    async assert(options) {
+        const out = await this.get(options);
+        if (!out)
+            throw new common_1.ResourceNotFoundError(this.resourceName || this.getCollectionName());
+        return out;
     }
+    /**
+     * Inserts the document into MongoDB
+     *
+     * @param doc
+     * @param options
+     */
     async create(doc, options) {
-        const r = await this._rawInsertOne({ ...doc, _id: this._id }, options);
-        if (r.insertedId) {
-            const out = await this.get(options);
-            if (out)
-                return out;
-        }
+        const r = await this.__insertOne({ ...doc, _id: this._id }, options);
+        if (r.insertedId)
+            return doc;
         /* istanbul ignore next */
         throw new Error('Unknown error while creating document');
     }
+    /**
+     * Delete the document from a collection
+     *
+     * @param options
+     */
     async delete(options) {
-        const filter = { _id: this._id };
-        const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
-        if (optionsFilter)
-            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
-        const r = await this._rawDeleteOne(filter, options);
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([{ _id: this._id }, options?.filter]);
+        const r = await this.__deleteOne(filter, options);
         return r.deletedCount;
     }
-    async get(options) {
-        const out = await this.find(options);
-        if (!out)
-            throw new common_1.ResourceNotFoundError(this.resource.name);
-        return out;
+    /**
+     * Checks if the document exists.
+     * Returns true if document exists, false otherwise
+     *
+     */
+    async exists() {
+        return !!(await this.get({ pick: ['_id'] }));
     }
-    async find(options) {
-        const filter = { _id: this._id };
-        const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
-        if (optionsFilter)
-            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
+    /**
+     * Fetches the document
+     *
+     * @param options
+     */
+    async get(options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([{ _id: this._id }, options?.filter]);
         const mongoOptions = {
             ...options,
-            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.resource.type, options),
+            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
             sort: undefined,
             skip: undefined,
             limit: undefined
         };
-        const out = await this._rawFindOne(filter, mongoOptions);
-        if (out) {
-            if (this.transformData)
-                return this.transformData(out);
-            return out;
-        }
+        return await this.__findOne(filter, mongoOptions);
     }
+    /**
+     * Updates a single document.
+     * Returns updated document
+     *
+     * @param doc
+     * @param options
+     */
     async update(doc, options) {
-        // Prevent upsert with different _id field
-        if (options?.upsert)
-            doc._id = this._id;
-        else
-            delete doc._id;
+        // Prevent updating _id field
+        delete doc._id;
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+            { _id: this._id },
+            options?.filter
+        ]);
         const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
         const mongoOptions = {
             ...options,
-            upsert: undefined
+            includeResultMetadata: false,
+            upsert: undefined,
+            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
         };
-        const filter = { _id: this._id };
-        const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
-        if (optionsFilter)
-            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
-        const r = await this._rawUpdateOne(filter, patch, mongoOptions);
-        if (r.matchedCount)
-            return await this.get(options);
+        const out = await this.__findOneAndUpdate(filter, patch, mongoOptions);
+        return out || undefined;
     }
 }
 exports.MongoSingletonService = MongoSingletonService;

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,4 +1,3 @@
-import '@opra/core';
 import { OpraFilter } from '@opra/common';
 const opMap = {
     '=': '$eq',
@@ -10,15 +9,71 @@ const opMap = {
     'in': '$in',
     '!in': '$nin',
 };
-export default function prepareFilter(filter) {
-    if (!filter)
-        return;
-    if (typeof filter === 'string')
-        return prepareFilterAst(OpraFilter.parse(filter));
-    else if (filter instanceof 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
+ */
+export default 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(OpraFilter.parse(filter));
+        else if (filter instanceof 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;
+}
+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)

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

@@ -1,6 +1,7 @@
 export default function preparePatch(doc, options) {
     const trg = {};
     _preparePatch(doc, trg, '', options);
+    trg.$set = trg.$set || {};
     return trg;
 }
 function _preparePatch(src, trg = {}, path, options) {

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

@@ -1,46 +1,47 @@
 import { ComplexType, pathToObjectTree } from '@opra/common';
-export default function prepareProjection(dataType, args) {
+export default function prepareProjection(dataType, options) {
     const out = {};
-    // omitExclusiveFields(dataType, out);
-    const pick = args?.pick && pathToObjectTree(args.include ? [...args.pick, ...args.include] : args.pick);
-    const include = !args?.pick && args?.include && pathToObjectTree(args.include);
-    const omit = args?.omit && pathToObjectTree(args.omit);
-    if (pick || include) {
-        _prepareInclusionProjection(dataType, out, pick, include, omit);
-    }
-    else
-        _prepareExclusionProjection(dataType, out, omit, !omit);
+    const pick = options?.pick && pathToObjectTree(options.pick);
+    const include = options?.include && pathToObjectTree(options.include);
+    const omit = options?.omit && pathToObjectTree(options.omit);
+    // const exclusionProjection = !pick && !!omit;
+    _prepareProjection(dataType, out, {
+        pickActivated: !!pick,
+        pick,
+        include,
+        omit
+    });
     return Object.keys(out).length ? out : undefined;
 }
-export function _prepareInclusionProjection(dataType, target, pick, include, omit, defaultFields) {
-    defaultFields = defaultFields ?? !pick;
-    let n;
+export 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 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 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;
-        }
-    }
-}
-export 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 ComplexType && typeof n === 'object') {
-                target[k] = {};
-                _prepareExclusionProjection(f.type, target[k], omit?.[k], omitExclusiveFields);
-                continue;
-            }
-            target[k] = 0;
         }
+        target[k] = 1;
     }
 }

package/esm/index.js

@@ -1,4 +1,6 @@
 export * from './mongo-adapter.js';
+export * from './mongo-array-service.js';
 export * from './mongo-collection-service.js';
 export * from './mongo-service.js';
 export * from './mongo-singleton-service.js';
+export * from './types.js';

package/esm/mongo-array-service.js

@@ -0,0 +1,339 @@
+import omit from 'lodash.omit';
+import { ObjectId } from 'mongodb';
+import { ComplexType, NotAcceptableError, ResourceNotFoundError } from '@opra/common';
+import { MongoAdapter } from './mongo-adapter.js';
+import { MongoService } from './mongo-service.js';
+/**
+ *
+ * @class MongoArrayService
+ */
+export class MongoArrayService extends 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 ComplexType))
+            throw new 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 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 = 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 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 = MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]);
+        const stages = [
+            { $match: matchFilter },
+            { $unwind: { path: "$" + this.fieldName } },
+            { $replaceRoot: { newRoot: "$" + this.fieldName } }
+        ];
+        if (options?.filter) {
+            const optionsFilter = 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 = MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]);
+        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;
+    }
+    /**
+     * Removes multiple items from an array field
+     *
+     * @param parentId
+     * @param options
+     */
+    async deleteMany(parentId, options) {
+        const docFilter = MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]);
+        // Count matching items, we will use this as result
+        const matchCount = await this.count(parentId, options);
+        const pullFilter = 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 = MongoAdapter.prepareKeyValues(id, [this.arrayKey]);
+        if (options?.filter)
+            filter = 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 = MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]);
+        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) {
+            const optionsFilter = MongoAdapter.prepareFilter(options?.filter);
+            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.getArrayDataType();
+        const projection = 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 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 = MongoAdapter.prepareKeyValues(id, [this.arrayKey]);
+        if (options?.filter)
+            filter = 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 = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(parentId, [this.collectionKey]),
+            { [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);
+        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 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);
+    }
+}