@opra/mongodb 0.31.4 → 0.31.5

package/cjs/{mongo-entity-service-base.js → mongo-service.js}

@@ -1,49 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoEntityServiceBase = void 0;
+exports.MongoService = void 0;
+const common_1 = require("@opra/common");
 const core_1 = require("@opra/core");
-class MongoEntityServiceBase extends core_1.ApiService {
-    constructor(arg0, arg1) {
+class MongoService extends core_1.ApiService {
+    constructor(dataType, options) {
         super();
-        const options = typeof arg0 === 'object' ? arg0 : arg1;
-        if (typeof arg0 === 'string')
-            this._collectionName = arg0;
+        this._dataType = dataType;
+        this.collectionName = options?.collectionName;
         this.db = options?.db;
-        this.defaultLimit = options?.defaultLimit || 10;
+        if (!this.collectionName) {
+            if (typeof dataType === 'string')
+                this.collectionName = dataType;
+            if (typeof dataType === 'function') {
+                const metadata = Reflect.getMetadata(common_1.DATATYPE_METADATA, dataType);
+                if (metadata)
+                    this.collectionName = metadata.name;
+            }
+        }
+        this.resourceName = options?.resourceName || this.collectionName;
+    }
+    forContext(context, options) {
+        return super.forContext(context, {
+            newInstance: options?.newInstance ||
+                (options?.db && this.db !== options?.db) ||
+                (options?.session && this.session !== options?.session)
+        });
     }
-    async _count(filter, options) {
+    async _rawInsertOne(doc, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
-            limit: undefined,
             session: options?.session || this.session
         };
         try {
-            return await collection.countDocuments(filter, options) || 0;
+            return await collection.insertOne(doc, options);
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
     }
-    async _deleteOne(filter, options) {
+    async _rawCountDocuments(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
+            limit: undefined,
             session: options?.session || this.session
         };
         try {
-            const r = await collection.deleteOne(filter, options);
-            return r.deletedCount;
+            return await collection.countDocuments(filter, options) || 0;
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
     }
-    async _deleteMany(filter, options) {
+    async _rawDeleteOne(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
@@ -51,105 +66,74 @@ class MongoEntityServiceBase extends core_1.ApiService {
             session: options?.session || this.session
         };
         try {
-            const r = await collection.deleteMany(filter, options);
-            return r.deletedCount;
+            return await collection.deleteOne(filter, options);
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
     }
-    async _findOne(filter, options) {
+    async _rawDeleteMany(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session
         };
-        let out;
         try {
-            out = await collection.findOne(filter, options);
+            return await collection.deleteMany(filter, options);
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
-        return out;
     }
-    async _find(filter, options) {
+    async _rawFindOne(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
-            limit: options?.limit || this.defaultLimit,
             session: options?.session || this.session
         };
-        const out = [];
-        let cursor;
         try {
-            cursor = collection.find(filter, options);
-            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 await collection.findOne(filter, options);
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
-        finally {
-            if (cursor)
-                await cursor.close();
-        }
-        return out;
     }
-    async _insertOne(doc, options) {
+    async _rawFind(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
-        let out;
         options = {
             ...options,
             session: options?.session || this.session
         };
         try {
-            const r = await collection.insertOne(doc, options);
-            if (r.insertedId)
-                out = await collection.findOne({ _id: r.insertedId }, options);
+            return collection.find(filter, options);
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
-        if (this.transformData)
-            out = this.transformData(out);
-        if (!out)
-            throw new Error('"insertOne" endpoint returned no result!');
-        return out;
     }
-    async _updateOne(filter, doc, options) {
+    async _rawUpdateOne(filter, doc, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
-        let out;
         options = {
             ...options,
             session: options?.session || this.session
         };
         try {
-            const r = await collection.updateOne(filter, doc, options);
-            if (r.matchedCount)
-                out = await collection.findOne((r.upsertedId ? { _id: r.upsertedId } : filter), options);
+            return await collection.updateOne(filter, doc, options);
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
-        if (this.transformData)
-            out = this.transformData(out);
-        return out;
     }
-    async _updateMany(filter, doc, options) {
+    async _rawUpdateMany(filter, doc, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
@@ -158,20 +142,13 @@ class MongoEntityServiceBase extends core_1.ApiService {
             upsert: false
         };
         try {
-            const r = await collection.updateMany(filter, doc, options);
-            return r.matchedCount;
+            return await collection.updateMany(filter, doc, options);
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
     }
-    forContext(context, db, session) {
-        const instance = super.forContext(context);
-        instance.db = db || this.db;
-        instance.session = session || this.session;
-        return instance;
-    }
     async _onError(error) {
         if (this.onError)
             await this.onError(error);
@@ -183,15 +160,16 @@ class MongoEntityServiceBase extends core_1.ApiService {
             throw new Error(`Database not set!`);
         return this.db;
     }
+    getDataType() {
+        return this.context.api.getComplexType(this._dataType);
+    }
     async getCollection(db) {
-        if (!this._collectionName)
-            throw new Error('collectionName is not assigned');
         return db.collection(this.getCollectionName());
     }
     getCollectionName() {
-        if (!this._collectionName)
-            throw new Error('collectionName is not defined');
-        return this._collectionName;
+        if (this.collectionName)
+            return this.collectionName;
+        throw new Error('collectionName is not defined');
     }
 }
-exports.MongoEntityServiceBase = MongoEntityServiceBase;
+exports.MongoService = MongoService;

package/cjs/mongo-singleton-service.js

@@ -0,0 +1,88 @@
+"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");
+/**
+ *
+ * @class MongoSingletonService
+ */
+class MongoSingletonService extends mongo_service_js_1.MongoService {
+    constructor(dataType, options) {
+        super(dataType, options);
+        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`);
+    }
+    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;
+        }
+        /* istanbul ignore next */
+        throw new Error('Unknown error while creating document');
+    }
+    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);
+        return r.deletedCount;
+    }
+    async get(options) {
+        const out = await this.find(options);
+        if (!out)
+            throw new common_1.ResourceNotFoundError(this.resource.name);
+        return out;
+    }
+    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])];
+        const mongoOptions = {
+            ...options,
+            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.resource.type, 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;
+        }
+    }
+    async update(doc, options) {
+        // Prevent upsert with different _id field
+        if (options?.upsert)
+            doc._id = this._id;
+        else
+            delete doc._id;
+        const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
+        const mongoOptions = {
+            ...options,
+            upsert: undefined
+        };
+        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);
+    }
+}
+exports.MongoSingletonService = MongoSingletonService;

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

@@ -10,7 +10,17 @@ const opMap = {
     'in': '$in',
     '!in': '$nin',
 };
-export default function transformFilter(ast, negative) {
+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;
+}
+function prepareFilterAst(ast, negative) {
     if (!ast)
         return;
     if (ast instanceof OpraFilter.QualifiedIdentifier) {
@@ -25,21 +35,24 @@ export default function transformFilter(ast, negative) {
         return ast.value;
     }
     if (ast instanceof OpraFilter.ArrayExpression) {
-        return ast.items.map(x => transformFilter(x, negative));
+        return ast.items.map(x => prepareFilterAst(x, negative));
     }
     if (ast instanceof OpraFilter.NegativeExpression) {
-        return transformFilter(ast.expression, !negative);
+        return prepareFilterAst(ast.expression, !negative);
     }
     if (ast instanceof 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 OpraFilter.ParenthesizedExpression) {
-        return transformFilter(ast.expression, negative);
+        return prepareFilterAst(ast.expression, negative);
     }
     if (ast instanceof OpraFilter.ComparisonExpression) {
-        const left = transformFilter(ast.left, negative);
+        const left = prepareFilterAst(ast.left, negative);
         if (ast.right instanceof OpraFilter.QualifiedIdentifier) {
             const op = opMap[ast.op];
             if (op)
@@ -47,7 +60,7 @@ export default 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 ? '!=' : '=')

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

@@ -0,0 +1,17 @@
+import isPlainObject from 'putil-isplainobject';
+const defaultPrimaryKey = ['_id'];
+export default function prepareKeyValues(keyValue, primaryKey) {
+    primaryKey = primaryKey || defaultPrimaryKey;
+    const b = isPlainObject(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 };
+}

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

@@ -1,9 +1,9 @@
-export default function transformPatch(doc) {
+export default function preparePatch(doc) {
     const trg = {};
-    _transformPatch(doc, trg);
+    _preparePatch(doc, trg);
     return trg;
 }
-function _transformPatch(src, trg = {}, path = '') {
+function _preparePatch(src, trg = {}, path = '') {
     let fieldName;
     for (const [k, v] of Object.entries(src)) {
         fieldName = k.startsWith('*') ? k.substring(1) : k;
@@ -16,7 +16,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/esm/{transform-projection.js → adapter-utils/prepare-projection.js}

@@ -1,18 +1,18 @@
 import { ComplexType, pathToObjectTree } from '@opra/common';
-export default function transformProjection(dataType, args) {
+export default function prepareProjection(dataType, args) {
     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) {
-        _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;
 }
-export function _transformInclusionProjection(dataType, target, pick, include, omit, defaultFields) {
+export function _prepareInclusionProjection(dataType, target, pick, include, omit, defaultFields) {
     defaultFields = defaultFields ?? !pick;
     let n;
     for (const [k, f] of dataType.fields.entries()) {
@@ -23,21 +23,21 @@ export function _transformInclusionProjection(dataType, target, pick, include, o
         if (n) {
             if (f.type instanceof 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;
         }
     }
 }
-export function _transformExclusionProjection(dataType, target, omit, omitExclusiveFields) {
+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] = {};
-                _transformExclusionProjection(f.type, target[k], omit?.[k], omitExclusiveFields);
+                _prepareExclusionProjection(f.type, target[k], omit?.[k], omitExclusiveFields);
                 continue;
             }
             target[k] = 0;

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

@@ -1,4 +1,4 @@
-export default function transformSort(sort) {
+export default function prepareSort(sort) {
     if (!(sort && sort.length))
         return;
     const out = {};

package/esm/index.js

@@ -1,5 +1,4 @@
 export * from './mongo-adapter.js';
-export * from './mongo-collection.js';
-export * from './mongo-entity-service-base.js';
-export * from './mongo-entity-service.js';
-export * from './mongo-singleton.js';
+export * from './mongo-collection-service.js';
+export * from './mongo-service.js';
+export * from './mongo-singleton-service.js';

package/esm/mongo-adapter.js

@@ -1,103 +1,13 @@
-import isNil from 'lodash.isnil';
-import omitBy from 'lodash.omitby';
-import { Collection, Singleton } from '@opra/common';
-import _transformFilter from './transform-filter.js';
-import _transformKeyValues from './transform-key-values.js';
-import _transformPatch from './transform-patch.js';
-import _transformProjection from './transform-projection.js';
-import _transformSort from './transform-sort.js';
+import _prepareFilter from './adapter-utils/prepare-filter.js';
+import _prepareKeyValues from './adapter-utils/prepare-key-values.js';
+import _preparePatch from './adapter-utils/prepare-patch.js';
+import _prepareProjection from './adapter-utils/prepare-projection.js';
+import _prepareSort from './adapter-utils/prepare-sort.js';
 export var MongoAdapter;
 (function (MongoAdapter) {
-    MongoAdapter.transformFilter = _transformFilter;
-    MongoAdapter.transformKeyValues = _transformKeyValues;
-    MongoAdapter.transformPatch = _transformPatch;
-    MongoAdapter.transformProjection = _transformProjection;
-    MongoAdapter.transformSort = _transformSort;
-    function transformRequest(request) {
-        const { resource } = request;
-        if (resource instanceof Collection || resource instanceof 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 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 = omitBy(options, isNil);
-            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 = _prepareKeyValues;
+    MongoAdapter.prepareFilter = _prepareFilter;
+    MongoAdapter.preparePatch = _preparePatch;
+    MongoAdapter.prepareProjection = _prepareProjection;
+    MongoAdapter.prepareSort = _prepareSort;
 })(MongoAdapter || (MongoAdapter = {}));