@opra/elastic 0.33.13 → 1.0.0-alpha.18

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = prepareFilter;
+/* eslint-disable camelcase */
+require("@opra/core");
+const common_1 = require("@opra/common");
+const isNil = (v) => v == null;
+function prepareFilter(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 => prepareFilter(x, negative)).filter(x => !isNil(x));
+    }
+    if (ast instanceof common_1.OpraFilter.NegativeExpression) {
+        return prepareFilter(ast.expression, !negative);
+    }
+    if (ast instanceof common_1.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);
+    }
+    if (ast instanceof common_1.OpraFilter.ParenthesizedExpression) {
+        return prepareFilter(ast.expression, negative);
+    }
+    if (ast instanceof common_1.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 common_1.OpraFilter.QualifiedIdentifier) {
+        throw new TypeError('not implemented yet');
+    }
+    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;
+    }
+    throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+}
+const wrapNot = (o, negative) => (negative ? { bool: { must_not: o } } : o);

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = prepareKeyValues;
+const tslib_1 = require("tslib");
+const putil_isplainobject_1 = tslib_1.__importDefault(require("putil-isplainobject"));
+const defaultPrimaryKey = ['_id'];
+function prepareKeyValues(keyValue, primaryKey) {
+    primaryKey = primaryKey || defaultPrimaryKey;
+    const b = (0, putil_isplainobject_1.default)(keyValue);
+    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)
+                throw new Error(`Value of key "${k}" is required`);
+            return o;
+        }, {});
+    }
+    return { [primaryKey[0]]: keyValue };
+}

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

@@ -0,0 +1,109 @@
+"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,
+// //   });
+// // }

package/cjs/{transform-sort.js → adapter-utils/prepare-sort.js}

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-function transformSort(sort) {
+exports.default = prepareSort;
+function prepareSort(sort) {
     if (!(sort && sort.length))
         return;
     const out = [];
@@ -14,4 +15,3 @@ function transformSort(sort) {
     });
     return out;
 }
-exports.default = transformSort;

package/cjs/elastic-adapter.js

@@ -2,50 +2,87 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElasticAdapter = void 0;
 const tslib_1 = require("tslib");
-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"));
+// import { SearchRequest } from '@elastic/elasticsearch/lib/api/types';
+// import { TransportRequestOptions } from '@elastic/transport';
+// import { omitNullish } from '@opra/common';
+const prepare_filter_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-filter.js"));
+const prepare_key_values_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-key-values.js"));
+// import _prepareProjection from './adapter-utils/prepare-projection.js';
+const prepare_sort_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-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 { params, endpoint } = request;
-            let options = {};
-            switch (endpoint.name) {
-                case 'findMany': {
-                    let searchRequest = {};
-                    const filter = ElasticAdapter.transformFilter(params?.filter);
-                    if (filter)
-                        searchRequest.query = filter;
-                    if (params?.limit != null)
-                        searchRequest.size = params.limit;
-                    if (params?.skip != null)
-                        searchRequest.from = params.skip;
-                    if (params?.count)
-                        searchRequest.track_total_hits = true;
-                    if (params?.pick || params?.include || params?.omit)
-                        searchRequest._source = (0, transform_projection_js_1.default)(resource.type, params);
-                    if (params?.sort)
-                        searchRequest.sort = (0, transform_sort_js_1.default)(params.sort);
-                    searchRequest = (0, common_1.omitNullish)(searchRequest);
-                    options = (0, common_1.omitNullish)(options);
-                    return {
-                        method: 'search',
-                        params: searchRequest,
-                        options,
-                        args: [searchRequest, options]
+    ElasticAdapter.prepareFilter = prepare_filter_js_1.default;
+    ElasticAdapter.prepareKeyValues = prepare_key_values_js_1.default;
+    // export const prepareProjection = _prepareProjection;
+    ElasticAdapter.prepareSort = prepare_sort_js_1.default;
+    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 TypeError(`Unimplemented request (${request.resource.kind}.${request.endpoint.name})`);
+        throw new Error(`This operation is not compatible to Elastic adapter`);
     }
-    ElasticAdapter.transformRequest = transformRequest;
+    ElasticAdapter.parseRequest = parseRequest;
 })(ElasticAdapter || (exports.ElasticAdapter = ElasticAdapter = {}));

