@opra/mongodb 0.31.4 → 0.31.5

package/cjs/{transform-filter.js → adapter-utils/prepare-filter.js}

@@ -12,7 +12,18 @@ const opMap = {
     'in': '$in',
     '!in': '$nin',
 };
-function transformFilter(ast, negative) {
+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;
+}
+exports.default = prepareFilter;
+function prepareFilterAst(ast, negative) {
     if (!ast)
         return;
     if (ast instanceof common_1.OpraFilter.QualifiedIdentifier) {
@@ -27,21 +38,24 @@ function transformFilter(ast, negative) {
         return ast.value;
     }
     if (ast instanceof common_1.OpraFilter.ArrayExpression) {
-        return ast.items.map(x => transformFilter(x, negative));
+        return ast.items.map(x => prepareFilterAst(x, negative));
     }
     if (ast instanceof common_1.OpraFilter.NegativeExpression) {
-        return transformFilter(ast.expression, !negative);
+        return prepareFilterAst(ast.expression, !negative);
     }
     if (ast instanceof common_1.OpraFilter.LogicalExpression) {
+        const items = ast.items
+            .map(x => prepareFilterAst(x, negative))
+            .filter(x => x != null);
         if (ast.op === 'or')
-            return { $or: ast.items.map(x => transformFilter(x, negative)) };
-        return { $and: ast.items.map(x => transformFilter(x, negative)) };
+            return { $or: items };
+        return { $and: items };
     }
     if (ast instanceof common_1.OpraFilter.ParenthesizedExpression) {
-        return transformFilter(ast.expression, negative);
+        return prepareFilterAst(ast.expression, negative);
     }
     if (ast instanceof common_1.OpraFilter.ComparisonExpression) {
-        const left = transformFilter(ast.left, negative);
+        const left = prepareFilterAst(ast.left, negative);
         if (ast.right instanceof common_1.OpraFilter.QualifiedIdentifier) {
             const op = opMap[ast.op];
             if (op)
@@ -49,7 +63,7 @@ function transformFilter(ast, negative) {
             /* istanbul ignore next */
             throw new Error(`Invalid filter query.`);
         }
-        let right = transformFilter(ast.right);
+        let right = prepareFilterAst(ast.right);
         if (right == null) {
             const op = ast.op === '='
                 ? (negative ? '!=' : '=')
@@ -107,5 +121,4 @@ function transformFilter(ast, negative) {
     }
     throw new Error(`${ast.kind} is not implemented yet`);
 }
-exports.default = transformFilter;
 const wrapNot = (o, negative) => negative ? { $not: o } : o;

package/cjs/adapter-utils/prepare-key-values.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const putil_isplainobject_1 = tslib_1.__importDefault(require("putil-isplainobject"));
+const defaultPrimaryKey = ['_id'];
+function prepareKeyValues(keyValue, primaryKey) {
+    primaryKey = primaryKey || defaultPrimaryKey;
+    const b = (0, putil_isplainobject_1.default)(keyValue);
+    if (primaryKey.length > 1 && !b)
+        new TypeError(`Argument "keyValue" must be an object that contains all key values`);
+    if (primaryKey.length > 1 || b) {
+        return primaryKey.reduce((o, k) => {
+            o[k] = keyValue[k];
+            if (o[k] == null)
+                new Error(`Value of key "${k}" is required`);
+            return o;
+        }, {});
+    }
+    return { [primaryKey[0]]: keyValue };
+}
+exports.default = prepareKeyValues;

package/cjs/{transform-patch.js → adapter-utils/prepare-patch.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-function transformPatch(doc) {
+function preparePatch(doc) {
     const trg = {};
-    _transformPatch(doc, trg);
+    _preparePatch(doc, trg);
     return trg;
 }
-exports.default = transformPatch;
-function _transformPatch(src, trg = {}, path = '') {
+exports.default = preparePatch;
+function _preparePatch(src, trg = {}, path = '') {
     let fieldName;
     for (const [k, v] of Object.entries(src)) {
         fieldName = k.startsWith('*') ? k.substring(1) : k;
@@ -19,7 +19,7 @@ function _transformPatch(src, trg = {}, path = '') {
         if (v && typeof v === 'object') {
             // If field name starts with "*", do "replace" operation except "merge"
             if (!k.startsWith('*')) {
-                _transformPatch(v, trg, key);
+                _preparePatch(v, trg, key);
                 continue;
             }
         }

package/cjs/{transform-projection.js → adapter-utils/prepare-projection.js}

@@ -1,22 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._transformExclusionProjection = exports._transformInclusionProjection = void 0;
+exports._prepareExclusionProjection = exports._prepareInclusionProjection = void 0;
 const common_1 = require("@opra/common");
-function transformProjection(dataType, args) {
+function prepareProjection(dataType, args) {
     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) {
-        _transformInclusionProjection(dataType, out, pick, include, omit);
+        _prepareInclusionProjection(dataType, out, pick, include, omit);
     }
     else
-        _transformExclusionProjection(dataType, out, omit, !omit);
+        _prepareExclusionProjection(dataType, out, omit, !omit);
     return Object.keys(out).length ? out : undefined;
 }
-exports.default = transformProjection;
-function _transformInclusionProjection(dataType, target, pick, include, omit, defaultFields) {
+exports.default = prepareProjection;
+function _prepareInclusionProjection(dataType, target, pick, include, omit, defaultFields) {
     defaultFields = defaultFields ?? !pick;
     let n;
     for (const [k, f] of dataType.fields.entries()) {
@@ -27,26 +27,26 @@ function _transformInclusionProjection(dataType, target, pick, include, omit, de
         if (n) {
             if (f.type instanceof common_1.ComplexType && (typeof n === 'object' || typeof omit?.[k] === 'object')) {
                 target[k] = {};
-                _transformInclusionProjection(f.type, target[k], pick?.[k] || include?.[k], undefined, omit?.[k], defaultFields);
+                _prepareInclusionProjection(f.type, target[k], pick?.[k] || include?.[k], undefined, omit?.[k], defaultFields);
                 continue;
             }
             target[k] = 1;
         }
     }
 }
-exports._transformInclusionProjection = _transformInclusionProjection;
-function _transformExclusionProjection(dataType, target, omit, omitExclusiveFields) {
+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] = {};
-                _transformExclusionProjection(f.type, target[k], omit?.[k], omitExclusiveFields);
+                _prepareExclusionProjection(f.type, target[k], omit?.[k], omitExclusiveFields);
                 continue;
             }
             target[k] = 0;
         }
     }
 }
-exports._transformExclusionProjection = _transformExclusionProjection;
+exports._prepareExclusionProjection = _prepareExclusionProjection;

package/cjs/{transform-sort.js → adapter-utils/prepare-sort.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-function transformSort(sort) {
+function prepareSort(sort) {
     if (!(sort && sort.length))
         return;
     const out = {};
@@ -14,4 +14,4 @@ function transformSort(sort) {
     });
     return out;
 }
-exports.default = transformSort;
+exports.default = prepareSort;

package/cjs/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./mongo-adapter.js"), exports);
-tslib_1.__exportStar(require("./mongo-collection.js"), exports);
-tslib_1.__exportStar(require("./mongo-entity-service-base.js"), exports);
-tslib_1.__exportStar(require("./mongo-entity-service.js"), exports);
-tslib_1.__exportStar(require("./mongo-singleton.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);

package/cjs/mongo-adapter.js

@@ -2,106 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoAdapter = void 0;
 const tslib_1 = require("tslib");
-const lodash_isnil_1 = tslib_1.__importDefault(require("lodash.isnil"));
-const lodash_omitby_1 = tslib_1.__importDefault(require("lodash.omitby"));
-const common_1 = require("@opra/common");
-const transform_filter_js_1 = tslib_1.__importDefault(require("./transform-filter.js"));
-const transform_key_values_js_1 = tslib_1.__importDefault(require("./transform-key-values.js"));
-const transform_patch_js_1 = tslib_1.__importDefault(require("./transform-patch.js"));
-const transform_projection_js_1 = tslib_1.__importDefault(require("./transform-projection.js"));
-const transform_sort_js_1 = tslib_1.__importDefault(require("./transform-sort.js"));
+const prepare_filter_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-filter.js"));
+const prepare_key_values_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-key-values.js"));
+const prepare_patch_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-patch.js"));
+const prepare_projection_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-projection.js"));
+const prepare_sort_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-sort.js"));
 var MongoAdapter;
 (function (MongoAdapter) {
-    MongoAdapter.transformFilter = transform_filter_js_1.default;
-    MongoAdapter.transformKeyValues = transform_key_values_js_1.default;
-    MongoAdapter.transformPatch = transform_patch_js_1.default;
-    MongoAdapter.transformProjection = transform_projection_js_1.default;
-    MongoAdapter.transformSort = transform_sort_js_1.default;
-    function transformRequest(request) {
-        const { resource } = request;
-        if (resource instanceof common_1.Collection || resource instanceof common_1.Singleton) {
-            const { params, endpoint } = request;
-            let options = {};
-            let filter;
-            const operation = endpoint.name;
-            if (operation === 'create' || operation === 'update' ||
-                operation === 'get' || operation === 'findMany') {
-                options.projection = MongoAdapter.transformProjection(resource.type, params);
-            }
-            if (resource instanceof common_1.Collection &&
-                (operation === 'delete' || operation === 'get' || operation === 'update')) {
-                filter = MongoAdapter.transformKeyValues(resource, request.key);
-            }
-            if (params?.filter) {
-                const f = MongoAdapter.transformFilter(params.filter);
-                filter = filter ? { $and: [filter, f] } : f;
-            }
-            if (operation === 'findMany') {
-                options.sort = params?.sort;
-                options.limit = params?.limit;
-                options.skip = params?.skip;
-                options.distinct = params?.distinct;
-                options.count = params?.count;
-            }
-            options = (0, lodash_omitby_1.default)(options, lodash_isnil_1.default);
-            switch (operation) {
-                case 'create': {
-                    return {
-                        method: 'insertOne',
-                        data: request.data,
-                        options,
-                        args: [request.data, options]
-                    };
-                }
-                case 'delete':
-                case 'deleteMany': {
-                    return {
-                        method: (operation === 'delete' ? 'deleteOne' : 'deleteMany'),
-                        filter,
-                        options,
-                        args: [filter, options]
-                    };
-                }
-                case 'get': {
-                    return {
-                        method: 'findOne',
-                        filter,
-                        options,
-                        args: [filter, options]
-                    };
-                }
-                case 'findMany': {
-                    return {
-                        method: 'find',
-                        filter,
-                        options,
-                        args: [filter, options]
-                    };
-                }
-                case 'update': {
-                    const data = MongoAdapter.transformPatch(request.data);
-                    filter = filter || {};
-                    return {
-                        method: 'updateOne',
-                        filter,
-                        data,
-                        options,
-                        args: [filter, data, options]
-                    };
-                }
-                case 'updateMany': {
-                    const data = MongoAdapter.transformPatch(request.data);
-                    return {
-                        method: 'updateMany',
-                        filter,
-                        data,
-                        options,
-                        args: [filter, data, options]
-                    };
-                }
-            }
-        }
-        throw new TypeError(`Unimplemented request kind (${request.resource.kind}.${request.endpoint.name})`);
-    }
-    MongoAdapter.transformRequest = transformRequest;
+    MongoAdapter.prepareKeyValues = prepare_key_values_js_1.default;
+    MongoAdapter.prepareFilter = prepare_filter_js_1.default;
+    MongoAdapter.preparePatch = prepare_patch_js_1.default;
+    MongoAdapter.prepareProjection = prepare_projection_js_1.default;
+    MongoAdapter.prepareSort = prepare_sort_js_1.default;
 })(MongoAdapter || (exports.MongoAdapter = MongoAdapter = {}));

package/cjs/mongo-collection-service.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoCollectionService = void 0;
+const tslib_1 = require("tslib");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+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 MongoCollectionService
+ */
+class MongoCollectionService extends mongo_service_js_1.MongoService {
+    constructor(dataType, options) {
+        super(dataType, options);
+        this.defaultLimit = options?.defaultLimit || 10;
+        this.keyFields = options?.keyField ?
+            (Array.isArray(options.keyField) ? options.keyField : [options.keyField]) : undefined;
+    }
+    async create(doc, options) {
+        const r = await this._rawInsertOne(doc, options);
+        if (r.insertedId) {
+            const out = await this.get(r.insertedId, options);
+            if (out)
+                return out;
+        }
+        /* istanbul ignore next */
+        throw new Error('Unknown error while creating document');
+    }
+    async count(options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
+        return this._rawCountDocuments(filter, (0, lodash_omit_1.default)(options, 'filter'));
+    }
+    async delete(id, options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, this.keyFields);
+        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);
+        return r.deletedCount;
+    }
+    async deleteMany(options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
+        const r = await this._rawDeleteMany(filter, (0, lodash_omit_1.default)(options, 'filter'));
+        return r.deletedCount;
+    }
+    async get(id, options) {
+        const out = await this.findOne(id, options);
+        if (!out)
+            throw new common_1.ResourceNotFoundError(this.resourceName || this.getCollectionName(), id);
+        return out;
+    }
+    async findOne(id, options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, this.keyFields);
+        const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
+        if (optionsFilter)
+            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
+        const mongoOptions = {
+            ...(0, lodash_omit_1.default)(options, ['sort', 'skip', 'limit', 'filter']),
+            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
+        };
+        const out = await this._rawFindOne(filter, mongoOptions);
+        if (out) {
+            if (this.transformData)
+                return this.transformData(out);
+            return out;
+        }
+    }
+    async findMany(options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
+        const [items, count] = await Promise.all([
+            // Promise that returns items
+            Promise.resolve().then(async () => {
+                const cursor = await this._rawFind(filter, {
+                    ...(0, lodash_omit_1.default)(options, 'filter'),
+                    sort: options?.sort ? mongo_adapter_js_1.MongoAdapter.prepareSort(options.sort) : undefined,
+                    projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options)
+                });
+                try {
+                    const out = [];
+                    let obj;
+                    while (out.length < this.defaultLimit && (obj = await cursor.next())) {
+                        const v = this.transformData ? this.transformData(obj) : obj;
+                        if (v)
+                            out.push(obj);
+                    }
+                    return out;
+                }
+                finally {
+                    await cursor.close();
+                }
+            }),
+            // Promise that returns count
+            (options?.count ? this.count(options) : Promise.resolve()),
+        ]);
+        if (options?.count)
+            this.context.response.totalMatches = count || 0;
+        return items;
+    }
+    async update(id, doc, options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, this.keyFields);
+        const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
+        if (optionsFilter)
+            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
+        // Prevent updating _id field
+        delete doc._id;
+        const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
+        const mongoOptions = {
+            ...options,
+            upsert: undefined
+        };
+        const r = await this._rawUpdateOne(filter, patch, mongoOptions);
+        if (r.modifiedCount)
+            return await this.get(filter, options);
+        if (r.upsertedCount)
+            return await this.get(r.upsertedId, options);
+    }
+    async updateMany(doc, options) {
+        // Prevent updating _id field
+        delete doc._id;
+        const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
+        const mongoOptions = {
+            ...(0, lodash_omit_1.default)(options, 'filter'),
+            upsert: undefined
+        };
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
+        const r = await this._rawUpdateMany(filter, patch, mongoOptions);
+        return r.matchedCount;
+    }
+}
+exports.MongoCollectionService = MongoCollectionService;