@opra/elastic 0.18.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @opra/mongodb
+
+OPRA MongoDB package.

package/cjs/elastic-adapter.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElasticAdapter = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable camelcase */
+const lodash_isnil_1 = tslib_1.__importDefault(require("lodash.isnil"));
+const lodash_omitby_1 = tslib_1.__importDefault(require("lodash.omitby"));
+const common_1 = require("@opra/common");
+const transform_filter_js_1 = tslib_1.__importDefault(require("./transform-filter.js"));
+const transform_key_values_js_1 = tslib_1.__importDefault(require("./transform-key-values.js"));
+const transform_projection_js_1 = tslib_1.__importDefault(require("./transform-projection.js"));
+const transform_sort_js_1 = tslib_1.__importDefault(require("./transform-sort.js"));
+var ElasticAdapter;
+(function (ElasticAdapter) {
+    ElasticAdapter.transformFilter = transform_filter_js_1.default;
+    ElasticAdapter.transformKeyValues = transform_key_values_js_1.default;
+    ElasticAdapter.transformProjection = transform_projection_js_1.default;
+    ElasticAdapter.transformSort = transform_sort_js_1.default;
+    function transformRequest(request) {
+        const { resource } = request;
+        if (resource instanceof common_1.Collection || resource instanceof common_1.Singleton) {
+            const { args, operation } = request;
+            let options = {};
+            switch (operation) {
+                case 'findMany': {
+                    let params = {};
+                    const filter = ElasticAdapter.transformFilter(args.filter);
+                    if (filter)
+                        params.query = filter;
+                    if (args.limit != null)
+                        params.size = args.limit;
+                    if (args.skip != null)
+                        params.from = args.skip;
+                    if (args.count)
+                        params.track_total_hits = true;
+                    if (args.pick || args.include || args.omit)
+                        params._source = (0, transform_projection_js_1.default)(resource.type, args);
+                    if (args.sort)
+                        params.sort = (0, transform_sort_js_1.default)(args.sort);
+                    params = (0, lodash_omitby_1.default)(params, lodash_isnil_1.default);
+                    options = (0, lodash_omitby_1.default)(options, lodash_isnil_1.default);
+                    return {
+                        method: 'search',
+                        params,
+                        options,
+                        args: [params, options]
+                    };
+                }
+            }
+        }
+        throw new TypeError(`Unimplemented request (${request.resourceKind}.${request.operation})`);
+    }
+    ElasticAdapter.transformRequest = transformRequest;
+})(ElasticAdapter = exports.ElasticAdapter || (exports.ElasticAdapter = {}));

package/cjs/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./elastic-adapter.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/transform-filter.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("@opra/core");
+const lodash_isnil_1 = tslib_1.__importDefault(require("lodash.isnil"));
+const common_1 = require("@opra/common");
+function transformFilter(ast, negative) {
+    if (!ast)
+        return;
+    if (ast instanceof common_1.OpraFilter.QualifiedIdentifier) {
+        return ast.value;
+    }
+    if (ast instanceof common_1.OpraFilter.NumberLiteral ||
+        ast instanceof common_1.OpraFilter.StringLiteral ||
+        ast instanceof common_1.OpraFilter.BooleanLiteral ||
+        ast instanceof common_1.OpraFilter.NullLiteral ||
+        ast instanceof common_1.OpraFilter.DateLiteral ||
+        ast instanceof common_1.OpraFilter.TimeLiteral) {
+        return ast.value;
+    }
+    if (ast instanceof common_1.OpraFilter.ArrayExpression) {
+        return ast.items
+            .map(x => transformFilter(x, negative))
+            .filter(x => !(0, lodash_isnil_1.default)(x));
+    }
+    if (ast instanceof common_1.OpraFilter.NegativeExpression) {
+        return transformFilter(ast.expression, !negative);
+    }
+    if (ast instanceof common_1.OpraFilter.LogicalExpression) {
+        const v = ast.items
+            .map(x => transformFilter(x))
+            .filter(x => !(0, lodash_isnil_1.default)(x));
+        if (ast.op === 'and') {
+            return {
+                'bool': {
+                    [(negative ? 'must_not' : 'must')]: v
+                }
+            };
+        }
+        return wrapNot({
+            'bool': { 'should': v }
+        }, negative);
+    }
+    if (ast instanceof common_1.OpraFilter.ParenthesizedExpression) {
+        return transformFilter(ast.expression, negative);
+    }
+    if (ast instanceof common_1.OpraFilter.ComparisonExpression)
+        return _transformComparisonExpression(ast, !!negative);
+    throw new Error(`${ast.kind} is not implemented yet`);
+}
+exports.default = transformFilter;
+function _transformComparisonExpression(ast, negative) {
+    const left = transformFilter(ast.left, negative);
+    if (ast.right instanceof common_1.OpraFilter.QualifiedIdentifier) {
+        throw new TypeError('not implemented yet');
+    }
+    const right = transformFilter(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);
+    }
+    throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+}
+const wrapNot = (o, negative) => negative ? { 'bool': { 'must_not': o } } : o;

