@opra/mongodb 1.20.0 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/mongodb",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "description": "Opra MongoDB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -10,46 +10,29 @@
     "valgen": "^5.18.2"
   },
   "peerDependencies": {
-    "@opra/common": "^1.20.0",
-    "@opra/core": "^1.20.0",
-    "@opra/http": "^1.20.0",
+    "@opra/common": "^1.22.0",
+    "@opra/core": "^1.22.0",
+    "@opra/http": "^1.22.0",
     "mongodb": "^7.0.0"
   },
-  "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./types/index.d.ts",
-        "default": "./esm/index.js"
-      },
-      "require": {
-        "types": "./types/index.d.cts",
-        "default": "./cjs/index.js"
-      },
-      "default": "./esm/index.js"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./cjs/index.js",
-  "module": "./esm/index.js",
-  "types": "./types/index.d.ts",
+  "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/panates/opra.git",
     "directory": "packages/mongodb"
   },
-  "engines": {
-    "node": ">=16.0",
-    "npm": ">=7.0.0"
-  },
-  "files": [
-    "bin/",
-    "cjs/",
-    "esm/",
-    "types/",
-    "LICENSE",
-    "README.md"
-  ],
   "keywords": [
     "opra",
     "mongodb",

package/{esm/services → services}/mongo-collection-service.js

@@ -6,6 +6,12 @@ import { MongoEntityService } from './mongo-entity-service.js';
  * @template T - The type of the documents in the collection.
  */
 export class MongoCollectionService extends MongoEntityService {
+    /**
+     * Represents the default limit value for a certain operation.
+     *
+     * @type {number}
+     */
+    defaultLimit;
     /**
      * Constructs a new instance
      *

package/{esm/services → services}/mongo-nested-service.js

@@ -10,6 +10,30 @@ import { MongoService } from './mongo-service.js';
  * @template T The type of the array item.
  */
 export class MongoNestedService extends MongoService {
+    /**
+     * Represents the name of the array field in parent document
+     *
+     * @type {string}
+     */
+    fieldName;
+    /**
+     * Represents the value of a nested array key field
+     *
+     * @type {string}
+     */
+    nestedKey;
+    /**
+     * Represents the default limit value for a certain operation.
+     *
+     * @type {number}
+     */
+    defaultLimit;
+    /**
+     * Represents a common array filter function
+     *
+     * @type {FilterInput | Function}
+     */
+    nestedFilter;
     /**
      * Constructs a new instance
      *

package/{esm/services → services}/mongo-service.js

@@ -9,6 +9,50 @@ const transactionKey = Symbol.for('transaction');
  * @template T - The type of the documents in the collection.
  */
 export class MongoService extends ServiceBase {
+    _dataTypeScope;
+    _dataType_;
+    _dataType;
+    _inputCodecs = {};
+    _outputCodecs = {};
+    /**
+     * Defines comma delimited scopes for api document
+     */
+    scope;
+    /**
+     * Represents the name of a collection in MongoDB
+     */
+    collectionName;
+    /**
+     * Represents the name of a resource.
+     * @type {string}
+     */
+    resourceName;
+    /**
+     * Represents a MongoDB database object.
+     */
+    db;
+    /**
+     * Represents a MongoDB ClientSession.
+     */
+    session;
+    /**
+     * Generates a new id for new inserting Document.
+     *
+     */
+    idGenerator;
+    /**
+     * Callback function for handling errors.
+     *
+     * @param {unknown} error - The error object.
+     * @param _this - The context object.
+     */
+    onError;
+    /**
+     * Represents a common filter function for a MongoService.
+     *
+     * @type {FilterInput | Function}
+     */
+    documentFilter;
     /**
      * Constructs a new instance
      *
@@ -18,8 +62,6 @@ export class MongoService extends ServiceBase {
      */
     constructor(dataType, options) {
         super();
-        this._inputCodecs = {};
-        this._outputCodecs = {};
         this._dataType_ = dataType;
         this.db = options?.db;
         this.documentFilter = options?.documentFilter;

package/{esm/services → services}/mongo-singleton-service.js

@@ -10,6 +10,11 @@ import { MongoEntityService } from './mongo-entity-service.js';
  * @template T - The type of document stored in the collection
  */
 export class MongoSingletonService extends MongoEntityService {
+    /**
+     * Represents a unique identifier for singleton record
+     * @type {MongoAdapter.AnyId} _id
+     */
+    _id;
     /**
      * Constructs a new instance
      *

package/cjs/adapter/mongo-adapter.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoAdapter = void 0;
-const tslib_1 = require("tslib");
-const prepare_filter_js_1 = tslib_1.__importDefault(require("./prepare-filter.js"));
-const prepare_key_values_js_1 = tslib_1.__importDefault(require("./prepare-key-values.js"));
-const prepare_projection_js_1 = tslib_1.__importDefault(require("./prepare-projection.js"));
-const prepare_sort_js_1 = tslib_1.__importDefault(require("./prepare-sort.js"));
-var MongoAdapter;
-(function (MongoAdapter) {
-    MongoAdapter.prepareFilter = prepare_filter_js_1.default;
-    MongoAdapter.prepareKeyValues = prepare_key_values_js_1.default;
-    MongoAdapter.prepareProjection = prepare_projection_js_1.default;
-    MongoAdapter.prepareSort = prepare_sort_js_1.default;
-    async function parseRequest(context) {
-        if (context.transport !== 'http') {
-            throw new TypeError('MongoAdapter can parse only HttpContext');
-        }
-        const ctx = context;
-        const { __oprDef } = ctx;
-        if (__oprDef?.composition?.startsWith('Entity.') &&
-            __oprDef.compositionOptions?.type) {
-            const controller = __oprDef.owner;
-            switch (__oprDef.composition) {
-                case 'Entity.Create': {
-                    const data = await ctx.getBody();
-                    const options = {
-                        projection: ctx.queryParams.projection,
-                    };
-                    return {
-                        method: 'create',
-                        data,
-                        options,
-                    };
-                }
-                case 'Entity.Delete': {
-                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
-                        controller.parameters.find(p => p.keyParam);
-                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
-                    const options = {
-                        filter: ctx.queryParams.filter,
-                    };
-                    return {
-                        method: 'delete',
-                        key,
-                        options,
-                    };
-                }
-                case 'Entity.DeleteMany': {
-                    const options = {
-                        filter: ctx.queryParams.filter,
-                    };
-                    return { method: 'deleteMany', options };
-                }
-                case 'Entity.FindMany': {
-                    const options = {
-                        filter: ctx.queryParams.filter,
-                        projection: ctx.queryParams.projection ||
-                            __oprDef.compositionOptions.defaultProjection,
-                        count: ctx.queryParams.count,
-                        limit: ctx.queryParams.limit || __oprDef.compositionOptions.defaultLimit,
-                        skip: ctx.queryParams.skip,
-                        sort: ctx.queryParams.sort || __oprDef.compositionOptions.defaultSort,
-                    };
-                    return { method: 'findMany', options };
-                }
-                case 'Entity.Get': {
-                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
-                        controller.parameters.find(p => p.keyParam);
-                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
-                    const options = {
-                        projection: ctx.queryParams.projection,
-                        filter: ctx.queryParams.filter,
-                    };
-                    return { method: 'get', key, options };
-                }
-                case 'Entity.Replace': {
-                    const data = await ctx.getBody();
-                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
-                        controller.parameters.find(p => p.keyParam);
-                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
-                    const options = {
-                        projection: ctx.queryParams.projection,
-                        filter: ctx.queryParams.filter,
-                    };
-                    return {
-                        method: 'replace',
-                        key,
-                        data,
-                        options,
-                    };
-                }
-                case 'Entity.Update': {
-                    const data = await ctx.getBody();
-                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
-                        controller.parameters.find(p => p.keyParam);
-                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
-                    const options = {
-                        projection: ctx.queryParams.projection,
-                        filter: ctx.queryParams.filter,
-                    };
-                    return {
-                        method: 'update',
-                        key,
-                        data,
-                        options,
-                    };
-                }
-                case 'Entity.UpdateMany': {
-                    const data = await ctx.getBody();
-                    const options = {
-                        filter: ctx.queryParams.filter,
-                    };
-                    return {
-                        method: 'updateMany',
-                        data,
-                        options,
-                    };
-                }
-                default:
-                    break;
-            }
-        }
-        throw new Error(`This operation is not compatible to MongoDB adapter`);
-    }
-    MongoAdapter.parseRequest = parseRequest;
-})(MongoAdapter || (exports.MongoAdapter = MongoAdapter = {}));

package/cjs/adapter/mongo-patch-generator.js

@@ -1,215 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoPatchGenerator = void 0;
-const common_1 = require("@opra/common");
-const FIELD_NAME_PATTERN = /^([-><*:])?(.+)$/;
-class MongoPatchGenerator {
-    generatePatch(dataType, doc, options) {
-        const ctx = {};
-        this._processComplexType(ctx, dataType, options?.currentPath || '', doc, options?.scope);
-        const update = {};
-        if (ctx.$pull)
-            update.$pull = ctx.$pull;
-        if (ctx.$unset)
-            update.$unset = ctx.$unset;
-        if (ctx.$set)
-            update.$set = ctx.$set;
-        if (ctx.$push)
-            update.$push = ctx.$push;
-        return {
-            update,
-            arrayFilters: ctx.arrayFilters,
-            initArrayFields: ctx.initArrayFields,
-        };
-    }
-    _processComplexType(ctx, dataType, path, input, scope) {
-        let result = false;
-        if (input._$push) {
-            result =
-                result || this._processPush(ctx, dataType, path, input._$push, scope);
-        }
-        if (input._$pull) {
-            result =
-                result || this._processPull(ctx, dataType, path, input._$pull, scope);
-        }
-        const keys = Object.keys(input);
-        const pathDot = path + (path ? '.' : '');
-        let field;
-        let key;
-        let value;
-        let keyField;
-        let keyValue;
-        let arrayIndex = 0;
-        let arrayFilterName = '';
-        for (key of keys) {
-            const m = FIELD_NAME_PATTERN.exec(key);
-            if (!m)
-                continue;
-            key = m[2];
-            if (key === '_$push' || key === '_$pull')
-                continue;
-            value = input[key];
-            field = dataType.findField(key, scope);
-            if (field && !field.inScope(scope))
-                continue;
-            /** Field not found */
-            if (!field) {
-                /** Additional fields will be updated */
-                if (dataType.additionalFields) {
-                    if (value === null) {
-                        ctx.$unset = ctx.$unset || {};
-                        ctx.$unset[pathDot + key] = 1;
-                        result = true;
-                    }
-                    else {
-                        ctx.$set = ctx.$set || {};
-                        if (dataType.additionalFields instanceof common_1.ComplexType) {
-                            /** Process nested object */
-                            if (this._processComplexType(ctx, dataType.additionalFields, pathDot + key, value, scope)) {
-                                result = true;
-                            }
-                            continue;
-                        }
-                        ctx.$set[pathDot + key] = value;
-                        result = true;
-                    }
-                }
-                continue;
-            }
-            /** Unset field value if null */
-            if (value === null) {
-                ctx.$unset = ctx.$unset || {};
-                ctx.$unset[pathDot + field.name] = 1;
-                result = true;
-                continue;
-            }
-            if (field.type instanceof common_1.ComplexType) {
-                if (!value)
-                    continue;
-                if (field.isArray) {
-                    if (field.isNestedEntity) {
-                        ctx.initArrayFields = ctx.initArrayFields || [];
-                        ctx.initArrayFields.push(pathDot + field.name);
-                        if (!value.length)
-                            continue;
-                        keyField = field.keyField || field.type.keyField;
-                        if (keyField) {
-                            for (let v of value) {
-                                /** Increase arrayIndex and determine a new name for array filter  */
-                                arrayFilterName = 'f' + String(++arrayIndex);
-                                /** Extract key value from object */
-                                keyValue = v[keyField];
-                                if (keyValue == null)
-                                    continue;
-                                v = { ...v };
-                                /** Remove key field from object */
-                                delete v[keyField];
-                                /** Process each object in array */
-                                if (this._processComplexType(ctx, field.type, pathDot + field.name + `.$[${arrayFilterName}]`, v, scope)) {
-                                    result = true;
-                                    /** Add array filter */
-                                    ctx.arrayFilters = ctx.arrayFilters || [];
-                                    ctx.arrayFilters.unshift({
-                                        [`${arrayFilterName}.${keyField}`]: keyValue,
-                                    });
-                                }
-                            }
-                            continue;
-                        }
-                    }
-                }
-                else {
-                    if (!(typeof value === 'object'))
-                        continue;
-                    /** Process nested object */
-                    if (this._processComplexType(ctx, field.type, pathDot + field.name, value, scope)) {
-                        result = true;
-                    }
-                    continue;
-                }
-            }
-            ctx.$set = ctx.$set || {};
-            ctx.$set[pathDot + field.name] = value;
-            result = true;
-        }
-        return result;
-    }
-    _processPush(ctx, dataType, path, input, scope) {
-        let result = false;
-        let field;
-        let key;
-        let value;
-        const pathDot = path + (path ? '.' : '');
-        const keys = Object.keys(input);
-        let keyField;
-        for (key of keys) {
-            value = input[key];
-            field = dataType.getField(key, scope);
-            if (!(field && field.isArray))
-                continue;
-            ctx.$push = ctx.$push || {};
-            if (field.type instanceof common_1.ComplexType) {
-                keyField = field.keyField || field.type.keyField;
-                if (keyField) {
-                    if (Array.isArray(value)) {
-                        value.forEach(v => {
-                            if (!v[keyField]) {
-                                throw new TypeError(`You must provide a key value of ${field.type.name} for $push operation.`);
-                            }
-                        });
-                        ctx.$push[pathDot + key] = { $each: value };
-                        result = true;
-                    }
-                    else {
-                        if (!value[keyField]) {
-                            throw new TypeError(`You must provide a key value of ${field.type.name} for $push operation.`);
-                        }
-                        ctx.$push[pathDot + key] = value;
-                        result = true;
-                    }
-                }
-                continue;
-            }
-            ctx.$push[pathDot + key] = Array.isArray(value)
-                ? { $each: value }
-                : value;
-            result = true;
-        }
-        return result;
-    }
-    _processPull(ctx, dataType, path, input, scope) {
-        let result = false;
-        let field;
-        let key;
-        let value;
-        const pathDot = path + (path ? '.' : '');
-        const keys = Object.keys(input);
-        let keyField;
-        for (key of keys) {
-            value = input[key];
-            field = dataType.getField(key, scope);
-            if (!(field && field.isArray))
-                continue;
-            ctx.$pull = ctx.$pull || {};
-            if (field.type instanceof common_1.ComplexType) {
-                keyField = field.keyField || field.type.keyField;
-                if (!keyField)
-                    continue;
-                ctx.$pull[pathDot + key] = {
-                    $elemMatch: {
-                        [keyField]: Array.isArray(value) ? { $in: value } : value,
-                    },
-                };
-                result = true;
-            }
-            else {
-                ctx.$pull[pathDot + key] = Array.isArray(value)
-                    ? { $in: value }
-                    : value;
-                result = true;
-            }
-        }
-        return result;
-    }
-}
-exports.MongoPatchGenerator = MongoPatchGenerator;