@opra/elastic 1.21.0 → 1.22.0

package/{esm/elastic-collection-service.js → elastic-collection-service.js}

@@ -6,6 +6,18 @@ import { ElasticEntityService } from './elastic-entity-service.js';
  * @template T - The type of the documents in the collection.
  */
 export class ElasticCollectionService extends ElasticEntityService {
+    /**
+     * Represents a common filter function for a ElasticService.
+     *
+     * @type {FilterInput | Function}
+     */
+    documentFilter;
+    /**
+     * Represents the default limit value for a certain operation.
+     *
+     * @type {number}
+     */
+    defaultLimit;
     /**
      * Constructs a new instance
      *

package/{esm/elastic-entity-service.js → elastic-entity-service.js}

@@ -7,6 +7,29 @@ import { ElasticService } from './elastic-service.js';
  * @template T - The type of the documents in the collection.
  */
 export class ElasticEntityService extends ElasticService {
+    _dataTypeScope;
+    _dataType_;
+    _dataType;
+    _inputCodecs = {};
+    _outputCodecs = {};
+    /**
+     * Defines comma delimited scopes for api document
+     */
+    scope;
+    /**
+     * Represents the name of a index in ElasticDB
+     */
+    indexName;
+    /**
+     * Represents the name of a resource.
+     * @type {string}
+     */
+    resourceName;
+    /**
+     * Generates a new id for new inserting Document.
+     *
+     */
+    idGenerator;
     /**
      * Constructs a new instance
      *
@@ -16,8 +39,6 @@ export class ElasticEntityService extends ElasticService {
      */
     constructor(dataType, options) {
         super(options);
-        this._inputCodecs = {};
-        this._outputCodecs = {};
         this._dataType_ = dataType;
         if (options?.indexName)
             this.indexName = options?.indexName;

package/{esm/elastic-service.js → elastic-service.js}

@@ -5,6 +5,17 @@ import { ServiceBase } from '@opra/core';
  * @template T - The type of the documents in the collection.
  */
 export class ElasticService extends ServiceBase {
+    /**
+     * Represents a ElasticDB database object.
+     */
+    client;
+    /**
+     * Callback function for handling errors.
+     *
+     * @param {unknown} error - The error object.
+     * @param _this - The context object.
+     */
+    onError;
     /**
      * Constructs a new instance
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/elastic",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "Opra Elastic Search adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -11,43 +11,27 @@
   },
   "peerDependencies": {
     "@elastic/elasticsearch": ">=8.7.0 <10",
-    "@opra/common": "^1.21.0",
-    "@opra/core": "^1.21.0"
+    "@opra/common": "^1.22.0",
+    "@opra/core": "^1.22.0"
   },
   "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
   "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",
+  "engines": {
+    "node": ">=20.0"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/panates/opra.git",
     "directory": "packages/elastic"
   },
-  "engines": {
-    "node": ">=16.0",
-    "npm": ">=7.0.0"
-  },
-  "files": [
-    "cjs/",
-    "esm/",
-    "types/",
-    "LICENSE",
-    "README.md"
-  ],
   "keywords": [
     "opra",
     "elastic",

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

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = prepareFilter;
-require("@opra/core");
-const common_1 = require("@opra/common");
-function prepareFilter(filters) {
-    const filtersArray = Array.isArray(filters) ? filters : [filters];
-    if (!filtersArray.length)
-        return;
-    const out = [];
-    for (const filter of filtersArray) {
-        if (!filter)
-            continue;
-        let x = filter;
-        if (typeof filter === 'string')
-            x = prepareFilterAst(common_1.OpraFilter.parse(filter));
-        else if (filter instanceof common_1.OpraFilter.Expression)
-            x = prepareFilterAst(filter);
-        out.push(x);
-    }
-    if (out.length > 1) {
-        return { bool: { must: [...out] } };
-    }
-    return out[0] ? out[0] : undefined;
-}
-function prepareFilterAst(ast, negative) {
-    if (!ast)
-        return;
-    if (ast instanceof common_1.OpraFilter.QualifiedIdentifier ||
-        ast instanceof common_1.OpraFilter.Literal) {
-        return ast.value;
-    }
-    if (ast instanceof common_1.OpraFilter.ArrayExpression) {
-        return ast.items.map(x => prepareFilterAst(x, negative));
-    }
-    if (ast instanceof common_1.OpraFilter.NegativeExpression) {
-        return prepareFilterAst(ast.expression, !negative);
-    }
-    if (ast instanceof common_1.OpraFilter.LogicalExpression) {
-        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 common_1.OpraFilter.ParenthesizedExpression) {
-        return prepareFilterAst(ast.expression, negative);
-    }
-    if (ast instanceof common_1.OpraFilter.ComparisonExpression) {
-        if (!(ast.left instanceof common_1.OpraFilter.QualifiedIdentifier ||
-            ast.left instanceof common_1.OpraFilter.StringLiteral)) {
-            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 {
-            if (ast.prepare) {
-                out = ast.prepare({
-                    left,
-                    right,
-                    op: ast.op,
-                    adapter: 'elastic',
-                });
-            }
-            if (!out) {
-                switch (ast.op) {
-                    case '!=':
-                    case '=':
-                    case 'in':
-                    case '!in': {
-                        out = Array.isArray(right)
-                            ? { terms: { [left]: right } }
-                            : { 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(`${ast.kind} is not implemented yet`);
-}

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

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = preparePatch;
-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/cjs/adapter-utils/prepare-projection.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = prepareProjection;
-exports.prepare = prepare;
-const common_1 = require("@opra/common");
-function prepareProjection(dataType, projection, scope) {
-    const out = {};
-    const includes = [];
-    const excludes = [];
-    const projection_ = typeof projection === 'string' || Array.isArray(projection)
-        ? (0, common_1.parseFieldsProjection)(projection)
-        : projection;
-    prepare(dataType, includes, excludes, '', projection_, scope);
-    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));
-}
-function prepare(dataType, includes, excludes, curPath, projection, scope) {
-    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(scope)) {
-        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 common_1.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/cjs/adapter-utils/prepare-sort.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = prepareSort;
-const SIGN_PATTERN = /^([+-])?(.+)$/;
-function prepareSort(sort) {
-    if (!(sort && sort.length))
-        return;
-    const out = [];
-    sort.forEach(k => {
-        const m = SIGN_PATTERN.exec(k);
-        if (m) {
-            out.push({ [m[2]]: { order: m[1] === '-' ? 'desc' : 'asc' } });
-        }
-    });
-    return out;
-}

package/cjs/elastic-adapter.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElasticAdapter = void 0;
-const tslib_1 = require("tslib");
-const prepare_filter_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-filter.js"));
-const prepare_patch_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-patch.js"));
-const prepare_projection_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-projection.js"));
-const prepare_sort_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-sort.js"));
-var ElasticAdapter;
-(function (ElasticAdapter) {
-    ElasticAdapter.prepareFilter = prepare_filter_js_1.default;
-    ElasticAdapter.preparePatch = prepare_patch_js_1.default;
-    ElasticAdapter.prepareProjection = prepare_projection_js_1.default;
-    ElasticAdapter.prepareSort = prepare_sort_js_1.default;
-    async function parseRequest(context) {
-        if (context.transport !== 'http') {
-            throw new TypeError('ElasticAdapter 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,
-                        count: ctx.queryParams.count,
-                        limit: ctx.queryParams.limit,
-                        skip: ctx.queryParams.skip,
-                        sort: ctx.queryParams.sort,
-                    };
-                    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 Elastic adapter`);
-    }
-    ElasticAdapter.parseRequest = parseRequest;
-})(ElasticAdapter || (exports.ElasticAdapter = ElasticAdapter = {}));