@opra/elastic 1.26.3 → 1.26.4

package/README.md

@@ -1,3 +1,26 @@
-# @opra/mongodb
+# @opra/elastic
 
-OPRA MongoDB package.
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![CI Tests][ci-test-image]][ci-test-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+
+## Support
+You can report bugs and discuss features on the [GitHub issues](https://github.com/panates/opra/issues) page.
+
+## Node Compatibility
+- node >= 20.x
+
+
+## License
+Available under [MIT](LICENSE) license.
+
+[npm-image]: https://img.shields.io/npm/v/@opra/elastic
+[npm-url]: https://npmjs.org/package/@opra/elastic
+[downloads-image]: https://img.shields.io/npm/dm/@opra/elastic.svg
+[downloads-url]: https://npmjs.org/package/@opra/elastic
+[ci-test-image]: https://github.com/panates/opra/actions/workflows/test.yml/badge.svg
+[ci-test-url]: https://github.com/panates/opra/actions/workflows/test.yml
+[coveralls-image]: https://coveralls.io/repos/github/panates/opra/badge.svg?branch=main
+[coveralls-url]: https://coveralls.io/github/panates/opra?branch=main

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

@@ -1,4 +1,10 @@
 import '@opra/core';
 import type { estypes } from '@elastic/elasticsearch';
 import { type ElasticAdapter } from '../elastic-adapter.js';
+/**
+ * Prepares an Elasticsearch filter query from the provided input.
+ *
+ * @param filters - The filter input or an array of filter inputs to prepare.
+ * @returns The prepared Elasticsearch query container, or undefined if no filters are provided.
+ */
 export default function prepareFilter(filters: ElasticAdapter.FilterInput | ElasticAdapter.FilterInput[]): estypes.QueryDslQueryContainer | undefined;

package/adapter-utils/prepare-filter.js

@@ -1,5 +1,11 @@
 import '@opra/core';
 import { OpraFilter } from '@opra/common';
+/**
+ * Prepares an Elasticsearch filter query from the provided input.
+ *
+ * @param filters - The filter input or an array of filter inputs to prepare.
+ * @returns The prepared Elasticsearch query container, or undefined if no filters are provided.
+ */
 export default function prepareFilter(filters) {
     const filtersArray = Array.isArray(filters) ? filters : [filters];
     if (!filtersArray.length)
@@ -36,7 +42,7 @@ function prepareFilterAst(ast, negative) {
     if (ast instanceof OpraFilter.LogicalExpression) {
         const items = ast.items
             .map(x => prepareFilterAst(x))
-            /** Filter nullish items */
+            /* Filter nullish items */
             .filter(x => x != null);
         const k = (ast.op === 'or' ? 'should' : 'must') + (negative ? '_not' : '');
         return { bool: { [k]: items } };

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

@@ -1,2 +1,8 @@
 import type { Script } from '@elastic/elasticsearch/api/types';
+/**
+ * Prepares an Elasticsearch script for a patch operation from the provided document.
+ *
+ * @param doc - The document containing the changes to prepare as a script.
+ * @returns An Elasticsearch script object.
+ */
 export default function preparePatch(doc: any): Script;

package/adapter-utils/prepare-patch.js

@@ -1,3 +1,9 @@
+/**
+ * Prepares an Elasticsearch script for a patch operation from the provided document.
+ *
+ * @param doc - The document containing the changes to prepare as a script.
+ * @returns An Elasticsearch script object.
+ */
 export default function preparePatch(doc) {
     const script = [];
     const params = {};
@@ -21,7 +27,7 @@ function _preparePatch(src, script, params, path) {
         if (v &&
             typeof v === 'object' &&
             !Array.isArray(v) &&
-            /** If field name starts with "*", do "replace" operation except "merge" */
+            /* If field name starts with "*", do "replace" operation except "merge" */
             !k.startsWith('*')) {
             _preparePatch(v, script, params, field);
             continue;

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

@@ -3,5 +3,13 @@ export interface ElasticProjection {
     includes?: string[];
     excludes?: string[];
 }
+/**
+ * Prepares an Elasticsearch projection object from the provided fields projection.
+ *
+ * @param dataType - The complex type defining the structure of the data.
+ * @param projection - The fields projection to transform.
+ * @param scope - The scope to use for field selection.
+ * @returns An `ElasticProjection` object containing include and exclude rules, or undefined.
+ */
 export default function prepareProjection(dataType: ComplexType, projection?: string | string[], scope?: string): ElasticProjection | undefined;
 export declare function prepare(dataType: ComplexType, includes: string[], excludes: string[], curPath: string, projection?: FieldsProjection, scope?: string): void;

package/adapter-utils/prepare-projection.js

@@ -1,4 +1,12 @@
 import { ComplexType, parseFieldsProjection, } from '@opra/common';
+/**
+ * Prepares an Elasticsearch projection object from the provided fields projection.
+ *
+ * @param dataType - The complex type defining the structure of the data.
+ * @param projection - The fields projection to transform.
+ * @param scope - The scope to use for field selection.
+ * @returns An `ElasticProjection` object containing include and exclude rules, or undefined.
+ */
 export default function prepareProjection(dataType, projection, scope) {
     const out = {};
     const includes = [];
@@ -24,7 +32,7 @@ export function prepare(dataType, includes, excludes, curPath, projection, scope
     let fieldPath;
     let field;
     let k;
-    /** Add fields from data type */
+    /* Add fields from data type */
     for (field of dataType.fields(scope)) {
         fieldName = field.name;
         fieldPath = curPath + (curPath ? '.' : '') + fieldName;
@@ -32,9 +40,9 @@ export function prepare(dataType, includes, excludes, curPath, projection, scope
         projectionKeysSet.delete(k);
         const p = projection?.[k];
         if (
-        /** if field is omitted */
+        /* if field is omitted */
         p?.sign === '-' ||
-            /** if no projection defined for this field and includeDefaultFields is true and the field is exclusive */
+            /* if no projection defined for this field and includeDefaultFields is true and the field is exclusive */
             (!p && field.exclusive)) {
             if (!needIncludes)
                 excludes.push(fieldPath);

package/adapter-utils/prepare-sort.d.ts

@@ -1 +1,7 @@
+/**
+ * Prepares an Elasticsearch sort array from the provided sort strings.
+ *
+ * @param sort - An array of sort strings (e.g., '+field' or '-field').
+ * @returns An array of Elasticsearch sort objects, or undefined if no sort is provided.
+ */
 export default function prepareSort(sort?: string[]): any[] | undefined;

package/adapter-utils/prepare-sort.js

@@ -1,4 +1,10 @@
 const SIGN_PATTERN = /^([+-])?(.+)$/;
+/**
+ * Prepares an Elasticsearch sort array from the provided sort strings.
+ *
+ * @param sort - An array of sort strings (e.g., '+field' or '-field').
+ * @returns An array of Elasticsearch sort objects, or undefined if no sort is provided.
+ */
 export default function prepareSort(sort) {
     if (!(sort && sort.length))
         return;

package/elastic-adapter.d.ts

@@ -17,5 +17,13 @@ export declare namespace ElasticAdapter {
         data?: any;
         options: any;
     }
+    /**
+     * Parses the execution context and transforms it into an `ElasticAdapter.TransformedRequest`.
+     *
+     * @param context - The execution context to parse.
+     * @returns A promise that resolves to the transformed request.
+     * @throws {@link TypeError} if the context is not an `HttpContext`.
+     * @throws {@link Error} if the operation is not compatible with the Elastic adapter.
+     */
     function parseRequest(context: ExecutionContext): Promise<TransformedRequest>;
 }

package/elastic-adapter.js

@@ -8,6 +8,14 @@ export var ElasticAdapter;
     ElasticAdapter.preparePatch = _preparePatch;
     ElasticAdapter.prepareProjection = _prepareProjection;
     ElasticAdapter.prepareSort = _prepareSort;
+    /**
+     * Parses the execution context and transforms it into an `ElasticAdapter.TransformedRequest`.
+     *
+     * @param context - The execution context to parse.
+     * @returns A promise that resolves to the transformed request.
+     * @throws {@link TypeError} if the context is not an `HttpContext`.
+     * @throws {@link Error} if the operation is not compatible with the Elastic adapter.
+     */
     async function parseRequest(context) {
         if (context.transport !== 'http') {
             throw new TypeError('ElasticAdapter can parse only HttpContext');

package/elastic-collection-service.d.ts

@@ -27,192 +27,182 @@ export declare namespace ElasticCollectionService {
     }
 }
 /**
- * @class ElasticCollectionService
+ * Class representing an Elasticsearch collection service for interacting with an Elasticsearch index.
+ *
  * @template T - The type of the documents in the collection.
  */
 export declare class ElasticCollectionService<T extends object = any> extends ElasticEntityService<T> {
     /**
-     * Represents a common filter function for a ElasticService.
-     *
-     * @type {FilterInput | Function}
+     * Represents a common filter for the service.
      */
     documentFilter?: ElasticCollectionService.DocumentFilter | ElasticCollectionService.DocumentFilter[];
     /**
-     * Represents the default limit value for a certain operation.
-     *
-     * @type {number}
+     * Represents the default limit value for find operations.
      */
     defaultLimit: number;
     /**
-     * Constructs a new instance
+     * Constructs a new instance.
      *
-     * @param {Type | string} dataType - The data type of the array elements.
-     * @param {ElasticCollectionService.Options} [options] - The options for the array service.
-     * @constructor
+     * @param dataType - The data type of the documents.
+     * @param options - The options for the collection service.
      */
     constructor(dataType: Type | string, options?: ElasticCollectionService.Options);
     for<C extends ExecutionContext, P extends Partial<this>>(context: C | ServiceBase, overwriteProperties?: Nullish<P>, overwriteContext?: Partial<C>): this & Required<P>;
     /**
      * Asserts the existence of a resource with the given ID.
-     * Throws a ResourceNotFoundError if the resource does not exist.
      *
-     * @param {string} id - The ID of the resource to assert.
-     * @param {ElasticEntityService.FindOneOptions} [options] - Optional options for checking the existence.
-     * @returns {Promise<void>} - A Promise that resolves when the resource exists.
-     * @throws {ResourceNotAvailableError} - If the resource does not exist.
+     * @param id - The ID of the resource to assert.
+     * @param options - Optional options for checking the existence.
+     * @returns A promise that resolves when the resource exists.
+     * @throws {@link ResourceNotAvailableError} if the resource does not exist.
      */
     assert(id: string, options?: ElasticEntityService.FindOneOptions): Promise<void>;
     /**
-     * Adds a document to the specified index
+     * Adds a document to the specified index.
      *
-     * @param {PartialDTO<T>} input - The input data for creating the document.
-     * @param {ElasticEntityService.CreateOptions} [options] - The options for creating the document.
-     * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created document.
-     * @throws {Error} if an unknown error occurs while creating the document.
+     * @param input - The input data for creating the document.
+     * @param options - The options for creating the document.
+     * @returns A promise that resolves to the created response.
+     * @throws {@link Error} if an unknown error occurs while creating the document.
      */
     create(input: PartialDTO<T>, options?: ElasticEntityService.CreateOptions): Promise<estypes.CreateResponse>;
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
-     * @param {ElasticEntityService.CountOptions<T>} options - The options for the count operation.
-     * @return {Promise<number>} - A promise that resolves to the count of documents in the collection.
+     * @param options - The options for the count operation.
+     * @returns A promise that resolves to the count of documents.
      */
     count(options?: ElasticEntityService.CountOptions): Promise<number>;
     /**
-     * Deletes a document from the collection.
+     * Deletes a document from the collection by its ID.
      *
-     * @param {string} id - The ID of the document to delete.
-     * @param {ElasticEntityService.DeleteOptions} [options] - Optional delete options.
-     * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
+     * @param id - The ID of the document to delete.
+     * @param options - Optional delete options.
+     * @returns A promise that resolves to the delete response.
      */
     delete(id: string, options?: ElasticEntityService.DeleteOptions): Promise<estypes.DeleteByQueryResponse>;
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {ElasticEntityService.DeleteManyOptions} options - The options for the delete operation.
-     * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
+     * @param options - The options for the delete operation.
+     * @returns A promise that resolves to the delete response.
      */
     deleteMany(options?: ElasticEntityService.DeleteManyOptions): Promise<estypes.DeleteByQueryResponse>;
     /**
-     * Checks if an object with the given id exists.
+     * Checks if an object with the given ID exists.
      *
-     * @param {string} id - The id of the object to check.
-     * @param {ElasticEntityService.FindOneOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
+     * @param id - The ID of the object to check.
+     * @param options - The options for the query.
+     * @returns A promise that resolves to a boolean indicating whether the object exists.
      */
     exists(id: string, options?: ElasticEntityService.FindOneOptions): Promise<boolean>;
     /**
-     * Checks if an object with the given arguments exists.
+     * Checks if at least one document exists matching the specified criteria.
      *
-     * @param {ElasticEntityService.FindOneOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
+     * @param options - The options for the query.
+     * @returns A promise that resolves to a boolean indicating whether the object exists.
      */
     existsOne(options?: ElasticEntityService.FindOneOptions): Promise<boolean>;
     /**
      * Finds a document by its ID.
      *
-     * @param {string} id - The ID of the document.
-     * @param {ElasticEntityService.FindOneOptions} [options] - The options for the find query.
-     * @return {Promise<PartialDTO<T | undefined>>} - A promise resolving to the found document, or undefined if not found.
+     * @param id - The ID of the document.
+     * @param options - The options for the find operation.
+     * @returns A promise resolving to the found document, or undefined if not found.
      */
     findById(id: string, options: RequiredSome<ElasticEntityService.FindOneOptions, 'projection'>): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds a document by its ID.
      *
-     * @param {string} id - The ID of the document.
-     * @param {ElasticEntityService.FindOneOptions} [options] - The options for the find query.
-     * @return {Promise<T | undefined>} - A promise resolving to the found document, or undefined if not found.
+     * @param id - The ID of the document.
+     * @param options - The options for the find operation.
+     * @returns A promise resolving to the found document, or undefined if not found.
      */
     findById(id: string, options?: ElasticEntityService.FindOneOptions): Promise<T | undefined>;
     /**
-     * Finds a document in the collection that matches the specified options.
+     * Finds a document in the collection that matches the specified criteria.
      *
-     * @param {ElasticEntityService.FindOneOptions} [options] - The options for the query.
-     * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
+     * @param options - The options for the find operation.
+     * @returns A promise that resolves with the found document or undefined if no document is found.
      */
     findOne(options: RequiredSome<ElasticEntityService.FindOneOptions, 'projection'>): Promise<PartialDTO<T> | undefined>;
     /**
-     * Finds a document in the collection that matches the specified options.
+     * Finds a document in the collection that matches the specified criteria.
      *
-     * @param {ElasticEntityService.FindOneOptions} [options] - The options for the query.
-     * @return {Promise<T | undefined>} A promise that resolves with the found document or undefined if no document is found.
+     * @param options - The options for the find operation.
+     * @returns A promise that resolves with the found document or undefined if no document is found.
      */
     findOne(options?: ElasticEntityService.FindOneOptions): Promise<T | undefined>;
     /**
-     * Finds multiple documents in the ElasticDB collection.
+     * Finds multiple documents in the Elasticsearch collection.
      *
-     * @param {ElasticEntityService.FindManyOptions} options - The options for the find operation.
-     * @return {Promise<PartialDTO<T> | undefined>} A Promise that resolves to an array of partial outputs of type T.
+     * @param options - The options for the find operation.
+     * @returns A promise that resolves to an array of partial documents.
      */
     findMany(options: RequiredSome<ElasticEntityService.FindManyOptions, 'projection'>): Promise<PartialDTO<T>[]>;
     /**
-     * Finds multiple documents in the ElasticDB collection.
+     * Finds multiple documents in the Elasticsearch collection.
      *
-     * @param {ElasticEntityService.FindManyOptions} options - The options for the find operation.
-     * @return {Promise<T | undefined>} A Promise that resolves to an array of partial outputs of type T.
+     * @param options - The options for the find operation.
+     * @returns A promise that resolves to an array of documents.
      */
     findMany(options?: ElasticEntityService.FindManyOptions): Promise<T[]>;
     searchRaw(request: estypes.SearchRequest, options?: ElasticEntityService.SearchOptions): Promise<estypes.SearchResponse<PartialDTO<T>>>;
     /**
-     * Finds multiple documents in the collection and returns both records (max limit)
-     * and total count that matched the given criteria
+     * Finds multiple documents and returns both records and total count.
      *
-     * @param {ElasticEntityService.FindManyOptions} [options] - The options for the find operation.
-     * @return {ElasticCollectionService.FindManyWithCountResult<PartialDTO<T>>} A Promise that resolves to an array of partial outputs of type T.
+     * @param options - The options for the find operation.
+     * @returns A promise that resolves to an object containing items and count.
      */
     findManyWithCount(options: RequiredSome<ElasticEntityService.FindManyOptions, 'projection'>): Promise<ElasticCollectionService.FindManyWithCountResult<PartialDTO<T>>>;
     /**
-     * Finds multiple documents in the collection and returns both records (max limit)
-     * and total count that matched the given criteria
+     * Finds multiple documents and returns both records and total count.
      *
-     * @param {ElasticEntityService.FindManyOptions} [options] - The options for the find operation.
-     * @return {ElasticCollectionService.FindManyWithCountResult<T>} A Promise that resolves to an array of partial outputs of type T.
+     * @param options - The options for the find operation.
+     * @returns A promise that resolves to an object containing items and count.
      */
     findManyWithCount(options?: ElasticEntityService.FindManyOptions): Promise<ElasticCollectionService.FindManyWithCountResult<T>>;
     /**
      * Retrieves a document from the collection by its ID. Throws error if not found.
      *
-     * @param {string} id - The ID of the document to retrieve.
-     * @param {ElasticEntityService.FindOneOptions<T>} [options] - Optional options for the findOne operation.
-     * @returns {Promise<PartialDTO<T>>} - A promise that resolves to the retrieved document,
-     *    or rejects with a ResourceNotFoundError if the document does not exist.
-     * @throws {ResourceNotAvailableError} - If the document with the specified ID does not exist.
+     * @param id - The ID of the document to retrieve.
+     * @param options - Optional options for the operation.
+     * @returns A promise that resolves to the retrieved document.
+     * @throws {@link ResourceNotAvailableError} if the document with the specified ID does not exist.
      */
     get(id: string, options: RequiredSome<ElasticEntityService.FindOneOptions, 'projection'>): Promise<PartialDTO<T>>;
     /**
      * Retrieves a document from the collection by its ID. Throws error if not found.
      *
-     * @param {string} id - The ID of the document to retrieve.
-     * @param {ElasticEntityService.FindOneOptions<T>} [options] - Optional options for the findOne operation.
-     * @returns {Promise<T>} - A promise that resolves to the retrieved document,
-     *    or rejects with a ResourceNotFoundError if the document does not exist.
-     * @throws {ResourceNotAvailableError} - If the document with the specified ID does not exist.
+     * @param id - The ID of the document to retrieve.
+     * @param options - Optional options for the operation.
+     * @returns A promise that resolves to the retrieved document.
+     * @throws {@link ResourceNotAvailableError} if the document with the specified ID does not exist.
      */
     get(id: string, options?: ElasticEntityService.FindOneOptions): Promise<T>;
     /**
      * Updates a document in the collection with the specified ID.
      *
-     * @param {string} id - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial input data to update the document with.
-     * @param {ElasticEntityService.UpdateOneOptions} [options] - The options for updating the document.
-     * @returns {Promise<estypes.UpdateResponse>} - A promise that resolves to the number of documents modified.
+     * @param id - The ID of the document to update.
+     * @param input - The partial input data to update the document with.
+     * @param options - The options for updating the document.
+     * @returns A promise that resolves to the update response.
      */
     update(id: string, input: PatchDTO<T>, options?: ElasticEntityService.UpdateOneOptions): Promise<estypes.UpdateByQueryResponse>;
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
-     * @param {PatchDTO<T>} input - The partial input to update the documents with.
-     * @param {ElasticEntityService.UpdateManyOptions} options - The options for updating the documents.
-     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     * @param input - The partial input to update the documents with.
+     * @param options - The options for updating the documents.
+     * @returns A promise that resolves to the update response.
      */
     updateMany(input: PatchDTO<T>, options?: ElasticEntityService.UpdateManyOptions): Promise<estypes.UpdateByQueryResponse>;
     /**
      * Retrieves the common filter used for querying documents.
-     * This method is mostly used for security issues like securing multi-tenant applications.
      *
+     * @param command - The command information.
      * @protected
-     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
-     * that resolves to the common filter, or undefined if not available.
+     * @returns The common filter or a promise that resolves to the common filter.
      */
     protected _getDocumentFilter(command: ElasticService.CommandInfo): ElasticAdapter.FilterInput | Promise<ElasticAdapter.FilterInput> | undefined;
 }

package/elastic-collection-service.js

@@ -2,28 +2,24 @@ import { ResourceNotAvailableError } from '@opra/common';
 import { ElasticAdapter } from './elastic-adapter.js';
 import { ElasticEntityService } from './elastic-entity-service.js';
 /**
- * @class ElasticCollectionService
+ * Class representing an Elasticsearch collection service for interacting with an Elasticsearch index.
+ *
  * @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}
+     * Represents a common filter for the service.
      */
     documentFilter;
     /**
-     * Represents the default limit value for a certain operation.
-     *
-     * @type {number}
+     * Represents the default limit value for find operations.
      */
     defaultLimit;
     /**
-     * Constructs a new instance
+     * Constructs a new instance.
      *
-     * @param {Type | string} dataType - The data type of the array elements.
-     * @param {ElasticCollectionService.Options} [options] - The options for the array service.
-     * @constructor
+     * @param dataType - The data type of the documents.
+     * @param options - The options for the collection service.
      */
     constructor(dataType, options) {
         super(dataType, options);
@@ -45,24 +41,23 @@ export class ElasticCollectionService extends ElasticEntityService {
     }
     /**
      * Asserts the existence of a resource with the given ID.
-     * Throws a ResourceNotFoundError if the resource does not exist.
      *
-     * @param {string} id - The ID of the resource to assert.
-     * @param {ElasticEntityService.FindOneOptions} [options] - Optional options for checking the existence.
-     * @returns {Promise<void>} - A Promise that resolves when the resource exists.
-     * @throws {ResourceNotAvailableError} - If the resource does not exist.
+     * @param id - The ID of the resource to assert.
+     * @param options - Optional options for checking the existence.
+     * @returns A promise that resolves when the resource exists.
+     * @throws {@link ResourceNotAvailableError} if the resource does not exist.
      */
     async assert(id, options) {
         if (!(await this.exists(id, options)))
             throw new ResourceNotAvailableError(this.getResourceName(), id);
     }
     /**
-     * Adds a document to the specified index
+     * Adds a document to the specified index.
      *
-     * @param {PartialDTO<T>} input - The input data for creating the document.
-     * @param {ElasticEntityService.CreateOptions} [options] - The options for creating the document.
-     * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created document.
-     * @throws {Error} if an unknown error occurs while creating the document.
+     * @param input - The input data for creating the document.
+     * @param options - The options for creating the document.
+     * @returns A promise that resolves to the created response.
+     * @throws {@link Error} if an unknown error occurs while creating the document.
      */
     async create(input, options) {
         const command = {
@@ -81,8 +76,8 @@ export class ElasticCollectionService extends ElasticEntityService {
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
-     * @param {ElasticEntityService.CountOptions<T>} options - The options for the count operation.
-     * @return {Promise<number>} - A promise that resolves to the count of documents in the collection.
+     * @param options - The options for the count operation.
+     * @returns A promise that resolves to the count of documents.
      */
     async count(options) {
         const command = {
@@ -102,11 +97,11 @@ export class ElasticCollectionService extends ElasticEntityService {
         });
     }
     /**
-     * Deletes a document from the collection.
+     * Deletes a document from the collection by its ID.
      *
-     * @param {string} id - The ID of the document to delete.
-     * @param {ElasticEntityService.DeleteOptions} [options] - Optional delete options.
-     * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
+     * @param id - The ID of the document to delete.
+     * @param options - Optional delete options.
+     * @returns A promise that resolves to the delete response.
      */
     async delete(id, options) {
         const command = {
@@ -128,8 +123,8 @@ export class ElasticCollectionService extends ElasticEntityService {
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {ElasticEntityService.DeleteManyOptions} options - The options for the delete operation.
-     * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
+     * @param options - The options for the delete operation.
+     * @returns A promise that resolves to the delete response.
      */
     async deleteMany(options) {
         const command = {
@@ -148,11 +143,11 @@ export class ElasticCollectionService extends ElasticEntityService {
         });
     }
     /**
-     * Checks if an object with the given id exists.
+     * Checks if an object with the given ID exists.
      *
-     * @param {string} id - The id of the object to check.
-     * @param {ElasticEntityService.FindOneOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
+     * @param id - The ID of the object to check.
+     * @param options - The options for the query.
+     * @returns A promise that resolves to a boolean indicating whether the object exists.
      */
     async exists(id, options) {
         const command = {
@@ -180,10 +175,10 @@ export class ElasticCollectionService extends ElasticEntityService {
         });
     }
     /**
-     * Checks if an object with the given arguments exists.
+     * Checks if at least one document exists matching the specified criteria.
      *
-     * @param {ElasticEntityService.FindOneOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
+     * @param options - The options for the query.
+     * @returns A promise that resolves to a boolean indicating whether the object exists.
      */
     async existsOne(options) {
         const command = {
@@ -206,7 +201,11 @@ export class ElasticCollectionService extends ElasticEntityService {
         });
     }
     /**
+     * Finds a document by its ID.
      *
+     * @param id - The ID of the document.
+     * @param options - The options for the find operation.
+     * @returns A promise resolving to the found document, or undefined if not found.
      */
     async findById(id, options) {
         const command = {
@@ -238,7 +237,10 @@ export class ElasticCollectionService extends ElasticEntityService {
         });
     }
     /**
+     * Finds a document in the collection that matches the specified criteria.
      *
+     * @param options - The options for the find operation.
+     * @returns A promise that resolves with the found document or undefined if no document is found.
      */
     async findOne(options) {
         const command = {
@@ -268,7 +270,10 @@ export class ElasticCollectionService extends ElasticEntityService {
         });
     }
     /**
+     * Finds multiple documents in the Elasticsearch collection.
      *
+     * @param options - The options for the find operation.
+     * @returns A promise that resolves to an array of documents.
      */
     async findMany(options) {
         const command = {
@@ -299,7 +304,10 @@ export class ElasticCollectionService extends ElasticEntityService {
         return this._executeCommand(command, async () => this._searchRaw(command));
     }
     /**
+     * Finds multiple documents and returns both records and total count.
      *
+     * @param options - The options for the find operation.
+     * @returns A promise that resolves to an object containing items and count.
      */
     async findManyWithCount(options) {
         const command = {
@@ -341,7 +349,12 @@ export class ElasticCollectionService extends ElasticEntityService {
         });
     }
     /**
+     * Retrieves a document from the collection by its ID. Throws error if not found.
      *
+     * @param id - The ID of the document to retrieve.
+     * @param options - Optional options for the operation.
+     * @returns A promise that resolves to the retrieved document.
+     * @throws {@link ResourceNotAvailableError} if the document with the specified ID does not exist.
      */
     async get(id, options) {
         const out = await this.findById(id, options);
@@ -352,10 +365,10 @@ export class ElasticCollectionService extends ElasticEntityService {
     /**
      * Updates a document in the collection with the specified ID.
      *
-     * @param {string} id - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial input data to update the document with.
-     * @param {ElasticEntityService.UpdateOneOptions} [options] - The options for updating the document.
-     * @returns {Promise<estypes.UpdateResponse>} - A promise that resolves to the number of documents modified.
+     * @param id - The ID of the document to update.
+     * @param input - The partial input data to update the document with.
+     * @param options - The options for updating the document.
+     * @returns A promise that resolves to the update response.
      */
     async update(id, input, options) {
         const command = {
@@ -378,9 +391,9 @@ export class ElasticCollectionService extends ElasticEntityService {
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
-     * @param {PatchDTO<T>} input - The partial input to update the documents with.
-     * @param {ElasticEntityService.UpdateManyOptions} options - The options for updating the documents.
-     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     * @param input - The partial input to update the documents with.
+     * @param options - The options for updating the documents.
+     * @returns A promise that resolves to the update response.
      */
     async updateMany(input, options) {
         const command = {
@@ -401,11 +414,10 @@ export class ElasticCollectionService extends ElasticEntityService {
     }
     /**
      * Retrieves the common filter used for querying documents.
-     * This method is mostly used for security issues like securing multi-tenant applications.
      *
+     * @param command - The command information.
      * @protected
-     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
-     * that resolves to the common filter, or undefined if not available.
+     * @returns The common filter or a promise that resolves to the common filter.
      */
     _getDocumentFilter(command) {
         const commonFilter = Array.isArray(this.documentFilter)

package/elastic-entity-service.d.ts

@@ -25,9 +25,7 @@ export declare namespace ElasticEntityService {
     interface CommandInfo extends ElasticService.CommandInfo {
     }
     /**
-     * Represents options for "create" operation
-     *
-     * @interface
+     * Represents options for the "create" operation.
      */
     interface CreateOptions {
         request?: StrictOmit<CreateRequest, 'id' | 'index' | 'document'>;
@@ -35,9 +33,8 @@ export declare namespace ElasticEntityService {
         replaceIfExists?: boolean;
     }
     /**
-     * Represents options for "count" operation
+     * Represents options for the "count" operation.
      *
-     * @interface
      * @template T - The type of the document.
      */
     interface CountOptions {
@@ -46,9 +43,8 @@ export declare namespace ElasticEntityService {
         transport?: TransportRequestOptions;
     }
     /**
-     * Represents options for "delete" operation
+     * Represents options for the "delete" operation.
      *
-     * @interface
      * @template T - The type of the document.
      */
     interface DeleteOptions {
@@ -57,9 +53,8 @@ export declare namespace ElasticEntityService {
         transport?: TransportRequestOptions;
     }
     /**
-     * Represents options for "deleteMany" operation
+     * Represents options for the "deleteMany" operation.
      *
-     * @interface
      * @template T - The type of the document.
      */
     interface DeleteManyOptions {
@@ -68,17 +63,15 @@ export declare namespace ElasticEntityService {
         transport?: TransportRequestOptions;
     }
     /**
-     * Represents options for "findOne" operation
+     * Represents options for the "findOne" operation.
      *
-     * @interface
      * @template T - The type of the document.
      */
     interface FindOneOptions extends StrictOmit<FindManyOptions, 'limit'> {
     }
     /**
-     * Represents options for "findMany" operation
+     * Represents options for the "findMany" operation.
      *
-     * @interface
      * @template T - The type of the document.
      */
     interface FindManyOptions {
@@ -92,18 +85,15 @@ export declare namespace ElasticEntityService {
         noDecode?: boolean;
     }
     /**
-     * Represents options for "search" operation
-     *
-     * @interface
+     * Represents options for the "search" operation.
      */
     interface SearchOptions {
         transport?: TransportRequestOptions;
         noDecode?: boolean;
     }
     /**
-     * Represents options for "update" operation
+     * Represents options for the "update" operation.
      *
-     * @interface
      * @template T - The type of the document.
      */
     interface UpdateOneOptions {
@@ -112,9 +102,8 @@ export declare namespace ElasticEntityService {
         transport?: TransportRequestOptions;
     }
     /**
-     * Represents options for "updateMany" operation
+     * Represents options for the "updateMany" operation.
      *
-     * @interface
      * @template T - The type of the document.
      */
     interface UpdateManyOptions {
@@ -167,7 +156,8 @@ export declare namespace ElasticEntityService {
     type ScriptSource = estypes.ScriptSource;
 }
 /**
- * @class ElasticEntityService
+ * Class representing an Elasticsearch entity service for interacting with an Elasticsearch index.
+ *
  * @template T - The type of the documents in the collection.
  */
 export declare class ElasticEntityService<T extends object = any> extends ElasticService {
@@ -177,29 +167,26 @@ export declare class ElasticEntityService<T extends object = any> extends Elasti
     protected _inputCodecs: Record<string, vg.isObject.Validator<T>>;
     protected _outputCodecs: Record<string, vg.isObject.Validator<T>>;
     /**
-     * Defines comma delimited scopes for api document
+     * Defines comma-delimited scopes for API document.
      */
     scope?: string;
     /**
-     * Represents the name of a index in ElasticDB
+     * Represents the name of an index in Elasticsearch.
      */
     indexName?: string | ((_this: any) => string);
     /**
      * Represents the name of a resource.
-     * @type {string}
      */
     resourceName?: string | ((_this: any) => string);
     /**
-     * Generates a new id for new inserting Document.
-     *
+     * Generates a new ID for a new document.
      */
     idGenerator?: (command: ElasticEntityService.CommandInfo, _this: any) => any;
     /**
-     * Constructs a new instance
+     * 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
+     * @param dataType - The data type of the documents.
+     * @param options - The options for the entity service.
      */
     constructor(dataType: Type | string, options?: ElasticEntityService.Options);
     /**
@@ -207,21 +194,21 @@ export declare class ElasticEntityService<T extends object = any> extends Elasti
      *
      * @protected
      * @returns The index name.
-     * @throws {Error} If the index name is not defined.
+     * @throws {@link Error} if the index name is not defined.
      */
     getIndexName(): string;
     /**
      * Retrieves the resource name.
      *
      * @protected
-     * @returns {string} The resource name.
-     * @throws {Error} If the resource name is not defined.
+     * @returns The resource name.
+     * @throws {@link Error} if the resource name is not defined.
      */
     getResourceName(): string;
     /**
-     * Retrieves the OPRA data type
+     * Retrieves the OPRA data type.
      *
-     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     * @throws {@link NotAcceptableError} if the data type is not a `ComplexType`.
      */
     get dataType(): ComplexType;
     /**
@@ -229,52 +216,59 @@ export declare class ElasticEntityService<T extends object = any> extends Elasti
      * If the target is an index and the document already exists,
      * the request updates the document and increments its version.
      *
-     * @param {ElasticEntityService.CreateCommand} command
+     * @param command - The create command.
      * @protected
+     * @throws {@link InternalServerError} if an unknown error occurs while creating the document.
      */
     protected _create(command: ElasticEntityService.CreateCommand): Promise<ElasticEntityService.CreateResponse>;
     protected __create(request: ElasticEntityService.CreateRequest, options?: ElasticEntityService.CreateOptions): Promise<estypes.WriteResponseBase>;
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
-     * @param {ElasticEntityService.CountCommand} command
+     * @param command - The count command.
      * @protected
+     * @returns A promise that resolves to the count response.
      */
     protected _count(command: ElasticEntityService.CountCommand): Promise<ElasticEntityService.CountResponse>;
     protected __count(request: ElasticEntityService.CountRequest, options?: ElasticEntityService.CountOptions): Promise<estypes.CountResponse>;
     /**
      * Deletes a document from the collection.
      *
-     * @param {ElasticEntityService.DeleteCommand} command
+     * @param command - The delete command.
      * @protected
+     * @returns A promise that resolves to the delete response.
      */
     protected _delete(command: ElasticEntityService.DeleteCommand): Promise<ElasticEntityService.DeleteByQueryResponse>;
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {ElasticEntityService.DeleteManyCommand} command
+     * @param command - The deleteMany command.
      * @protected
+     * @returns A promise that resolves to the delete response.
      */
     protected _deleteMany(command: ElasticEntityService.DeleteManyCommand): Promise<ElasticEntityService.DeleteByQueryResponse>;
     protected __delete(request: ElasticEntityService.DeleteByQueryRequest, options?: ElasticEntityService.DeleteOptions): Promise<estypes.DeleteByQueryResponse>;
     /**
-     * Returns search hits that match the query defined in the request
+     * Returns search hits that match the query defined in the request.
      *
-     * @param {ElasticEntityService.FindManyCommand} command
+     * @param command - The findMany command.
+     * @returns A promise that resolves to the search response.
      */
     protected _findMany(command: ElasticEntityService.FindManyCommand): Promise<ElasticEntityService.SearchResponse<PartialDTO<T>>>;
     protected __findMany(request: ElasticEntityService.SearchRequest, options?: ElasticEntityService.FindManyOptions): Promise<estypes.SearchResponse<T, Record<string, estypes.AggregationsAggregate>>>;
     /**
      * Executes a search operation on the Elasticsearch index using the provided search command.
      *
-     * @param {ElasticEntityService.SearchCommand} command - The search command containing the request configuration and optional transport settings.
-     * @return {Promise<ElasticEntityService.SearchResponse>} A promise resolving to the search response from Elasticsearch.
+     * @param command - The search command containing the request configuration and optional transport settings.
+     * @returns A promise resolving to the search response from Elasticsearch.
      */
     protected _searchRaw(command: ElasticEntityService.SearchCommand): Promise<ElasticEntityService.SearchResponse<PartialDTO<T>>>;
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
-     * @param {ElasticEntityService.UpdateCommand<T>} command
+     * @param command - The update command.
+     * @returns A promise that resolves to the update response.
+     * @throws {@link TypeError} if both 'input' and 'script' are provided and the script language is not 'painless'.
      */
     protected _updateMany(command: ElasticEntityService.UpdateCommand<T>): Promise<ElasticEntityService.UpdateByQueryResponse>;
     protected __update(request: ElasticEntityService.UpdateByQueryRequest, options?: ElasticEntityService.UpdateManyOptions): Promise<estypes.UpdateByQueryResponse>;

package/elastic-entity-service.js

@@ -3,7 +3,8 @@ import { isNotNullish } from 'valgen';
 import { ElasticAdapter } from './elastic-adapter.js';
 import { ElasticService } from './elastic-service.js';
 /**
- * @class ElasticEntityService
+ * Class representing an Elasticsearch entity service for interacting with an Elasticsearch index.
+ *
  * @template T - The type of the documents in the collection.
  */
 export class ElasticEntityService extends ElasticService {
@@ -13,29 +14,26 @@ export class ElasticEntityService extends ElasticService {
     _inputCodecs = {};
     _outputCodecs = {};
     /**
-     * Defines comma delimited scopes for api document
+     * Defines comma-delimited scopes for API document.
      */
     scope;
     /**
-     * Represents the name of a index in ElasticDB
+     * Represents the name of an index in Elasticsearch.
      */
     indexName;
     /**
      * Represents the name of a resource.
-     * @type {string}
      */
     resourceName;
     /**
-     * Generates a new id for new inserting Document.
-     *
+     * Generates a new ID for a new document.
      */
     idGenerator;
     /**
-     * Constructs a new instance
+     * 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
+     * @param dataType - The data type of the documents.
+     * @param options - The options for the entity service.
      */
     constructor(dataType, options) {
         super(options);
@@ -59,7 +57,7 @@ export class ElasticEntityService extends ElasticService {
      *
      * @protected
      * @returns The index name.
-     * @throws {Error} If the index name is not defined.
+     * @throws {@link Error} if the index name is not defined.
      */
     getIndexName() {
         const out = typeof this.indexName === 'function'
@@ -73,8 +71,8 @@ export class ElasticEntityService extends ElasticService {
      * Retrieves the resource name.
      *
      * @protected
-     * @returns {string} The resource name.
-     * @throws {Error} If the resource name is not defined.
+     * @returns The resource name.
+     * @throws {@link Error} if the resource name is not defined.
      */
     getResourceName() {
         const out = typeof this.resourceName === 'function'
@@ -85,9 +83,9 @@ export class ElasticEntityService extends ElasticService {
         throw new Error('resourceName is not defined');
     }
     /**
-     * Retrieves the OPRA data type
+     * Retrieves the OPRA data type.
      *
-     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     * @throws {@link NotAcceptableError} if the data type is not a `ComplexType`.
      */
     get dataType() {
         if (this._dataType && this._dataTypeScope !== this.scope)
@@ -102,8 +100,9 @@ export class ElasticEntityService extends ElasticService {
      * If the target is an index and the document already exists,
      * the request updates the document and increments its version.
      *
-     * @param {ElasticEntityService.CreateCommand} command
+     * @param command - The create command.
      * @protected
+     * @throws {@link InternalServerError} if an unknown error occurs while creating the document.
      */
     async _create(command) {
         const input = command.input;
@@ -135,8 +134,9 @@ export class ElasticEntityService extends ElasticService {
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
-     * @param {ElasticEntityService.CountCommand} command
+     * @param command - The count command.
      * @protected
+     * @returns A promise that resolves to the count response.
      */
     async _count(command) {
         const { options } = command;
@@ -164,8 +164,9 @@ export class ElasticEntityService extends ElasticService {
     /**
      * Deletes a document from the collection.
      *
-     * @param {ElasticEntityService.DeleteCommand} command
+     * @param command - The delete command.
      * @protected
+     * @returns A promise that resolves to the delete response.
      */
     async _delete(command) {
         isNotNullish(command.documentId, { label: 'documentId' });
@@ -191,8 +192,9 @@ export class ElasticEntityService extends ElasticService {
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {ElasticEntityService.DeleteManyCommand} command
+     * @param command - The deleteMany command.
      * @protected
+     * @returns A promise that resolves to the delete response.
      */
     async _deleteMany(command) {
         const { options } = command;
@@ -218,9 +220,10 @@ export class ElasticEntityService extends ElasticService {
         return client.deleteByQuery(request, options?.transport);
     }
     /**
-     * Returns search hits that match the query defined in the request
+     * Returns search hits that match the query defined in the request.
      *
-     * @param {ElasticEntityService.FindManyCommand} command
+     * @param command - The findMany command.
+     * @returns A promise that resolves to the search response.
      */
     async _findMany(command) {
         const { options } = command;
@@ -267,8 +270,8 @@ export class ElasticEntityService extends ElasticService {
     /**
      * Executes a search operation on the Elasticsearch index using the provided search command.
      *
-     * @param {ElasticEntityService.SearchCommand} command - The search command containing the request configuration and optional transport settings.
-     * @return {Promise<ElasticEntityService.SearchResponse>} A promise resolving to the search response from Elasticsearch.
+     * @param command - The search command containing the request configuration and optional transport settings.
+     * @returns A promise resolving to the search response from Elasticsearch.
      */
     async _searchRaw(command) {
         const { options } = command;
@@ -293,7 +296,9 @@ export class ElasticEntityService extends ElasticService {
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
-     * @param {ElasticEntityService.UpdateCommand<T>} command
+     * @param command - The update command.
+     * @returns A promise that resolves to the update response.
+     * @throws {@link TypeError} if both 'input' and 'script' are provided and the script language is not 'painless'.
      */
     async _updateMany(command) {
         if (command.byId)
@@ -409,7 +414,7 @@ export class ElasticEntityService extends ElasticService {
     async _executeCommand(command, commandFn) {
         try {
             const result = await super._executeCommand(command, async () => {
-                /** Call before[X] hooks */
+                /* Call before[X] hooks */
                 if (command.crud === 'create')
                     await this._beforeCreate(command);
                 else if (command.crud === 'update' && command.byId) {
@@ -424,10 +429,10 @@ export class ElasticEntityService extends ElasticService {
                 else if (command.crud === 'delete' && !command.byId) {
                     await this._beforeDeleteMany(command);
                 }
-                /** Call command function */
+                /* Call command function */
                 return commandFn();
             });
-            /** Call after[X] hooks */
+            /* Call after[X] hooks */
             if (command.crud === 'create')
                 await this._afterCreate(command, result);
             else if (command.crud === 'update' && command.byId) {

package/elastic-service.d.ts

@@ -3,44 +3,43 @@ import { ServiceBase } from '@opra/core';
 export interface ElasticService {
     /**
      * Interceptor function for handling callback execution with provided arguments.
-     * @type Function
+     *
      * @param next - The callback function to be intercepted.
-     * @param {ElasticService.CommandInfo} command - The arguments object containing the following properties:
+     * @param command - The command information.
      * @param _this - The reference to the current object.
-     * @returns - The promise that resolves to the result of the callback execution.
+     * @returns The promise that resolves to the result of the callback execution.
      */
     interceptor?(next: () => any, command: ElasticService.CommandInfo, _this: any): Promise<any>;
 }
 /**
- * Class representing a ElasticSearch service for interacting with a collection.
- * @extends ServiceBase
+ * Class representing a Elasticsearch service for interacting with a collection.
+ *
  * @template T - The type of the documents in the collection.
  */
 export declare class ElasticService extends ServiceBase {
     /**
-     * Represents a ElasticDB database object.
+     * Represents an Elasticsearch client instance or a function that returns one.
      */
     client?: Client | ((_this: any) => Client);
     /**
      * Callback function for handling errors.
      *
-     * @param {unknown} error - The error object.
+     * @param error - The error object.
      * @param _this - The context object.
      */
     onError?: (error: unknown, _this: any) => void | Promise<void>;
     /**
-     * Constructs a new instance
+     * Constructs a new instance.
      *
-     * @param [options] - The options for the service
-     * @constructor
+     * @param options - The options for the service.
      */
     constructor(options?: ElasticService.Options);
     /**
-     * Retrieves the ElasticSearch client.
+     * Retrieves the Elasticsearch client.
      *
      * @protected
-     *
-     * @throws {Error} If the context or client is not set.
+     * @returns The Elasticsearch client.
+     * @throws {@link Error} if the client is not set.
      */
     getClient(): Client;
     protected _executeCommand(command: ElasticService.CommandInfo, commandFn: () => any): Promise<any>;

package/elastic-service.js

@@ -1,26 +1,25 @@
 import { ServiceBase } from '@opra/core';
 /**
- * Class representing a ElasticSearch service for interacting with a collection.
- * @extends ServiceBase
+ * Class representing a Elasticsearch service for interacting with a collection.
+ *
  * @template T - The type of the documents in the collection.
  */
 export class ElasticService extends ServiceBase {
     /**
-     * Represents a ElasticDB database object.
+     * Represents an Elasticsearch client instance or a function that returns one.
      */
     client;
     /**
      * Callback function for handling errors.
      *
-     * @param {unknown} error - The error object.
+     * @param error - The error object.
      * @param _this - The context object.
      */
     onError;
     /**
-     * Constructs a new instance
+     * Constructs a new instance.
      *
-     * @param [options] - The options for the service
-     * @constructor
+     * @param options - The options for the service.
      */
     constructor(options) {
         super();
@@ -29,11 +28,11 @@ export class ElasticService extends ServiceBase {
         this.onError = options?.onError;
     }
     /**
-     * Retrieves the ElasticSearch client.
+     * Retrieves the Elasticsearch client.
      *
      * @protected
-     *
-     * @throws {Error} If the context or client is not set.
+     * @returns The Elasticsearch client.
+     * @throws {@link Error} if the client is not set.
      */
     getClient() {
         // @ts-ignore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/elastic",
-  "version": "1.26.3",
+  "version": "1.26.4",
   "description": "Opra Elastic Search adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -11,8 +11,8 @@
   },
   "peerDependencies": {
     "@elastic/elasticsearch": ">=8.7.0 <10",
-    "@opra/common": "^1.26.3",
-    "@opra/core": "^1.26.3"
+    "@opra/common": "^1.26.4",
+    "@opra/core": "^1.26.4"
   },
   "type": "module",
   "module": "./index.js",