@opra/mongodb 0.33.13 → 1.0.0-alpha.10

package/cjs/mongo-singleton-service.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoSingletonService = void 0;
-const mongodb_1 = require("mongodb");
 const common_1 = require("@opra/common");
+const mongodb_1 = require("mongodb");
 const mongo_adapter_js_1 = require("./mongo-adapter.js");
-const mongo_service_js_1 = require("./mongo-service.js");
+const mongo_entity_service_js_1 = require("./mongo-entity-service.js");
 /**
  * A class that provides access to a MongoDB collection, with support for singleton document operations.
  * @class MongoSingletonService
  * @extends MongoService
  * @template T - The type of document stored in the collection
  */
-class MongoSingletonService extends mongo_service_js_1.MongoService {
+class MongoSingletonService extends mongo_entity_service_js_1.MongoEntityService {
     /**
      * Constructs a new instance
      *
@@ -21,14 +21,12 @@ class MongoSingletonService extends mongo_service_js_1.MongoService {
      */
     constructor(dataType, options) {
         super(dataType, options);
-        this.collectionKey = this.collectionKey || options?.collectionKey || '_id';
         this._id = this._id || options?._id || new mongodb_1.ObjectId('655608925cad472b75fc6485');
-        this.$documentFilter = this.$documentFilter || options?.documentFilter;
-        this.$interceptor = this.$interceptor || options?.interceptor;
     }
     /**
      * Asserts the existence of a resource based on the given options.
      *
+     * @param {MongoSingletonService.ExistsOptions<T>} [options]
      * @returns {Promise<void>} A Promise that resolves when the resource exists.
      * @throws {ResourceNotAvailableError} If the resource does not exist.
      */
@@ -39,37 +37,23 @@ class MongoSingletonService extends mongo_service_js_1.MongoService {
     /**
      * Creates the document in the database.
      *
-     * @param {DTO<T>} input - The partial input to create the document with.
+     * @param {PartialDTO<T>} input - The partial input to create the document with.
      * @param {MongoSingletonService.CreateOptions} [options] - The options for creating the document.
      * @return {Promise<PartialDTO<T>>} A promise that resolves to the partial output of the created document.
      * @throws {Error} Throws an error if an unknown error occurs while creating the document.
      */
     async create(input, options) {
+        input._id = this._id;
         const info = {
             crud: 'create',
             method: 'create',
+            byId: false,
+            documentId: this._id,
             input,
             options,
         };
         return this._intercept(() => this._create(input, options), info);
     }
-    async _create(input, options) {
-        const encode = this.getEncoder('create');
-        const doc = encode(input);
-        doc._id = this._id;
-        const r = await this.__insertOne(doc, options);
-        if (r.insertedId) {
-            if (!options)
-                return doc;
-            const out = await this._findOne(options);
-            if (out)
-                return out;
-            if (!out)
-                throw new common_1.ResourceNotAvailableError(this.getResourceName());
-        }
-        /* istanbul ignore next */
-        throw new common_1.InternalServerError(`Unknown error while creating document for "${this.getResourceName()}"`);
-    }
     /**
      * Deletes a record from the database
      *
@@ -80,77 +64,51 @@ class MongoSingletonService extends mongo_service_js_1.MongoService {
         const info = {
             crud: 'delete',
             method: 'delete',
+            byId: true,
+            documentId: this._id,
             options,
         };
         return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
-            return this._delete({ ...options, filter });
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._delete(this._id, { ...options, filter });
         }, info);
     }
-    async _delete(options) {
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            { _id: this._id },
-            options?.filter
-        ]);
-        const r = await this.__deleteOne(filter, options);
-        return r.deletedCount;
-    }
     /**
      * Checks if the document exists in the database.
      *
      * @return {Promise<boolean>} - A promise that resolves to a boolean value indicating if the document exists.
      */
     async exists(options) {
-        return !!(await this.findOne({ ...options, pick: ['_id'], omit: undefined, include: undefined }));
+        return !!(await this.find({ ...options, projection: ['_id'], skip: undefined }));
     }
     /**
      * Fetches the document if it exists. Returns undefined if not found.
      *
-     * @param {MongoSingletonService.FindOptions<T>} [options] - The options for finding the document.
+     * @param {MongoSingletonService.FindOneOptions<T>} [options] - The options for finding the document.
      * @returns {Promise<PartialDTO<T> | undefined>} - A promise that resolves to the found document or undefined if not found.
      */
-    async findOne(options) {
+    async find(options) {
         const info = {
             crud: 'read',
             method: 'findOne',
+            byId: true,
+            documentId: this._id,
             options,
         };
         return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
-            return this._findOne({ ...options, filter });
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._findById(this._id, { ...options, filter });
         }, info);
     }
-    async _findOne(options) {
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            { _id: this._id },
-            options?.filter
-        ]);
-        const mongoOptions = {
-            ...options,
-            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
-            sort: undefined,
-            skip: undefined,
-            limit: undefined
-        };
-        const decoder = this.getDecoder();
-        const out = await this.__findOne(filter, mongoOptions);
-        return out ? decoder(out) : undefined;
-    }
     /**
      * Fetches the document from the Mongo collection service. Throws error if not found.
      *
-     * @param {MongoCollectionService.FindOneOptions} options - The options to customize the query.
+     * @param {MongoSingletonService.FindOneOptions<T>} options - The options to customize the query.
      * @return {Promise<PartialDTO<T>>} - A promise that resolves to the fetched document.
      * @throws {ResourceNotAvailableError} - If the document is not found in the collection.
      */
     async get(options) {
-        const out = await this.findOne(options);
+        const out = await this.find(options);
         if (!out)
             throw new common_1.ResourceNotAvailableError(this.getResourceName());
         return out;
@@ -167,34 +125,16 @@ class MongoSingletonService extends mongo_service_js_1.MongoService {
         const info = {
             crud: 'update',
             method: 'update',
+            byId: true,
+            documentId: this._id,
             input,
             options,
         };
         return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
-            return this._updateOnly(input, { ...options, filter });
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._updateOnly(this._id, input, { ...options, filter });
         }, info);
     }