package/cjs/transform-key-values.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function transformKeyValues(resource, keyValues) {
+    const { primaryKey } = resource;
+    if (primaryKey.length > 1) {
+        const out = {};
+        primaryKey.forEach((k, i) => {
+            out[k] = typeof keyValues === 'object' ? keyValues[k] : keyValues[i];
+        });
+        return out;
+    }
+    return { [primaryKey[0]]: keyValues };
+}
+exports.default = transformKeyValues;

package/cjs/transform-projection.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const lodash_isnil_1 = tslib_1.__importDefault(require("lodash.isnil"));
+const lodash_omitby_1 = tslib_1.__importDefault(require("lodash.omitby"));
+const common_1 = require("@opra/common");
+function transformProjection(dataType, args) {
+    let includes;
+    let excludes;
+    if (args.include && !args.pick) {
+        includes = includes || [];
+        for (const [k, f] of dataType.fields) {
+            if (f.exclusive)
+                continue;
+            if (f.type instanceof common_1.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 common_1.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 common_1.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 common_1.ComplexType)
+                excludes.push(k + '.*');
+            else
+                excludes.push(k);
+        }
+    }
+    return (0, lodash_omitby_1.default)({
+        includes,
+        excludes
+    }, lodash_isnil_1.default);
+}
+exports.default = transformProjection;

package/cjs/transform-sort.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function transformSort(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);
+    });
+    return out;
+}
+exports.default = transformSort;

package/esm/elastic-adapter.js

@@ -0,0 +1,50 @@
+/* eslint-disable camelcase */
+import isNil from 'lodash.isnil';
+import omitBy from 'lodash.omitby';
+import { Collection, Singleton } from '@opra/common';
+import _transformFilter from './transform-filter.js';
+import _transformKeyValues from './transform-key-values.js';
+import _transformProjection from './transform-projection.js';
+import _transformSort from './transform-sort.js';
+export var ElasticAdapter;
+(function (ElasticAdapter) {
+    ElasticAdapter.transformFilter = _transformFilter;
+    ElasticAdapter.transformKeyValues = _transformKeyValues;
+    ElasticAdapter.transformProjection = _transformProjection;
+    ElasticAdapter.transformSort = _transformSort;
+    function transformRequest(request) {
+        const { resource } = request;
+        if (resource instanceof Collection || resource instanceof Singleton) {
+            const { args, operation } = request;
+            let options = {};
+            switch (operation) {
+                case 'findMany': {
+                    let params = {};
+                    const filter = ElasticAdapter.transformFilter(args.filter);
+                    if (filter)
+                        params.query = filter;
+                    if (args.limit != null)
+                        params.size = args.limit;
+                    if (args.skip != null)
+                        params.from = args.skip;
+                    if (args.count)
+                        params.track_total_hits = true;
+                    if (args.pick || args.include || args.omit)
+                        params._source = _transformProjection(resource.type, args);
+                    if (args.sort)
+                        params.sort = _transformSort(args.sort);
+                    params = omitBy(params, isNil);
+                    options = omitBy(options, isNil);
+                    return {
+                        method: 'search',
+                        params,
+                        options,
+                        args: [params, options]
+                    };
+                }
+            }
+        }
+        throw new TypeError(`Unimplemented request (${request.resourceKind}.${request.operation})`);
+    }
+    ElasticAdapter.transformRequest = transformRequest;
+})(ElasticAdapter || (ElasticAdapter = {}));

package/esm/index.js

@@ -0,0 +1 @@
+export * from './elastic-adapter.js';

package/esm/transform-filter.js