package/cjs/elastic-service.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElasticService = void 0;
+const core_1 = require("@opra/core");
+/**
+ * Class representing a ElasticSearch service for interacting with a collection.
+ * @extends ServiceBase
+ * @template T - The type of the documents in the collection.
+ */
+class ElasticService extends core_1.ServiceBase {
+    /**
+     * Constructs a new instance
+     *
+     * @param dataType - The data type of the returning results
+     * @param indexName - The name of the index, or a function that returns the index name
+     * @param [options] - The options for the service
+     * @constructor
+     */
+    constructor(dataType, indexName, options) {
+        super();
+        this._inputCodecs = {};
+        this._outputCodecs = {};
+        this._dataType_ = dataType;
+        this.client = options?.client;
+        this.$commonFilter = this.$commonFilter || options?.commonFilter;
+        this.$interceptor = this.$interceptor || options?.interceptor;
+        this.$indexName = indexName;
+        this.$resourceName = options?.resourceName;
+        this.$idGenerator = options?.idGenerator;
+    }
+    /**
+     * Retrieves the index name.
+     *
+     * @protected
+     * @returns The index name.
+     * @throws {Error} If the index name is not defined.
+     */
+    getIndexName() {
+        const out = typeof this.$indexName === 'function' ? this.$indexName(this) : this.$indexName;
+        if (out)
+            return out;
+        throw new Error('indexName is not defined');
+    }
+    /**
+     * Retrieves the resource name.
+     *
+     * @protected
+     * @returns {string} The resource name.
+     * @throws {Error} If the resource name is not defined.
+     */
+    getResourceName() {
+        const out = typeof this.$resourceName === 'function' ? this.$resourceName(this) : this.$resourceName || this.getIndexName();
+        if (out)
+            return out;
+        throw new Error('resourceName is not defined');
+    }
+    /**
+     * Retrieves the OPRA data type
+     *
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataType() {
+        if (!this._dataType)
+            this._dataType = this.context.document.node.getComplexType(this._dataType_);
+        return this._dataType;
+    }
+    /**
+     * Retrieves the codec for the specified operation.
+     *
+     * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
+     */
+    getInputCodec(operation) {
+        let validator = this._inputCodecs[operation];
+        if (validator)
+            return validator;
+        const options = { projection: '*' };
+        if (operation === 'update')
+            options.partial = 'deep';
+        const dataType = this.dataType;
+        validator = dataType.generateCodec('decode', options);
+        this._inputCodecs[operation] = validator;
+        return validator;
+    }
+    /**
+     * Retrieves the codec.
+     */
+    getOutputCodec(operation) {
+        let validator = this._outputCodecs[operation];
+        if (validator)
+            return validator;
+        const options = { projection: '*', partial: 'deep' };
+        const dataType = this.dataType;
+        validator = dataType.generateCodec('decode', options);
+        this._outputCodecs[operation] = validator;
+        return validator;
+    }
+    /**
+     * Retrieves the ElasticSearch client.
+     *
+     * @protected
+     *
+     * @throws {Error} If the context or client is not set.
+     */
+    getClient() {
+        // @ts-ignore
+        const db = typeof this.client === 'function' ? this.client(this) : this.client;
+        if (!db)
+            throw new Error(`Client not set!`);
+        return db;
+    }
+    /**
+     * Generates an ID.
+     *
+     * @protected
+     * @returns The generated ID.
+     */
+    _generateId() {
+        return typeof this.$idGenerator === 'function' ? this.$idGenerator(this) : undefined;
+    }
+    /**
+     * Retrieves the common filter used for querying documents.
+     * This method is mostly used for security issues like securing multi-tenant applications.
+     *
+     * @protected
+     * @returns {QueryDslQueryContainer | Promise<QueryDslQueryContainer> | undefined} The common filter or a Promise
+     * that resolves to the common filter, or undefined if not available.
+     */
+    _getCommonFilter(info) {
+        return typeof this.$commonFilter === 'function' ? this.$commonFilter(info, this) : this.$commonFilter;
+    }
+    async _intercept(callback, info) {
+        try {
+            if (this.$interceptor)
+                return this.$interceptor(callback, info, this);
+            return callback();
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this._intercept);
+            await this.$onError?.(e, this);
+            throw e;
+        }
+    }
+}
+exports.ElasticService = ElasticService;

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

@@ -0,0 +1,102 @@
+/* eslint-disable camelcase */
+import '@opra/core';
+import { OpraFilter } from '@opra/common';
+const isNil = (v) => v == null;
+export default function prepareFilter(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 => prepareFilter(x, negative)).filter(x => !isNil(x));
+    }
+    if (ast instanceof OpraFilter.NegativeExpression) {
+        return prepareFilter(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);
+    }
+    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');
+    }
+    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;
+    }
+    throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+}
+const wrapNot = (o, negative) => (negative ? { bool: { must_not: o } } : o);

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

@@ -0,0 +1,18 @@
+import isPlainObject from 'putil-isplainobject';
+const defaultPrimaryKey = ['_id'];
+export default function prepareKeyValues(keyValue, primaryKey) {
+    primaryKey = primaryKey || defaultPrimaryKey;
+    const b = isPlainObject(keyValue);
+    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)
+                throw new Error(`Value of key "${k}" is required`);
+            return o;
+        }, {});
+    }
+    return { [primaryKey[0]]: keyValue };
+}