-    async _updateOnly(input, options) {
-        const encode = this.getEncoder('update');
-        const doc = encode(input);
-        const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
-        const mongoOptions = {
-            ...options,
-            includeResultMetadata: false,
-            upsert: undefined,
-            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
-        };
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            { _id: this._id },
-            options?.filter
-        ]);
-        const r = await this.__updateOne(filter, patch, mongoOptions);
-        return r.modifiedCount;
-    }
     /**
      * Updates a document in the MongoDB collection.
      *
@@ -207,51 +147,15 @@ class MongoSingletonService extends mongo_service_js_1.MongoService {
         const info = {
             crud: 'update',
             method: 'update',
+            byId: true,
+            documentId: this._id,
             input,
             options,
         };
         return this._intercept(async () => {
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
-            return this._update(input, { ...options, filter });
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._update(this._id, input, { ...options, filter });
         }, info);
     }
-    async _update(input, options) {
-        const encode = this.getEncoder('update');
-        const doc = encode(input);
-        const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
-        const mongoOptions = {
-            ...options,
-            includeResultMetadata: false,
-            upsert: undefined,
-            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
-        };
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            { _id: this._id },
-            options?.filter
-        ]);
-        const decoder = this.getDecoder();
-        const out = await this.__findOneAndUpdate(filter, patch, mongoOptions);
-        return out ? decoder(out) : undefined;
-    }
-    /**
-     * Retrieves the common filter used for querying the document.
-     * This method is mostly used for security issues like securing multi-tenant applications.
-     *
-     * @protected
-     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
-     * that resolves to the common filter, or undefined if not available.
-     */
-    _getDocumentFilter(args) {
-        return typeof this.$documentFilter === 'function' ?
-            this.$documentFilter(args, this) : this.$documentFilter;
-    }
-    async _intercept(callback, args) {
-        if (this.$interceptor)
-            return this.$interceptor(callback, args, this);
-        return callback();
-    }
 }
 exports.MongoSingletonService = MongoSingletonService;

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

