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

package/esm/elastic-entity-service.js

@@ -0,0 +1,388 @@
+import { DATATYPE_METADATA, InternalServerError } from '@opra/common';
+import { isNotNullish } from 'valgen';
+import { ElasticAdapter } from './elastic-adapter.js';
+import { ElasticService } from './elastic-service.js';
+/**
+ * @class ElasticEntityService
+ * @template T - The type of the documents in the collection.
+ */
+export class ElasticEntityService extends 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(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;
+        isNotNullish(input, { label: 'input' });
+        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 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 = 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) {
+        isNotNullish(command.documentId, { label: 'documentId' });
+        const { options } = command;
+        const filterQuery = 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 = 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 = 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 ? ElasticAdapter.prepareSort(options?.sort) : undefined,
+            _source: 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)
+            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;
+        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 = 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 = 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
+    }
+}

package/esm/elastic-service.js

@@ -8,88 +8,14 @@ export class ElasticService extends 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.
@@ -105,35 +31,26 @@ export class ElasticService extends 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/esm/index.js

@@ -1 +1,4 @@
 export * from './elastic-adapter.js';
+export * from './elastic-collection-service.js';
+export * from './elastic-entity-service.js';
+export * from './elastic-service.js';

package/esm/package.json

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

package/package.json

@@ -1,56 +1,48 @@
 {
   "name": "@opra/elastic",
-  "version": "1.0.0-alpha.32",
+  "version": "1.0.0-beta.2",
   "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",
-    "lint:fix": "eslint . --max-warnings=0 --fix",
-    "format": "prettier . --write --log-level=warn",
-    "test": "jest --passWithNoTests",
-    "cover": "jest --passWithNoTests --collect-coverage",
-    "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
-    "clean:src": "ts-cleanup -s src --all",
-    "clean:test": "ts-cleanup -s test --all",
-    "clean:dist": "rimraf ../../build/client",
-    "clean:cover": "rimraf ../../coverage/client"
-  },
   "dependencies": {
+    "lodash.omit": "^4.5.0",
     "putil-isplainobject": "^1.1.5",
-    "tslib": "^2.6.3"
-  },
-  "devDependencies": {
-    "@elastic/elasticsearch": "^8.14.0",
-    "@faker-js/faker": "^8.4.1",
-    "ts-gems": "^3.4.0"
+    "tslib": "^2.7.0",
+    "valgen": "^5.9.0"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": ">=8.7.0",
-    "@opra/common": "^1.0.0-alpha.32",
-    "@opra/core": "^1.0.0-alpha.32"
+    "@opra/common": "^1.0.0-beta.2",
+    "@opra/core": "^1.0.0-beta.2"
   },
   "type": "module",
-  "module": "./esm/index.js",
+  "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"
+    },
+    "./package.json": "./package.json"
+  },
   "main": "./cjs/index.js",
+  "module": "./esm/index.js",
   "types": "./types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/elastic"
+  },
   "engines": {
     "node": ">=16.0",
     "npm": ">=7.0.0"
   },
   "files": [
-    "bin/",
     "cjs/",
     "esm/",
     "types/",
@@ -63,4 +55,4 @@
     "elasticsearch",
     "adapter"
   ]
-}
+}

package/types/adapter-utils/prepare-filter.d.ts

@@ -1,3 +1,4 @@
 import '@opra/core';
-import { OpraFilter } from '@opra/common';
-export default function prepareFilter(ast: OpraFilter.Expression | undefined, negative?: boolean): any;
+import type { QueryDslQueryContainer } from '@elastic/elasticsearch/lib/api/types';
+import { type ElasticAdapter } from '../elastic-adapter.js';
+export default function prepareFilter(filters: ElasticAdapter.FilterInput | ElasticAdapter.FilterInput[]): QueryDslQueryContainer | undefined;

package/types/adapter-utils/prepare-patch.d.ts

@@ -0,0 +1,2 @@
+import { Script } from '@elastic/elasticsearch/lib/api/types.js';
+export default function preparePatch(doc: any): Script;

package/types/adapter-utils/prepare-projection.d.ts

@@ -0,0 +1,7 @@
+import { ComplexType, FieldsProjection } from '@opra/common';
+export interface ElasticProjection {
+    includes?: string[];
+    excludes?: string[];
+}
+export default function prepareProjection(dataType: ComplexType, projection?: string | string[]): ElasticProjection | undefined;
+export declare function prepare(dataType: ComplexType, includes: string[], excludes: string[], curPath: string, projection?: FieldsProjection): void;

package/types/elastic-adapter.d.ts

@@ -1,10 +1,15 @@
+import type { QueryDslQueryContainer } from '@elastic/elasticsearch/lib/api/types.js';
+import { OpraFilter } from '@opra/common';
 import { HttpContext } from '@opra/core';
 import _prepareFilter from './adapter-utils/prepare-filter.js';
-import _prepareKeyValues from './adapter-utils/prepare-key-values.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 declare namespace ElasticAdapter {
+    type FilterInput = OpraFilter.Expression | QueryDslQueryContainer | string | undefined;
     const prepareFilter: typeof _prepareFilter;
-    const prepareKeyValues: typeof _prepareKeyValues;
+    const preparePatch: typeof _preparePatch;
+    const prepareProjection: typeof _prepareProjection;
     const prepareSort: typeof _prepareSort;
     interface TransformedRequest {
         method: 'create' | 'delete' | 'deleteMany' | 'get' | 'findMany' | 'update' | 'updateMany';