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

package/cjs/elastic-entity-service.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElasticEntityService = void 0;
+const common_1 = require("@opra/common");
+const valgen_1 = require("valgen");
+const elastic_adapter_js_1 = require("./elastic-adapter.js");
+const elastic_service_js_1 = require("./elastic-service.js");
+/**
+ * @class ElasticEntityService
+ * @template T - The type of the documents in the collection.
+ */
+class ElasticEntityService extends elastic_service_js_1.ElasticService {
+    /**
+     * Constructs a new instance
+     *
+     * @param {Type | string} dataType - The data type of the array elements.
+     * @param {ElasticEntityService.Options} [options] - The options for the array service.
+     * @constructor
+     */
+    constructor(dataType, options) {
+        super(options);
+        this._inputCodecs = {};
+        this._outputCodecs = {};
+        this._dataType_ = dataType;
+        if (options?.indexName)
+            this.indexName = options?.indexName;
+        else {
+            if (typeof dataType === 'string')
+                this.indexName = dataType;
+            if (typeof dataType === 'function') {
+                const metadata = Reflect.getMetadata(common_1.DATATYPE_METADATA, dataType);
+                if (metadata)
+                    this.indexName = metadata.name;
+            }
+        }
+        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;
+    }
+    /**
+     * Adds a JSON document to the specified data stream or index and makes it searchable.
+     * If the target is an index and the document already exists,
+     * the request updates the document and increments its version.
+     *
+     * @param {ElasticEntityService.CreateCommand} command
+     * @protected
+     */
+    async _create(command) {
+        const input = command.input;
+        (0, valgen_1.isNotNullish)(input, { label: 'input' });
+        (0, valgen_1.isNotNullish)(input._id, { label: 'input._id' });
+        const inputCodec = this._getInputCodec('create');
+        const doc = inputCodec(input);
+        const { options } = command;
+        const request = {
+            ...options?.request,
+            index: this.getIndexName(),
+            id: input._id,
+            document: doc,
+        };
+        const client = this.getClient();
+        const r = await client.create(request, options?.transport);
+        /* istanbul ignore next */
+        if (!(r._id && (r.result === 'created' || r.result === 'updated'))) {
+            throw new common_1.InternalServerError(`Unknown error while creating document for "${this.getResourceName()}"`);
+        }
+        return r;
+    }
+    /**
+     * Returns the count of documents in the collection based on the provided options.
+     *
+     * @param {ElasticEntityService.CountCommand} command
+     * @protected
+     */
+    async _count(command) {
+        const { options } = command;
+        const filterQuery = elastic_adapter_js_1.ElasticAdapter.prepareFilter([options?.filter, options?.request?.query]);
+        let query = {
+            ...options?.request?.query,
+            ...filterQuery,
+        };
+        if (!Object.keys(query).length)
+            query = undefined;
+        const request = {
+            index: this.getIndexName(),
+            ...options?.request,
+            query,
+        };
+        const client = this.getClient();
+        return client.count(request, options?.transport);
+    }
+    /**
+     * Deletes a document from the collection.
+     *
+     * @param {ElasticEntityService.DeleteCommand} command
+     * @protected
+     */
+    async _delete(command) {
+        (0, valgen_1.isNotNullish)(command.documentId, { label: 'documentId' });
+        const { options } = command;
+        const filterQuery = elastic_adapter_js_1.ElasticAdapter.prepareFilter([
+            { ids: { values: [command.documentId] } },
+            options?.filter,
+            options?.request?.query,
+        ]);
+        let query = {
+            ...options?.request?.query,
+            ...filterQuery,
+        };
+        if (!Object.keys(query).length)
+            query = { match_all: {} };
+        const request = {
+            index: this.getIndexName(),
+            ...options?.request,
+            query,
+        };
+        const client = this.getClient();
+        return client.deleteByQuery(request, options?.transport);
+    }
+    /**
+     * Deletes multiple documents from the collection that meet the specified filter criteria.
+     *
+     * @param {ElasticEntityService.DeleteManyCommand} command
+     * @protected
+     */
+    async _deleteMany(command) {
+        const { options } = command;
+        const filterQuery = elastic_adapter_js_1.ElasticAdapter.prepareFilter([options?.filter, options?.request?.query]);
+        let query = {
+            ...options?.request?.query,
+            ...filterQuery,
+        };
+        if (!Object.keys(query).length)
+            query = { match_all: {} };
+        const request = {
+            ...options?.request,
+            index: this.getIndexName(),
+            query,
+        };
+        const client = this.getClient();
+        return client.deleteByQuery(request, options?.transport);
+    }
+    /**
+     * Returns search hits that match the query defined in the request
+     *
+     * @param {ElasticEntityService.SearchCommand} command
+     */
+    async _search(command) {
+        const { options } = command;
+        const filterQuery = elastic_adapter_js_1.ElasticAdapter.prepareFilter([
+            command.documentId ? { ids: { values: [command.documentId] } } : undefined,
+            options?.filter,
+            options?.request?.query,
+        ]);
+        let query = {
+            ...options?.request?.query,
+            ...filterQuery,
+        };
+        if (!Object.keys(query).length)
+            query = { match_all: {} };
+        const request = {
+            from: options?.skip,
+            size: options?.limit,
+            sort: options?.sort ? elastic_adapter_js_1.ElasticAdapter.prepareSort(options?.sort) : undefined,
+            _source: elastic_adapter_js_1.ElasticAdapter.prepareProjection(this.dataType, options?.projection),
+            index: this.getIndexName(),
+            ...options?.request,
+            query,
+        };
+        const client = this.getClient();
+        return client.search(request, options?.transport);
+    }
+    /**
+     * Updates multiple documents in the collection based on the specified input and options.
+     *
+     * @param {ElasticEntityService.UpdateCommand<T>} command
+     */
+    async _updateMany(command) {
+        if (command.byId)
+            (0, valgen_1.isNotNullish)(command.documentId, { label: 'documentId' });
+        const { options } = command;
+        const input = command.input;
+        const requestScript = command.options?.request?.script;
+        let script;
+        const inputKeysLen = Object.keys(input).length;
+        (0, valgen_1.isNotNullish)(inputKeysLen || script, { label: 'input' });
+        if (requestScript) {
+            script = typeof requestScript === 'string' ? { source: requestScript } : { ...requestScript };
+            script.lang = script.lang || 'painless';
+            if (inputKeysLen > 0 && script.lang !== 'painless') {
+                throw new TypeError(`You cannot provide 'input' and 'script' arguments at the same time unless the script lang is 'painless'`);
+            }
+        }
+        if (inputKeysLen) {
+            delete input._id;
+            const inputCodec = this._getInputCodec('update');
+            const doc = inputCodec(input);
+            const scr = elastic_adapter_js_1.ElasticAdapter.preparePatch(doc);
+            if (script) {
+                script.source = (script.source ? script.source + '\n' + script.source : '') + scr.source;
+                script.params = { ...script.params, ...scr.params };
+            }
+            else
+                script = scr;
+        }
+        script.source = script?.source || 'return;';
+        const filterQuery = elastic_adapter_js_1.ElasticAdapter.prepareFilter([
+            command.byId ? { ids: { values: [command.documentId] } } : undefined,
+            options?.filter,
+            options?.request?.query,
+        ]);
+        let query = {
+            ...options?.request?.query,
+            ...filterQuery,
+        };
+        if (!Object.keys(query).length)
+            query = { match_all: {} };
+        const request = {
+            ...options?.request,
+            index: this.getIndexName(),
+            script,
+            query,
+        };
+        const client = this.getClient();
+        return client.updateByQuery(request, options?.transport);
+    }
+    /**
+     * Generates an ID.
+     *
+     * @protected
+     * @returns The generated ID.
+     */
+    _generateId(command) {
+        return typeof this.idGenerator === 'function' ? this.idGenerator(command, this) : undefined;
+    }
+    /**
+     * 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;
+    }
+    async _executeCommand(command, commandFn) {
+        try {
+            const result = await super._executeCommand(command, async () => {
+                /** Call before[X] hooks */
+                if (command.crud === 'create')
+                    await this._beforeCreate(command);
+                else if (command.crud === 'update' && command.byId) {
+                    await this._beforeUpdate(command);
+                }
+                else if (command.crud === 'update' && !command.byId) {
+                    await this._beforeUpdateMany(command);
+                }
+                else if (command.crud === 'delete' && command.byId) {
+                    await this._beforeDelete(command);
+                }
+                else if (command.crud === 'delete' && !command.byId) {
+                    await this._beforeDeleteMany(command);
+                }
+                /** Call command function */
+                return commandFn();
+            });
+            /** Call after[X] hooks */
+            if (command.crud === 'create')
+                await this._afterCreate(command, result);
+            else if (command.crud === 'update' && command.byId) {
+                await this._afterUpdate(command, result);
+            }
+            else if (command.crud === 'update' && !command.byId) {
+                await this._afterUpdateMany(command, result);
+            }
+            else if (command.crud === 'delete' && command.byId) {
+                await this._afterDelete(command, result);
+            }
+            else if (command.crud === 'delete' && !command.byId) {
+                await this._afterDeleteMany(command, result);
+            }
+            return result;
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this._executeCommand);
+            await this.onError?.(e, this);
+            throw e;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeCreate(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeUpdate(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeUpdateMany(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeDelete(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeDeleteMany(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterCreate(command, result) {
+        // Do nothing
+    }
+    async _afterUpdate(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    command, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    result) {
+        // Do nothing
+    }
+    async _afterUpdateMany(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    command, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    affected) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterDelete(command, affected) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterDeleteMany(command, affected) {
+        // Do nothing
+    }
+}
+exports.ElasticEntityService = ElasticEntityService;

package/cjs/elastic-service.js

@@ -11,88 +11,14 @@ 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) {
+    constructor(options) {
         super();
-        this._inputCodecs = {};
-        this._outputCodecs = {};
-        this._dataType_ = dataType;
+        this.interceptor = options?.interceptor;
         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;
+        this.onError = options?.onError;
     }
     /**
      * Retrieves the ElasticSearch client.
@@ -108,35 +34,26 @@ class ElasticService extends core_1.ServiceBase {
             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) {
+    async _executeCommand(command, commandFn) {
+        let proto;
+        const next = async () => {
+            proto = proto ? Object.getPrototypeOf(proto) : this;
+            while (proto) {
+                if (proto.interceptor && Object.prototype.hasOwnProperty.call(proto, 'interceptor')) {
+                    return await proto.interceptor.call(this, next, command, this);
+                }
+                proto = Object.getPrototypeOf(proto);
+                if (!(proto instanceof ElasticService))
+                    break;
+            }
+            return commandFn();
+        };
         try {
-            if (this.$interceptor)
-                return this.$interceptor(callback, info, this);
-            return callback();
+            return await next();
         }
         catch (e) {
-            Error.captureStackTrace(e, this._intercept);
-            await this.$onError?.(e, this);
+            Error.captureStackTrace(e, this._executeCommand);
+            await this.onError?.(e, this);
             throw e;
         }
     }

package/cjs/index.js

@@ -2,3 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./elastic-adapter.js"), exports);
+tslib_1.__exportStar(require("./elastic-collection-service.js"), exports);
+tslib_1.__exportStar(require("./elastic-entity-service.js"), exports);
+tslib_1.__exportStar(require("./elastic-service.js"), exports);