@opra/elastic 1.0.0-alpha.32 → 1.0.0-beta.2

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

@@ -1,14 +1,31 @@
 /* eslint-disable camelcase */
 import '@opra/core';
 import { OpraFilter } from '@opra/common';
-const isNil = (v) => v == null;
-export default function prepareFilter(ast, negative) {
-    if (!ast)
+export default function prepareFilter(filters) {
+    const filtersArray = Array.isArray(filters) ? filters : [filters];
+    if (!filtersArray.length)
         return;
-    if (ast instanceof OpraFilter.QualifiedIdentifier) {
-        return ast.value;
+    const out = [];
+    for (const filter of filtersArray) {
+        if (!filter)
+            continue;
+        let x = filter;
+        if (typeof filter === 'string')
+            x = prepareFilterAst(OpraFilter.parse(filter));
+        else if (filter instanceof OpraFilter.Expression)
+            x = prepareFilterAst(filter);
+        out.push(x);
     }
-    if (ast instanceof OpraFilter.NumberLiteral ||
+    if (out.length > 1) {
+        return { bool: { must: [...out] } };
+    }
+    return out[0] ? out[0] : undefined;
+}
+function prepareFilterAst(ast, negative) {
+    if (!ast)
+        return;
+    if (ast instanceof OpraFilter.QualifiedIdentifier ||
+        ast instanceof OpraFilter.NumberLiteral ||
         ast instanceof OpraFilter.StringLiteral ||
         ast instanceof OpraFilter.BooleanLiteral ||
         ast instanceof OpraFilter.NullLiteral ||
@@ -17,86 +34,77 @@ export default function prepareFilter(ast, negative) {
         return ast.value;
     }
     if (ast instanceof OpraFilter.ArrayExpression) {
-        return ast.items.map(x => prepareFilter(x, negative)).filter(x => !isNil(x));
+        return ast.items.map(x => prepareFilterAst(x, negative));
     }
     if (ast instanceof OpraFilter.NegativeExpression) {
-        return prepareFilter(ast.expression, !negative);
+        return prepareFilterAst(ast.expression, !negative);
     }
     if (ast instanceof OpraFilter.LogicalExpression) {
-        const v = ast.items.map(x => prepareFilter(x)).filter(x => !isNil(x));
-        if (ast.op === 'and') {
-            return {
-                bool: {
-                    [negative ? 'must_not' : 'must']: v,
-                },
-            };
-        }
-        return wrapNot({
-            bool: { should: v },
-        }, negative);
+        const items = ast.items
+            .map(x => prepareFilterAst(x))
+            /** Filter nullish items */
+            .filter(x => x != null);
+        const k = (ast.op === 'or' ? 'should' : 'must') + (negative ? '_not' : '');
+        return { bool: { [k]: items } };
     }
     if (ast instanceof OpraFilter.ParenthesizedExpression) {
-        return prepareFilter(ast.expression, negative);
-    }
-    if (ast instanceof OpraFilter.ComparisonExpression)
-        return _transformComparisonExpression(ast, !!negative);
-    throw new Error(`${ast.kind} is not implemented yet`);
-}
-function _transformComparisonExpression(ast, negative) {
-    const left = prepareFilter(ast.left, negative);
-    if (ast.right instanceof OpraFilter.QualifiedIdentifier) {
-        throw new TypeError('not implemented yet');
+        return prepareFilterAst(ast.expression, negative);
     }
-    const right = prepareFilter(ast.right);
-    if (right == null) {
-        const op = ast.op === '=' ? (negative ? '!=' : '=') : negative ? '=' : '!=';
-        if (op === '=')
-            return { bool: { must_not: { exists: { field: left } } } };
-        if (op === '!=')
-            return { bool: { exists: { field: left } } };
-    }
-    switch (ast.op) {
-        case '=':
-            return wrapNot({ term: { [left]: right } }, negative);
-        case '!=':
-            return wrapNot({ term: { [left]: right } }, !negative);
-        case '>':
-            return wrapNot({ range: { [left]: { gt: right } } }, negative);
-        case '>=':
-            return wrapNot({ range: { [left]: { gte: right } } }, negative);
-        case '<':
-            return wrapNot({ range: { [left]: { lt: right } } }, negative);
-        case '<=':
-            return wrapNot({ range: { [left]: { lte: right } } }, negative);
-        case 'in':
-            return wrapNot({ terms: { [left]: Array.isArray(right) ? right : [right] } }, negative);
-        case '!in':
-            return wrapNot({ terms: { [left]: Array.isArray(right) ? right : [right] } }, !negative);
-        case 'like':
-            return wrapNot({ wildcard: { [left]: String(right) } }, negative);
-        case '!like':
-            return wrapNot({ wildcard: { [left]: String(right) } }, !negative);
-        case 'ilike':
-            return wrapNot({
-                wildcard: {
-                    [left]: {
-                        value: String(right),
-                        case_insensitive: true,
-                    },
-                },
-            }, negative);
-        case '!ilike':
-            return wrapNot({
-                wildcard: {
-                    [left]: {
-                        value: String(right),
-                        case_insensitive: true,
-                    },
-                },
-            }, !negative);
-        default:
-            break;
+    if (ast instanceof OpraFilter.ComparisonExpression) {
+        if (!(ast.left instanceof OpraFilter.QualifiedIdentifier)) {
+            throw new Error('Left side of ComparisonExpression must be a QualifiedIdentifier');
+        }
+        const left = prepareFilterAst(ast.left);
+        const right = prepareFilterAst(ast.right);
+        let out;
+        if (right == null) {
+            negative = !negative;
+            out = { exists: { field: left } };
+        }
+        else {
+            switch (ast.op) {
+                case '!=':
+                case '=':
+                case 'in':
+                case '!in': {
+                    out = { match: { [left]: right } };
+                    break;
+                }
+                case '>': {
+                    out = { range: { [left]: { gt: right } } };
+                    break;
+                }
+                case '>=': {
+                    out = { range: { [left]: { gte: right } } };
+                    break;
+                }
+                case '<': {
+                    out = { range: { [left]: { lt: right } } };
+                    break;
+                }
+                case '<=': {
+                    out = { range: { [left]: { lte: right } } };
+                    break;
+                }
+                case '!like':
+                case 'like': {
+                    out = { wildcard: { [left]: { value: String(right).replace(/%/g, '*') } } };
+                    break;
+                }
+                case '!ilike':
+                case 'ilike': {
+                    out = { wildcard: { [left]: { value: String(right).replace(/%/g, '*'), case_insensitive: true } } };
+                    break;
+                }
+                default:
+                    /* istanbul ignore next */
+                    throw new TypeError(`Unknown ComparisonExpression operation (${ast.op})`);
+            }
+        }
+        if ((ast.op.startsWith('!') && !negative) || (!ast.op.startsWith('!') && negative)) {
+            return { bool: { must_not: { ...out } } };
+        }
+        return out;
     }
-    throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+    throw new Error(`${ast.kind} is not implemented yet`);
 }
-const wrapNot = (o, negative) => (negative ? { bool: { must_not: o } } : o);

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

@@ -0,0 +1,32 @@
+export default function preparePatch(doc) {
+    const script = [];
+    const params = {};
+    _preparePatch(doc, script, params, '');
+    return {
+        source: script.join('\n'),
+        params,
+        lang: 'painless',
+    };
+}
+function _preparePatch(src, script, params, path) {
+    let f;
+    let field;
+    for (const [k, v] of Object.entries(src)) {
+        f = k.startsWith('*') ? k.substring(1) : k;
+        field = path ? path + '.' + f : f;
+        if (v == null) {
+            script.push(`ctx._source.remove('${field}');`);
+            continue;
+        }
+        if (v &&
+            typeof v === 'object' &&
+            !Array.isArray(v) &&
+            /** If field name starts with "*", do "replace" operation except "merge" */
+            !k.startsWith('*')) {
+            _preparePatch(v, script, params, field);
+            continue;
+        }
+        script.push(`ctx._source['${field}'] = params['${field}'];`);
+        params[field] = v;
+    }
+}

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

@@ -1,109 +1,62 @@
-"use strict";
-// import { ApiField, ComplexType, FieldsProjection, omitNullish, parseFieldsProjection } from '@opra/common';
-// import mongodb, { Document } from 'mongodb';
-//
-// export default function prepareProjection(
-//   dataType: ComplexType,
-//   projection?: string | string[] | Document,
-// ): mongodb.Document | undefined {
-//   if (projection && typeof projection === 'object' && !Array.isArray(projection)) return projection;
-//   const out: Record<string, boolean> = {};
-//   const projection_ =
-//     typeof projection === 'string' || Array.isArray(projection) ? parseFieldsProjection(projection) : projection;
-//   // const exclusionProjection = !pick && !!omit;
-//   prepare(dataType, out, projection_);
-//   return Object.keys(out).length ? out : undefined;
-// }
-//
-// export function prepare(dataType: ComplexType, target: mongodb.Document, projection?: FieldsProjection) {
-//   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: string;
-//   let field: ApiField;
-//   let k: string;
-//   /** 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 (field.type instanceof ComplexType && typeof p?.projection === 'object') {
-//       target[fieldName] = {};
-//       prepare(field.type, target[fieldName], p.projection);
-//       continue;
-//     }
-//     target[fieldName] = 1;
-//   }
-//   /** Add additional fields */
-//   if (dataType.additionalFields) {
-//     for (k of projectionKeysSet.values()) {
-//       const n = projectionKeysSet[k];
-//       if (n?.sign !== '-') target[k] = 1;
-//     }
-//   }
-// }
-//
-// // function __prepareProjection(
-// //   dataType: ComplexType,
-// //   args: {
-// //     pick?: string[];
-// //     omit?: string[];
-// //     include?: string[];
-// //   },
-// // ): any {
-// //   let includes: string[] | undefined;
-// //   let excludes: string[] | undefined;
-// //
-// //   if (args.include && !args.pick) {
-// //     includes = includes || [];
-// //     for (const [k, f] of dataType.fields) {
-// //       if (f.exclusive) continue;
-// //       if (f.type instanceof ComplexType) includes.push(k + '.*');
-// //       else includes.push(k);
-// //     }
-// //   }
-// //
-// //   if (args.pick) {
-// //     includes = includes || [];
-// //     for (const k of args.pick) {
-// //       const f = dataType.getField(k);
-// //       if (f.type instanceof ComplexType) includes.push(k + '.*');
-// //       else includes.push(k);
-// //     }
-// //   }
-// //
-// //   if (args.include) {
-// //     includes = includes || [];
-// //     for (const k of args.include) {
-// //       const f = dataType.getField(k);
-// //       if (f.type instanceof ComplexType) includes.push(k + '.*');
-// //       else includes.push(k);
-// //     }
-// //   }
-// //
-// //   if (args.omit) {
-// //     excludes = excludes || [];
-// //     for (const k of args.omit) {
-// //       const f = dataType.getField(k);
-// //       if (f.type instanceof ComplexType) excludes.push(k + '.*');
-// //       else excludes.push(k);
-// //     }
-// //   }
-// //
-// //   return omitNullish({
-// //     includes,
-// //     excludes,
-// //   });
-// // }
+import { ComplexType, parseFieldsProjection } from '@opra/common';
+export default function prepareProjection(dataType, projection) {
+    const out = {};
+    const includes = [];
+    const excludes = [];
+    const projection_ = typeof projection === 'string' || Array.isArray(projection) ? parseFieldsProjection(projection) : projection;
+    prepare(dataType, includes, excludes, '', projection_);
+    if (includes.length)
+        out.includes = includes;
+    if (excludes.length)
+        out.excludes = excludes;
+    return includes.length || excludes.length ? out : undefined;
+}
+function getNeedIncludes(projection) {
+    return !!(projection && Object.values(projection).find(p => !p.sign));
+}
+export function prepare(dataType, includes, excludes, curPath, projection) {
+    const needIncludes = getNeedIncludes(projection);
+    const projectionKeys = projection && Object.keys(projection);
+    const projectionKeysSet = new Set(projectionKeys);
+    let fieldName;
+    let fieldPath;
+    let field;
+    let k;
+    /** Add fields from data type */
+    for (field of dataType.fields.values()) {
+        fieldName = field.name;
+        fieldPath = curPath + (curPath ? '.' : '') + fieldName;
+        k = fieldName.toLowerCase();
+        projectionKeysSet.delete(k);
+        const p = projection?.[k];
+        if (
+        /** if field is omitted */
+        p?.sign === '-' ||
+            /** if no projection defined for this field and includeDefaultFields is true and the field is exclusive */
+            (!p && field.exclusive)) {
+            if (!needIncludes)
+                excludes.push(fieldPath);
+            continue;
+        }
+        if (needIncludes && p && !includes.includes(fieldPath)) {
+            if (!getNeedIncludes(p?.projection)) {
+                includes.push(fieldPath);
+            }
+        }
+        if (field.type instanceof ComplexType && typeof p?.projection === 'object') {
+            prepare(field.type, includes, excludes, fieldPath, p.projection);
+        }
+    }
+    if (dataType.additionalFields) {
+        for (k of projectionKeysSet.values()) {
+            const n = projection?.[k];
+            fieldPath = curPath + (curPath ? '.' : '') + k;
+            if (n?.sign === '-') {
+                if (!needIncludes)
+                    excludes.push(fieldPath);
+            }
+            else
+                includes.push(fieldPath);
+        }
+    }
+}

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

@@ -1,14 +1,13 @@
+const SIGN_PATTERN = /^([+-])?(.+)$/;
 export default function prepareSort(sort) {
     if (!(sort && sort.length))
         return;
     const out = [];
     sort.forEach(k => {
-        if (k.startsWith('-'))
-            out.push({ [k.substring(1)]: 'desc' });
-        else if (k.startsWith('+'))
-            out.push(k.substring(1));
-        else
-            out.push(k);
+        const m = SIGN_PATTERN.exec(k);
+        if (m) {
+            out.push({ [m[2]]: { order: m[1] === '-' ? 'desc' : 'asc' } });
+        }
     });
     return out;
 }

package/esm/elastic-adapter.js

@@ -1,15 +1,12 @@
-// import { SearchRequest } from '@elastic/elasticsearch/lib/api/types';
-// import { TransportRequestOptions } from '@elastic/transport';
-// import { omitNullish } from '@opra/common';
 import _prepareFilter from './adapter-utils/prepare-filter.js';
-import _prepareKeyValues from './adapter-utils/prepare-key-values.js';
-// import _prepareProjection from './adapter-utils/prepare-projection.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 ElasticAdapter;
 (function (ElasticAdapter) {
     ElasticAdapter.prepareFilter = _prepareFilter;
-    ElasticAdapter.prepareKeyValues = _prepareKeyValues;
-    // export const prepareProjection = _prepareProjection;
+    ElasticAdapter.preparePatch = _preparePatch;
+    ElasticAdapter.prepareProjection = _prepareProjection;
     ElasticAdapter.prepareSort = _prepareSort;
     async function parseRequest(context) {
         const { operation } = context;