@@ -6,7 +6,7 @@ const opMap = {
     '>=': '$gte',
     '<': '$lt',
     '<=': '$lte',
-    'in': '$in',
+    in: '$in',
     '!in': '$nin',
 };
 /**
@@ -61,9 +61,7 @@ export default function prepareFilter(filters, options) {
         }
         i++;
     }
-    return i
-        ? (options?.fieldPrefix ? addPrefix(out, options.fieldPrefix) : out)
-        : undefined;
+    return i ? (options?.fieldPrefix ? addPrefix(out, options.fieldPrefix) : out) : undefined;
 }
 function addPrefix(source, prefix) {
     if (typeof source !== 'object')
@@ -82,10 +80,8 @@ function addPrefix(source, prefix) {
 function prepareFilterAst(ast, negative) {
     if (!ast)
         return;
-    if (ast instanceof OpraFilter.QualifiedIdentifier) {
-        return ast.value;
-    }
-    if (ast instanceof OpraFilter.NumberLiteral ||
+    if (ast instanceof OpraFilter.QualifiedIdentifier ||
+        ast instanceof OpraFilter.NumberLiteral ||
         ast instanceof OpraFilter.StringLiteral ||
         ast instanceof OpraFilter.BooleanLiteral ||
         ast instanceof OpraFilter.NullLiteral ||
@@ -100,9 +96,7 @@ function prepareFilterAst(ast, negative) {
         return prepareFilterAst(ast.expression, !negative);
     }
     if (ast instanceof OpraFilter.LogicalExpression) {
-        const items = ast.items
-            .map(x => prepareFilterAst(x, negative))
-            .filter(x => x != null);
+        const items = ast.items.map(x => prepareFilterAst(x, negative)).filter(x => x != null);
         if (ast.op === 'or')
             return { $or: items };
         return { $and: items };
@@ -115,15 +109,13 @@ function prepareFilterAst(ast, negative) {
         if (ast.right instanceof OpraFilter.QualifiedIdentifier) {
             const op = opMap[ast.op];
             if (op)
-                return { $expr: { [op]: ["$" + left, "$" + ast.right.value] } };
+                return { $expr: { [op]: ['$' + left, '$' + ast.right.value] } };
             /* istanbul ignore next */
             throw new Error(`Invalid filter query.`);
         }
         let right = prepareFilterAst(ast.right);
         if (right == null) {
-            const op = ast.op === '='
-                ? (negative ? '!=' : '=')
-                : (negative ? '=' : '!=');
+            const op = ast.op === '=' ? (negative ? '!=' : '=') : negative ? '=' : '!=';
             if (op === '=')
                 return { $or: [{ [left]: null }, { [left]: { $exists: false } }] };
             if (op === '!=')
@@ -143,38 +135,40 @@ function prepareFilterAst(ast, negative) {
                     [left]: wrapNot({
                         $text: {
                             $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
-                            $caseSensitive: true
-                        }
-                    }, negative)
+                            $caseSensitive: true,
+                        },
+                    }, negative),
                 };
             case 'ilike':
                 return {
                     [left]: wrapNot({
                         $text: {
-                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
-                        }
-                    }, negative)
+                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
+                        },
+                    }, negative),
                 };
             case '!like':
                 return {
                     [left]: wrapNot({
                         $text: {
                             $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
-                            $caseSensitive: true
-                        }
-                    }, !negative)
+                            $caseSensitive: true,
+                        },
+                    }, !negative),
                 };
             case '!ilike':
                 return {
                     [left]: wrapNot({
                         $text: {
-                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
-                        }
-                    }, !negative)
+                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
+                        },
+                    }, !negative),
                 };
+            default:
+                break;
         }
         throw new Error(`Unimplemented ComparisonExpression operation (right side is ${ast.right.kind})`);
     }
     throw new Error(`${ast.kind} is not implemented yet`);
 }
-const wrapNot = (o, negative) => negative ? { $not: o } : o;
+const wrapNot = (o, negative) => (negative ? { $not: o } : o);

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

@@ -3,13 +3,14 @@ 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) {
+        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;
         }, {});
     }

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

@@ -4,10 +4,11 @@ export default function preparePatch(doc, options) {
     trg.$set = trg.$set || {};
     return trg;
 }
-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/esm/adapter-utils/prepare-projection.js

