@opra/mongodb 1.0.0-alpha.2 → 1.0.0-alpha.20

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = prepareFilter;
 const common_1 = require("@opra/common");
 const opMap = {
     '=': '$eq',
@@ -65,7 +66,6 @@ function prepareFilter(filters, options) {
     }
     return i ? (options?.fieldPrefix ? addPrefix(out, options.fieldPrefix) : out) : undefined;
 }
-exports.default = prepareFilter;
 function addPrefix(source, prefix) {
     if (typeof source !== 'object')
         return source;
@@ -167,6 +167,8 @@ function prepareFilterAst(ast, negative) {
                         },
                     }, !negative),
                 };
+            default:
+                break;
         }
         throw new Error(`Unimplemented ComparisonExpression operation (right side is ${ast.right.kind})`);
     }

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

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = prepareKeyValues;
 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) {
+        throw 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`);
+                throw new Error(`Value of key "${k}" is required`);
             return o;
         }, {});
     }
     return { [primaryKey[0]]: keyValue };
 }
-exports.default = prepareKeyValues;

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

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = preparePatch;
 function preparePatch(doc, options) {
     const trg = {};
     _preparePatch(doc, trg, '', options);
     trg.$set = trg.$set || {};
     return trg;
 }
-exports.default = preparePatch;
-function _preparePatch(src, trg = {}, path, options) {
+function _preparePatch(src, trg, path, options) {
     let f;
     let key;
     let field;
+    trg = trg || {};
     const fieldPrefix = options?.fieldPrefix;
     for (const [k, v] of Object.entries(src)) {
         f = k.startsWith('*') ? k.substring(1) : k;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepare = void 0;
+exports.default = prepareProjection;
+exports.prepare = prepare;
 const common_1 = require("@opra/common");
 function prepareProjection(dataType, projection) {
     if (projection && typeof projection === 'object' && !Array.isArray(projection))
@@ -11,7 +12,6 @@ function prepareProjection(dataType, projection) {
     prepare(dataType, out, projection_);
     return Object.keys(out).length ? out : undefined;
 }
-exports.default = prepareProjection;
 function prepare(dataType, target, projection) {
     const defaultFields = !projection || !Object.values(projection).find(p => !p.sign);
     const projectionKeys = projection && Object.keys(projection).map(x => x.toLowerCase());
@@ -50,4 +50,3 @@ function prepare(dataType, target, projection) {
         }
     }
 }
-exports.prepare = prepare;

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

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

package/cjs/index.js

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

@@ -17,7 +17,7 @@ var MongoAdapter;
     async function parseRequest(context) {
         const { operation } = context;
         if (operation.composition?.startsWith('Entity.') && operation.compositionOptions?.type) {
-            const { compositionOptions } = operation;
+            const controller = operation.owner;
             switch (operation.composition) {
                 case 'Entity.Create': {
                     const data = await context.getBody();
@@ -27,7 +27,8 @@ var MongoAdapter;
                     return { method: 'create', data, options };
                 }
                 case 'Entity.Delete': {
-                    const key = context.pathParams[compositionOptions.keyParameter];
+                    const keyParam = operation.parameters.find(p => p.keyParam) || controller.parameters.find(p => p.keyParam);
+                    const key = keyParam && context.pathParams[String(keyParam.name)];
                     const options = {
                         filter: context.queryParams.filter,
                     };
@@ -51,7 +52,8 @@ var MongoAdapter;
                     return { method: 'findMany', options };
                 }
                 case 'Entity.Get': {
-                    const key = context.pathParams[compositionOptions.keyParameter];
+                    const keyParam = operation.parameters.find(p => p.keyParam) || controller.parameters.find(p => p.keyParam);
+                    const key = keyParam && context.pathParams[String(keyParam.name)];
                     const options = {
                         projection: context.queryParams.projection,
                         filter: context.queryParams.filter,
@@ -60,7 +62,8 @@ var MongoAdapter;
                 }
                 case 'Entity.Update': {
                     const data = await context.getBody();
-                    const key = context.pathParams[compositionOptions.keyParameter];
+                    const keyParam = operation.parameters.find(p => p.keyParam) || controller.parameters.find(p => p.keyParam);
+                    const key = keyParam && context.pathParams[String(keyParam.name)];
                     const options = {
                         projection: context.queryParams.projection,
                         filter: context.queryParams.filter,
@@ -74,6 +77,8 @@ var MongoAdapter;
                     };
                     return { method: 'updateMany', data, options };
                 }
+                default:
+                    break;
             }
         }
         throw new Error(`This operation is not compatible to MongoDB adapter`);

package/cjs/mongo-collection-service.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoCollectionService = void 0;
-const mongodb_1 = require("mongodb");
 const common_1 = require("@opra/common");
 const mongo_adapter_js_1 = require("./mongo-adapter.js");
 const mongo_entity_service_js_1 = require("./mongo-entity-service.js");
@@ -26,7 +25,7 @@ class MongoCollectionService extends mongo_entity_service_js_1.MongoEntityServic
      * Throws a ResourceNotFoundError if the resource does not exist.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the resource to assert.
-     * @param {MongoCollectionService.ExistsOptions<T>} [options] - Optional options for checking the existence.
+     * @param {MongoEntityService.ExistsOptions<T>} [options] - Optional options for checking the existence.
      * @returns {Promise<void>} - A Promise that resolves when the resource exists.
      * @throws {ResourceNotAvailableError} - If the resource does not exist.
      */
@@ -39,112 +38,126 @@ class MongoCollectionService extends mongo_entity_service_js_1.MongoEntityServic
      * Interceptors will be called before performing db operation
      *
      * @param {PartialDTO<T>} input - The input data for creating the document.
-     * @param {MongoCollectionService.CreateOptions} [options] - The options for creating the document.
+     * @param {MongoEntityService.CreateOptions} [options] - The options for creating the document.
      * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created document.
      * @throws {Error} if an unknown error occurs while creating the document.
      */
     async create(input, options) {
-        const id = input._id || this._generateId();
-        if (id != null)
-            input._id = id;
-        const info = {
+        const command = {
             crud: 'create',
             method: 'create',
             byId: false,
-            documentId: id,
             input,
             options,
         };
-        return this._intercept(() => this._create(input, options), info);
+        return this._executeCommand(command, () => this._create(command));
     }
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
-     * @param {MongoCollectionService.CountOptions<T>} options - The options for the count operation.
+     * @param {MongoEntityService.CountOptions<T>} options - The options for the count operation.
      * @return {Promise<number>} - A promise that resolves to the count of documents in the collection.
      */
     async count(options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'count',
             byId: false,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._count({ ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._count(command);
+        });
     }
     /**
      * Deletes a document from the collection.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document to delete.
-     * @param {MongoCollectionService.DeleteOptions<T>} [options] - Optional delete options.
+     * @param {MongoEntityService.DeleteOptions<T>} [options] - Optional delete options.
      * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
      */
     async delete(id, options) {
-        const info = {
+        const command = {
             crud: 'delete',
             method: 'delete',
             byId: true,
             documentId: id,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._delete(id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._delete(command);
+        });
     }
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {MongoCollectionService.DeleteManyOptions<T>} options - The options for the delete operation.
+     * @param {MongoEntityService.DeleteManyOptions<T>} options - The options for the delete operation.
      * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
      */
     async deleteMany(options) {
-        const info = {
+        const command = {
             crud: 'delete',
             method: 'deleteMany',
             byId: false,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._deleteMany({ ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._deleteMany(command);
+        });
     }
     /**
      * The distinct command returns a list of distinct values for the given key across a collection.
      * @param {string} field
-     * @param {MongoCollectionService.DistinctOptions<T>} [options]
+     * @param {MongoEntityService.DistinctOptions<T>} [options]
      * @protected
      */
     async distinct(field, options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'distinct',
-            byId: true,
+            byId: false,
+            field,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._distinct(field, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._distinct(command);
+        });
     }
     /**
      * Checks if an object with the given id exists.
      *
      * @param {MongoAdapter.AnyId} id - The id of the object to check.
-     * @param {MongoCollectionService.ExistsOptions<T>} [options] - The options for the query (optional).
+     * @param {MongoEntityService.ExistsOptions<T>} [options] - The options for the query (optional).
      * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
      */
     async exists(id, options) {
-        return !!(await this.findById(id, { ...options, projection: ['_id'] }));
+        const command = {
+            crud: 'read',
+            method: 'exists',
+            byId: true,
+            documentId: id,
+            options,
+        };
+        return this._executeCommand(command, async () => {
+            const documentFilter = await this._getDocumentFilter(command);
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([documentFilter, command.options?.filter]);
+            const findCommand = command;
+            findCommand.options = { ...command.options, filter, projection: ['_id'] };
+            return !!(await this._findById(findCommand));
+        });
     }
     /**
      * Checks if an object with the given arguments exists.
      *
-     * @param {MongoCollectionService.ExistsOneOptions} [options] - The options for the query (optional).
+     * @param {MongoEntityService.ExistsOneOptions} [options] - The options for the query (optional).
      * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
      */
     async existsOne(options) {
@@ -154,83 +167,87 @@ class MongoCollectionService extends mongo_entity_service_js_1.MongoEntityServic
      * Finds a document by its ID.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document.
-     * @param {MongoCollectionService.FindOneOptions<T>} [options] - The options for the find query.
+     * @param {MongoEntityService.FindOneOptions<T>} [options] - The options for the find query.
      * @return {Promise<PartialDTO<T | undefined>>} - A promise resolving to the found document, or undefined if not found.
      */
     async findById(id, options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'findById',
             byId: true,
             documentId: id,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = await this._getDocumentFilter(info);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([documentFilter, options?.filter]);
-            return this._findById(id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const documentFilter = await this._getDocumentFilter(command);
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([documentFilter, command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._findById(command);
+        });
     }
     /**
      * Finds a document in the collection that matches the specified options.
      *
-     * @param {MongoCollectionService.FindOneOptions<T>} [options] - The options for the query.
+     * @param {MongoEntityService.FindOneOptions<T>} [options] - The options for the query.
      * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
      */
     async findOne(options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'findOne',
             byId: false,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._findOne({ ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._findOne(command);
+        });
     }
     /**
      * Finds multiple documents in the MongoDB collection.
      *
-     * @param {MongoCollectionService.FindManyOptions<T>} options - The options for the find operation.
+     * @param {MongoEntityService.FindManyOptions<T>} options - The options for the find operation.
      * @return A Promise that resolves to an array of partial outputs of type T.
      */
     async findMany(options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'findMany',
             byId: false,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._findMany({ ...options, filter, limit: options?.limit || this.defaultLimit });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter, limit: command.options?.limit || this.defaultLimit };
+            return this._findMany(command);
+        });
     }
     /**
      * Finds multiple documents in the collection and returns both records (max limit)
      * and total count that matched the given criteria
      *
-     * @param {MongoCollectionService.FindManyOptions<T>} [options] - The options for the find operation.
+     * @param {MongoEntityService.FindManyOptions<T>} [options] - The options for the find operation.
      * @return A Promise that resolves to an array of partial outputs of type T.
      */
     async findManyWithCount(options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'findManyWithCount',
             byId: false,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._findManyWithCount({ ...options, filter, limit: options?.limit || this.defaultLimit });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter, limit: command.options?.limit || this.defaultLimit };
+            return this._findManyWithCount(command);
+        });
     }
     /**
      * Retrieves a document from the collection by its ID. Throws error if not found.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document to retrieve.
-     * @param {MongoCollectionService.FindOneOptions<T>} [options] - Optional options for the findOne operation.
+     * @param {MongoEntityService.FindOneOptions<T>} [options] - Optional options for the findOne operation.
      * @returns {Promise<PartialDTO<T>>} - A promise that resolves to the retrieved document,
      *    or rejects with a ResourceNotFoundError if the document does not exist.
      * @throws {ResourceNotAvailableError} - If the document with the specified ID does not exist.
@@ -246,74 +263,74 @@ class MongoCollectionService extends mongo_entity_service_js_1.MongoEntityServic
      *
      * @param {MongoAdapter.AnyId} id - The id of the document to update.
      * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input object containing the fields to update.
-     * @param {MongoCollectionService.UpdateOptions<T>} [options] - The options for the update operation.
+     * @param {MongoEntityService.UpdateOneOptions<T>} [options] - The options for the update operation.
      * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the updated document or
      * undefined if the document was not found.
      */
     async update(id, input, options) {
-        const info = {
+        const isUpdateFilter = Array.isArray(input) || !!Object.keys(input).find(x => x.startsWith('$'));
+        const command = {
             crud: 'update',
             method: 'update',
             documentId: id,
             byId: true,
-            input,
+            input: isUpdateFilter ? undefined : input,
+            inputRaw: isUpdateFilter ? input : undefined,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._update(id, input, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._update(command);
+        });
     }
     /**
      * Updates a document in the collection with the specified ID.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document to update.
      * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input data to update the document with.
-     * @param {MongoCollectionService.UpdateOptions<T>} [options] - The options for updating the document.
+     * @param {MongoEntityService.UpdateOneOptions<T>} [options] - The options for updating the document.
      * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
      */
     async updateOnly(id, input, options) {
-        const info = {
+        const isUpdateFilter = Array.isArray(input) || !!Object.keys(input).find(x => x.startsWith('$'));
+        const command = {
             crud: 'update',
-            method: 'update',
+            method: 'updateOnly',
             documentId: id,
             byId: true,
-            input,
+            input: isUpdateFilter ? undefined : input,
+            inputRaw: isUpdateFilter ? input : undefined,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._updateOnly(id, input, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._updateOnly(command);
+        });
     }
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
      * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input to update the documents with.
-     * @param {MongoCollectionService.UpdateManyOptions<T>} options - The options for updating the documents.
+     * @param {MongoEntityService.UpdateManyOptions<T>} options - The options for updating the documents.
      * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
      */
     async updateMany(input, options) {
-        const info = {
+        const isUpdateFilter = Array.isArray(input) || !!Object.keys(input).find(x => x.startsWith('$'));
+        const command = {
             crud: 'update',
             method: 'updateMany',
             byId: false,
-            input,
+            input: isUpdateFilter ? undefined : input,
+            inputRaw: isUpdateFilter ? input : undefined,
             options,
         };
-        return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._updateMany(input, { ...options, filter });
-        }, info);
-    }
-    /**
-     * Generates an ID.
-     *
-     * @protected
-     * @returns {MongoAdapter.AnyId} The generated ID.
-     */
-    _generateId() {
-        return typeof this.$idGenerator === 'function' ? this.$idGenerator(this) : new mongodb_1.ObjectId();
+        return this._executeCommand(command, async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._updateMany(command);
+        });
     }
 }
 exports.MongoCollectionService = MongoCollectionService;