@@ -0,0 +1,105 @@
+import '@opra/core';
+import isNil from 'lodash.isnil';
+import { OpraFilter } from '@opra/common';
+export default function transformFilter(ast, negative) {
+    if (!ast)
+        return;
+    if (ast instanceof OpraFilter.QualifiedIdentifier) {
+        return ast.value;
+    }
+    if (ast instanceof OpraFilter.NumberLiteral ||
+        ast instanceof OpraFilter.StringLiteral ||
+        ast instanceof OpraFilter.BooleanLiteral ||
+        ast instanceof OpraFilter.NullLiteral ||
+        ast instanceof OpraFilter.DateLiteral ||
+        ast instanceof OpraFilter.TimeLiteral) {
+        return ast.value;
+    }
+    if (ast instanceof OpraFilter.ArrayExpression) {
+        return ast.items
+            .map(x => transformFilter(x, negative))
+            .filter(x => !isNil(x));
+    }
+    if (ast instanceof OpraFilter.NegativeExpression) {
+        return transformFilter(ast.expression, !negative);
+    }
+    if (ast instanceof OpraFilter.LogicalExpression) {
+        const v = ast.items
+            .map(x => transformFilter(x))
+            .filter(x => !isNil(x));
+        if (ast.op === 'and') {
+            return {
+                'bool': {
+                    [(negative ? 'must_not' : 'must')]: v
+                }
+            };
+        }
+        return wrapNot({
+            'bool': { 'should': v }
+        }, negative);
+    }
+    if (ast instanceof OpraFilter.ParenthesizedExpression) {
+        return transformFilter(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 = transformFilter(ast.left, negative);
+    if (ast.right instanceof OpraFilter.QualifiedIdentifier) {
+        throw new TypeError('not implemented yet');
+    }
+    const right = transformFilter(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);
+    }
+    throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+}
+const wrapNot = (o, negative) => negative ? { 'bool': { 'must_not': o } } : o;

package/esm/transform-key-values.js

@@ -0,0 +1,11 @@
+export default function transformKeyValues(resource, keyValues) {
+    const { primaryKey } = resource;
+    if (primaryKey.length > 1) {
+        const out = {};
+        primaryKey.forEach((k, i) => {
+            out[k] = typeof keyValues === 'object' ? keyValues[k] : keyValues[i];
+        });
+        return out;
+    }
+    return { [primaryKey[0]]: keyValues };
+}

package/esm/transform-projection.js

@@ -0,0 +1,52 @@
+import isNil from 'lodash.isnil';
+import omitBy from 'lodash.omitby';
+import { ComplexType } from '@opra/common';
+export default function transformProjection(dataType, args) {
+    let includes;
+    let excludes;
+    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 omitBy({
+        includes,
+        excludes
+    }, isNil);
+}

package/esm/transform-sort.js

@@ -0,0 +1,14 @@
+export default function transformSort(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);
+    });
+    return out;
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@opra/elastic",
+  "version": "0.18.0",
+  "description": "Opra Elastic Search adapter package",
+  "author": "Panates",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/elastic"
+  },
+  "scripts": {
+    "compile": "tsc",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -b tsconfig-build-cjs.json",
+    "build:esm": "tsc -b tsconfig-build-esm.json",
+    "postbuild": "cp README.md package.json ../../LICENSE ../../build/elastic && cp ../../package.cjs.json ../../build/elastic/cjs/package.json",
+    "lint": "eslint . --max-warnings=0",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
+    "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
+    "clean:src": "ts-cleanup -s src --all && ts-cleanup -s test --all",
+    "clean:dist": "rimraf ../../build/elastic",
+    "clean:cover": "rimraf ../../coverage/elastic"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "@elastic/elasticsearch": "^8.7.0",
+    "@faker-js/faker": "^8.0.0",
+    "ts-gems": "^2.4.0"
+  },
+  "peerDependencies": {
+    "@elastic/elasticsearch": ">=8.7.0",
+    "@opra/common": "^0.18.0",
+    "@opra/core": "^0.18.0"
+  },
+  "type": "module",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "default": "./esm/index.js"
+    },
+    "./cjs": "./cjs/index.js",
+    "./esm": "./esm/index.js"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "bin/",
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "opra",
+    "elastic",
+    "elasticsearch",
+    "adapter"
+  ]
+}

package/types/elastic-adapter.d.ts

@@ -0,0 +1,12 @@
+import { Request } from '@opra/core';
+import _transformFilter from './transform-filter.js';
+import _transformKeyValues from './transform-key-values.js';
+import _transformProjection from './transform-projection.js';
+import _transformSort from './transform-sort.js';
+export declare namespace ElasticAdapter {
+    const transformFilter: typeof _transformFilter;
+    const transformKeyValues: typeof _transformKeyValues;
+    const transformProjection: typeof _transformProjection;
+    const transformSort: typeof _transformSort;
+    function transformRequest(request: Request): any;
+}

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from './elastic-adapter.js';

package/types/transform-filter.d.ts

@@ -0,0 +1,3 @@
+import '@opra/core';
+import { OpraFilter } from '@opra/common';
+export default function transformFilter(ast: OpraFilter.Expression | undefined, negative?: boolean): any;

package/types/transform-key-values.d.ts

@@ -0,0 +1,2 @@
+import { Collection } from '@opra/common';
+export default function transformKeyValues(resource: Collection, keyValues: any): Record<string, any>;

package/types/transform-projection.d.ts

@@ -0,0 +1,6 @@
+import { ComplexType } from '@opra/common';
+export default function transformProjection(dataType: ComplexType, args: {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+}): any;

package/types/transform-sort.d.ts

@@ -0,0 +1 @@
+export default function transformSort(sort?: string[]): any[] | undefined;