@@ -1,47 +1,48 @@
-import { ComplexType, pathToObjectTree } from '@opra/common';
-export default function prepareProjection(dataType, options) {
+import { ComplexType, parseFieldsProjection } from '@opra/common';
+export default function prepareProjection(dataType, projection) {
+    if (projection && typeof projection === 'object' && !Array.isArray(projection))
+        return projection;
     const out = {};
-    const pick = options?.pick && pathToObjectTree(options.pick);
-    const include = options?.include && pathToObjectTree(options.include);
-    const omit = options?.omit && pathToObjectTree(options.omit);
+    const projection_ = typeof projection === 'string' || Array.isArray(projection) ? parseFieldsProjection(projection) : projection;
     // const exclusionProjection = !pick && !!omit;
-    _prepareProjection(dataType, out, {
-        pickActivated: !!pick,
-        pick,
-        include,
-        omit
-    });
+    prepare(dataType, out, projection_);
     return Object.keys(out).length ? out : undefined;
 }
-export function _prepareProjection(dataType, target, 
-// exclusionProjection: boolean,
-options) {
-    // const defaultFields = options?.defaultFields ?? !options?.pick;
-    const optionsOmit = options?.omit;
-    const optionsPick = options?.pick;
-    const optionsInclude = options?.include;
-    const pickActivated = options?.pickActivated;
-    for (const [k, f] of dataType.fields.entries()) {
-        const fieldOmit = optionsOmit?.[k];
-        const fieldInclude = optionsInclude?.[k];
-        const fieldPick = optionsPick?.[k];
-        if (fieldOmit === true ||
-            !((pickActivated && fieldPick) ||
-                (!pickActivated && (!f.exclusive || fieldInclude))))
+export 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());
+    const projectionKeysSet = new Set(projectionKeys);
+    let fieldName;
+    let field;
+    let k;
+    /** Add fields from data type */
+    for (field of dataType.fields.values()) {
+        fieldName = field.name;
+        k = fieldName.toLowerCase();
+        projectionKeysSet.delete(k);
+        const p = projection?.[k];
+        if (
+        /** Ignore if field is omitted */
+        p?.sign === '-' ||
+            /** Ignore if default fields and field is not in projection */
+            (!defaultFields && !p) ||
+            /** Ignore if default fields enabled and fields is exclusive */
+            (defaultFields && field.exclusive && !p)) {
             continue;
-        if (f.type instanceof ComplexType &&
-            (typeof fieldInclude === 'object' ||
-                typeof fieldPick === 'object' ||
-                typeof fieldOmit === 'object')) {
-            target[k] = {};
-            _prepareProjection(f.type, target[k], {
-                pickActivated: fieldPick != null && fieldPick !== true,
-                include: typeof fieldInclude === 'object' ? fieldInclude : undefined,
-                pick: typeof fieldPick === 'object' ? fieldPick : undefined,
-                omit: typeof fieldOmit === 'object' ? fieldOmit : undefined
-            });
+        }
+        if (field.type instanceof ComplexType && typeof p?.projection === 'object') {
+            target[fieldName] = {};
+            prepare(field.type, target[fieldName], p.projection);
             continue;
         }
-        target[k] = 1;
+        target[fieldName] = 1;
+    }
+    /** Add additional fields */
+    if (dataType.additionalFields) {
+        for (k of projectionKeysSet.values()) {
+            const n = projectionKeysSet[k];
+            if (n?.sign !== '-')
+                target[k] = 1;
+        }
     }
 }

package/esm/index.js

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

package/esm/mongo-adapter.js

@@ -5,9 +5,79 @@ import _prepareProjection from './adapter-utils/prepare-projection.js';
 import _prepareSort from './adapter-utils/prepare-sort.js';
 export var MongoAdapter;
 (function (MongoAdapter) {
-    MongoAdapter.prepareKeyValues = _prepareKeyValues;
     MongoAdapter.prepareFilter = _prepareFilter;
+    MongoAdapter.prepareKeyValues = _prepareKeyValues;
     MongoAdapter.preparePatch = _preparePatch;
     MongoAdapter.prepareProjection = _prepareProjection;
     MongoAdapter.prepareSort = _prepareSort;
+    async function parseRequest(context) {
+        const { operation } = context;
+        if (operation.composition?.startsWith('Entity.') && operation.compositionOptions?.type) {
+            const controller = operation.owner;
+            switch (operation.composition) {
+                case 'Entity.Create': {
+                    const data = await context.getBody();
+                    const options = {
+                        projection: context.queryParams.projection,
+                    };
+                    return { method: 'create', data, options };
+                }
+                case 'Entity.Delete': {
+                    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,
+                    };
+                    return { method: 'delete', key, options };
+                }
+                case 'Entity.DeleteMany': {
+                    const options = {
+                        filter: context.queryParams.filter,
+                    };
+                    return { method: 'deleteMany', options };
+                }
+                case 'Entity.FindMany': {
+                    const options = {
+                        filter: context.queryParams.filter,
+                        projection: context.queryParams.projection,
+                        count: context.queryParams.count,
+                        limit: context.queryParams.limit,
+                        skip: context.queryParams.skip,
+                        sort: context.queryParams.sort,
+                    };
+                    return { method: 'findMany', options };
+                }
+                case 'Entity.Get': {
+                    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,
+                    };
+                    return { method: 'get', key, options };
+                }
+                case 'Entity.Update': {
+                    const data = await context.getBody();
+                    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,
+                    };
+                    return { method: 'update', key, data, options };
+                }
+                case 'Entity.UpdateMany': {
+                    const data = await context.getBody();
+                    const options = {
+                        filter: context.queryParams.filter,
+                    };
+                    return { method: 'updateMany', data, options };
+                }
+                default:
+                    break;
+            }
+        }
+        throw new Error(`This operation is not compatible to MongoDB adapter`);
+    }
+    MongoAdapter.parseRequest = parseRequest;
 })(MongoAdapter || (MongoAdapter = {}));