@opra/mongodb 0.33.13 → 1.0.0-alpha.2

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

@@ -8,7 +8,7 @@ const opMap = {
     '>=': '$gte',
     '<': '$lt',
     '<=': '$lte',
-    'in': '$in',
+    in: '$in',
     '!in': '$nin',
 };
 /**
@@ -63,9 +63,7 @@ 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;
 }
 exports.default = prepareFilter;
 function addPrefix(source, prefix) {
@@ -85,10 +83,8 @@ function addPrefix(source, prefix) {
 function prepareFilterAst(ast, negative) {
     if (!ast)
         return;
-    if (ast instanceof common_1.OpraFilter.QualifiedIdentifier) {
-        return ast.value;
-    }
-    if (ast instanceof common_1.OpraFilter.NumberLiteral ||
+    if (ast instanceof common_1.OpraFilter.QualifiedIdentifier ||
+        ast instanceof common_1.OpraFilter.NumberLiteral ||
         ast instanceof common_1.OpraFilter.StringLiteral ||
         ast instanceof common_1.OpraFilter.BooleanLiteral ||
         ast instanceof common_1.OpraFilter.NullLiteral ||
@@ -103,9 +99,7 @@ function prepareFilterAst(ast, negative) {
         return prepareFilterAst(ast.expression, !negative);
     }
     if (ast instanceof common_1.OpraFilter.LogicalExpression) {
-        const items = ast.items
-            .map(x => prepareFilterAst(x, negative))
-            .filter(x => x != null);
+        const items = ast.items.map(x => prepareFilterAst(x, negative)).filter(x => x != null);
         if (ast.op === 'or')
             return { $or: items };
         return { $and: items };
@@ -118,15 +112,13 @@ function prepareFilterAst(ast, negative) {
         if (ast.right instanceof common_1.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 === '!=')
@@ -146,38 +138,38 @@ 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),
                 };
         }
         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/cjs/adapter-utils/prepare-projection.js

@@ -1,52 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._prepareProjection = void 0;
+exports.prepare = void 0;
 const common_1 = require("@opra/common");
-function prepareProjection(dataType, options) {
+function prepareProjection(dataType, projection) {
+    if (projection && typeof projection === 'object' && !Array.isArray(projection))
+        return projection;
     const out = {};
-    const pick = options?.pick && (0, common_1.pathToObjectTree)(options.pick);
-    const include = options?.include && (0, common_1.pathToObjectTree)(options.include);
-    const omit = options?.omit && (0, common_1.pathToObjectTree)(options.omit);
+    const projection_ = typeof projection === 'string' || Array.isArray(projection) ? (0, common_1.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;
 }
 exports.default = prepareProjection;
-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))))
+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 common_1.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 common_1.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;
+        }
     }
 }
-exports._prepareProjection = _prepareProjection;
+exports.prepare = prepare;

package/cjs/index.js

@@ -2,8 +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-array-service.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-service.js"), exports);
 tslib_1.__exportStar(require("./mongo-singleton-service.js"), exports);
-tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/mongo-adapter.js

@@ -9,9 +9,74 @@ const prepare_projection_js_1 = tslib_1.__importDefault(require("./adapter-utils
 const prepare_sort_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-sort.js"));
 var MongoAdapter;
 (function (MongoAdapter) {
-    MongoAdapter.prepareKeyValues = prepare_key_values_js_1.default;
     MongoAdapter.prepareFilter = prepare_filter_js_1.default;
+    MongoAdapter.prepareKeyValues = prepare_key_values_js_1.default;
     MongoAdapter.preparePatch = prepare_patch_js_1.default;
     MongoAdapter.prepareProjection = prepare_projection_js_1.default;
     MongoAdapter.prepareSort = prepare_sort_js_1.default;
+    async function parseRequest(context) {
+        const { operation } = context;
+        if (operation.composition?.startsWith('Entity.') && operation.compositionOptions?.type) {
+            const { compositionOptions } = operation;
+            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 key = context.pathParams[compositionOptions.keyParameter];
+                    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 key = context.pathParams[compositionOptions.keyParameter];
+                    const options = {
+                        projection: context.queryParams.projection,
+                        filter: context.queryParams.filter,
+                    };
+                    return { method: 'get', key, options };
+                }
+                case 'Entity.Update': {
+                    const data = await context.getBody();
+                    const key = context.pathParams[compositionOptions.keyParameter];
+                    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 };
+                }
+            }
+        }
+        throw new Error(`This operation is not compatible to MongoDB adapter`);
+    }
+    MongoAdapter.parseRequest = parseRequest;
 })(MongoAdapter || (exports.MongoAdapter = MongoAdapter = {}));