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

package/types/elastic-collection-service.d.ts

@@ -0,0 +1,217 @@
+import type * as elastic from '@elastic/elasticsearch/lib/api/types';
+import { HttpContext } from '@opra/core';
+import type { DTO, Nullish, PartialDTO, PatchDTO, RequiredSome, Type } from 'ts-gems';
+import { ElasticAdapter } from './elastic-adapter.js';
+import { ElasticEntityService } from './elastic-entity-service.js';
+import { ElasticService } from './elastic-service.js';
+/**
+ *
+ * @namespace ElasticCollectionService
+ */
+export declare namespace ElasticCollectionService {
+    /**
+     * The constructor options of ElasticCollectionService.
+     *
+     * @interface Options
+     * @extends ElasticService.Options
+     */
+    interface Options extends ElasticEntityService.Options {
+        documentFilter?: ElasticCollectionService['documentFilter'];
+        defaultLimit?: number;
+    }
+    type DocumentFilter = ElasticAdapter.FilterInput | ((args: ElasticEntityService.CommandInfo, _this: ElasticCollectionService) => ElasticAdapter.FilterInput | Promise<ElasticAdapter.FilterInput> | undefined);
+    interface FindManyWithCountResult<X> {
+        items: X[];
+        count: number;
+        relation: elastic.SearchTotalHitsRelation;
+    }
+}
+/**
+ * @class ElasticCollectionService
+ * @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}
+     */
+    documentFilter?: ElasticCollectionService.DocumentFilter | ElasticCollectionService.DocumentFilter[];
+    /**
+     * Represents the default limit value for a certain operation.
+     *
+     * @type {number}
+     */
+    defaultLimit: number;
+    /**
+     * 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
+     */
+    constructor(dataType: Type | string, options?: ElasticCollectionService.Options);
+    for<C extends HttpContext, P extends Partial<this>>(context: C, 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.
+     */
+    assert(id: string, options?: ElasticEntityService.FindOneOptions): Promise<void>;
+    /**
+     * 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.
+     */
+    create(input: DTO<T>, options?: ElasticEntityService.CreateOptions): Promise<elastic.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.
+     */
+    count(options?: ElasticEntityService.CountOptions): Promise<number>;
+    /**
+     * Deletes a document from the collection.
+     *
+     * @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.
+     */
+    delete(id: string, options?: ElasticEntityService.DeleteOptions): Promise<elastic.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.
+     */
+    deleteMany(options?: ElasticEntityService.DeleteManyOptions): Promise<elastic.DeleteByQueryResponse>;
+    /**
+     * 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.
+     */
+    exists(id: string, options?: ElasticEntityService.FindOneOptions): Promise<boolean>;
+    /**
+     * Checks if an object with the given arguments exists.
+     *
+     * @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.
+     */
+    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.
+     */
+    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.
+     */
+    findById(id: string, options?: ElasticEntityService.FindOneOptions): Promise<T | undefined>;
+    /**
+     * Finds a document in the collection that matches the specified options.
+     *
+     * @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.
+     */
+    findOne(options: RequiredSome<ElasticEntityService.FindOneOptions, 'projection'>): Promise<PartialDTO<T> | undefined>;
+    /**
+     * Finds a document in the collection that matches the specified options.
+     *
+     * @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.
+     */
+    findOne(options?: ElasticEntityService.FindOneOptions): Promise<T | undefined>;
+    /**
+     * Finds multiple documents in the ElasticDB collection.
+     *
+     * @param {ElasticEntityService.SearchOptions} 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.
+     */
+    findMany(options: RequiredSome<ElasticEntityService.SearchOptions, 'projection'>): Promise<PartialDTO<T>[]>;
+    /**
+     * Finds multiple documents in the ElasticDB collection.
+     *
+     * @param {ElasticEntityService.SearchOptions} options - The options for the find operation.
+     * @return {Promise<T | undefined>} A Promise that resolves to an array of partial outputs of type T.
+     */
+    findMany(options?: ElasticEntityService.SearchOptions): Promise<T[]>;
+    /**
+     * Finds multiple documents in the collection and returns both records (max limit)
+     * and total count that matched the given criteria
+     *
+     * @param {ElasticEntityService.SearchOptions} [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.
+     */
+    findManyWithCount(options: RequiredSome<ElasticEntityService.SearchOptions, '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
+     *
+     * @param {ElasticEntityService.SearchOptions} [options] - The options for the find operation.
+     * @return {ElasticCollectionService.FindManyWithCountResult<T>} A Promise that resolves to an array of partial outputs of type T.
+     */
+    findManyWithCount(options?: ElasticEntityService.SearchOptions): 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.
+     */
+    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.
+     */
+    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<elastic.UpdateResponse>} - A promise that resolves to the number of documents modified.
+     */
+    update(id: string, input: PatchDTO<T>, options?: ElasticEntityService.UpdateOneOptions): Promise<elastic.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.
+     */
+    updateMany(input: PatchDTO<T>, options?: ElasticEntityService.UpdateManyOptions): Promise<elastic.UpdateByQueryResponse>;
+    /**
+     * Retrieves the common filter used for querying documents.
+     * This method is mostly used for security issues like securing multi-tenant applications.
+     *
+     * @protected
+     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
+     * that resolves to the common filter, or undefined if not available.
+     */
+    protected _getDocumentFilter(command: ElasticService.CommandInfo): ElasticAdapter.FilterInput | Promise<ElasticAdapter.FilterInput> | undefined;
+}

package/types/elastic-entity-service.d.ts

@@ -0,0 +1,262 @@
+import type * as elastic from '@elastic/elasticsearch/lib/api/types.js';
+import type { TransportRequestOptions } from '@elastic/transport';
+import { ComplexType } from '@opra/common';
+import type { PartialDTO, PatchDTO, RequiredSome, StrictOmit, Type } from 'ts-gems';
+import { type IsObject } from 'valgen';
+import { ElasticAdapter } from './elastic-adapter.js';
+import { ElasticService } from './elastic-service.js';
+/**
+ *
+ * @namespace ElasticEntityService
+ */
+export declare namespace ElasticEntityService {
+    /**
+     * The constructor options of ElasticEntityService.
+     *
+     * @interface Options
+     * @extends ElasticService.Options
+     */
+    interface Options extends ElasticService.Options {
+        indexName?: ElasticEntityService['indexName'];
+        resourceName?: ElasticEntityService['resourceName'];
+        idGenerator?: ElasticEntityService['idGenerator'];
+    }
+    interface CommandInfo extends ElasticService.CommandInfo {
+    }
+    /**
+     * Represents options for "create" operation
+     *
+     * @interface
+     */
+    interface CreateOptions {
+        request?: elastic.CreateRequest;
+        transport?: TransportRequestOptions;
+    }
+    /**
+     * Represents options for "count" operation
+     *
+     * @interface
+     * @template T - The type of the document.
+     */
+    interface CountOptions {
+        filter?: ElasticAdapter.FilterInput;
+        request?: elastic.CountRequest;
+        transport?: TransportRequestOptions;
+    }
+    /**
+     * Represents options for "delete" operation
+     *
+     * @interface
+     * @template T - The type of the document.
+     */
+    interface DeleteOptions {
+        filter?: ElasticAdapter.FilterInput;
+        request?: elastic.DeleteByQueryRequest;
+        transport?: TransportRequestOptions;
+    }
+    /**
+     * Represents options for "deleteMany" operation
+     *
+     * @interface
+     * @template T - The type of the document.
+     */
+    interface DeleteManyOptions {
+        filter?: ElasticAdapter.FilterInput;
+        request?: elastic.DeleteByQueryRequest;
+        transport?: TransportRequestOptions;
+    }
+    /**
+     * Represents options for "findOne" operation
+     *
+     * @interface
+     * @template T - The type of the document.
+     */
+    interface FindOneOptions extends StrictOmit<SearchOptions, 'limit'> {
+    }
+    /**
+     * Represents options for "findMany" operation
+     *
+     * @interface
+     * @template T - The type of the document.
+     */
+    interface SearchOptions {
+        filter?: ElasticAdapter.FilterInput;
+        projection?: string | string[];
+        sort?: string[];
+        limit?: number;
+        skip?: number;
+        request?: elastic.SearchRequest;
+        transport?: TransportRequestOptions;
+    }
+    /**
+     * Represents options for "update" operation
+     *
+     * @interface
+     * @template T - The type of the document.
+     */
+    interface UpdateOneOptions {
+        filter?: ElasticAdapter.FilterInput;
+        request?: elastic.UpdateByQueryRequest;
+        transport?: TransportRequestOptions;
+    }
+    /**
+     * Represents options for "updateMany" operation
+     *
+     * @interface
+     * @template T - The type of the document.
+     */
+    interface UpdateManyOptions {
+        filter?: ElasticAdapter.FilterInput;
+        request?: elastic.UpdateByQueryRequest;
+        transport?: TransportRequestOptions;
+    }
+    interface CreateCommand extends StrictOmit<RequiredSome<CommandInfo, 'input'>, 'documentId'> {
+        crud: 'create';
+        options?: CreateOptions;
+    }
+    interface CountCommand extends StrictOmit<CommandInfo, 'documentId' | 'input'> {
+        crud: 'read';
+        options?: CountOptions;
+    }
+    interface DeleteCommand extends StrictOmit<CommandInfo, 'input'> {
+        crud: 'delete';
+        options?: DeleteOptions;
+    }
+    interface DeleteManyCommand extends StrictOmit<CommandInfo, 'input'> {
+        crud: 'delete';
+        options?: DeleteManyOptions;
+    }
+    interface SearchCommand extends StrictOmit<CommandInfo, 'input'> {
+        crud: 'read';
+        options?: SearchOptions;
+    }
+    interface UpdateCommand<T> extends CommandInfo {
+        crud: 'update';
+        input: PatchDTO<T>;
+        options?: UpdateOneOptions;
+    }
+}
+/**
+ * @class ElasticEntityService
+ * @template T - The type of the documents in the collection.
+ */
+export declare class ElasticEntityService<T extends object = any> extends ElasticService {
+    protected _dataType_: Type | string;
+    protected _dataType?: ComplexType;
+    protected _inputCodecs: Record<string, IsObject.Validator<T>>;
+    protected _outputCodecs: Record<string, IsObject.Validator<T>>;
+    /**
+     * Represents the name of a index in ElasticDB
+     */
+    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.
+     *
+     */
+    idGenerator?: (command: ElasticEntityService.CommandInfo, _this: any) => any;
+    /**
+     * 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: Type | string, options?: ElasticEntityService.Options);
+    /**
+     * Retrieves the index name.
+     *
+     * @protected
+     * @returns The index name.
+     * @throws {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.
+     */
+    getResourceName(): string;
+    /**
+     * Retrieves the OPRA data type
+     *
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataType(): ComplexType;
+    /**
+     * 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
+     */
+    protected _create(command: ElasticEntityService.CreateCommand): Promise<elastic.CreateResponse>;
+    /**
+     * Returns the count of documents in the collection based on the provided options.
+     *
+     * @param {ElasticEntityService.CountCommand} command
+     * @protected
+     */
+    protected _count(command: ElasticEntityService.CountCommand): Promise<elastic.CountResponse>;
+    /**
+     * Deletes a document from the collection.
+     *
+     * @param {ElasticEntityService.DeleteCommand} command
+     * @protected
+     */
+    protected _delete(command: ElasticEntityService.DeleteCommand): Promise<elastic.DeleteByQueryResponse>;
+    /**
+     * Deletes multiple documents from the collection that meet the specified filter criteria.
+     *
+     * @param {ElasticEntityService.DeleteManyCommand} command
+     * @protected
+     */
+    protected _deleteMany(command: ElasticEntityService.DeleteManyCommand): Promise<elastic.DeleteByQueryResponse>;
+    /**
+     * Returns search hits that match the query defined in the request
+     *
+     * @param {ElasticEntityService.SearchCommand} command
+     */
+    protected _search(command: ElasticEntityService.SearchCommand): Promise<elastic.SearchResponse>;
+    /**
+     * Updates multiple documents in the collection based on the specified input and options.
+     *
+     * @param {ElasticEntityService.UpdateCommand<T>} command
+     */
+    protected _updateMany(command: ElasticEntityService.UpdateCommand<T>): Promise<elastic.UpdateByQueryResponse>;
+    /**
+     * Generates an ID.
+     *
+     * @protected
+     * @returns The generated ID.
+     */
+    protected _generateId(command: ElasticEntityService.CommandInfo): any;
+    /**
+     * Retrieves the codec for the specified operation.
+     *
+     * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
+     */
+    protected _getInputCodec(operation: string): IsObject.Validator<T>;
+    /**
+     * Retrieves the codec.
+     */
+    protected _getOutputCodec(operation: string): IsObject.Validator<T>;
+    protected _executeCommand(command: ElasticEntityService.CommandInfo, commandFn: () => any): Promise<any>;
+    protected _beforeCreate(command: ElasticEntityService.CreateCommand): Promise<void>;
+    protected _beforeUpdate(command: ElasticEntityService.UpdateCommand<T>): Promise<void>;
+    protected _beforeUpdateMany(command: ElasticEntityService.UpdateCommand<T>): Promise<void>;
+    protected _beforeDelete(command: ElasticEntityService.DeleteCommand): Promise<void>;
+    protected _beforeDeleteMany(command: ElasticEntityService.DeleteCommand): Promise<void>;
+    protected _afterCreate(command: ElasticEntityService.CreateCommand, result: PartialDTO<T>): Promise<void>;
+    protected _afterUpdate(command: ElasticEntityService.UpdateCommand<T>, result?: PartialDTO<T>): Promise<void>;
+    protected _afterUpdateMany(command: ElasticEntityService.UpdateCommand<T>, affected: number): Promise<void>;
+    protected _afterDelete(command: ElasticEntityService.DeleteCommand, affected: number): Promise<void>;
+    protected _afterDeleteMany(command: ElasticEntityService.DeleteCommand, affected: number): Promise<void>;
+}

package/types/elastic-service.d.ts

@@ -1,9 +1,5 @@
 import { Client } from '@elastic/elasticsearch';
-import { QueryDslQueryContainer } from '@elastic/elasticsearch/lib/api/types';
-import { ComplexType } from '@opra/common';
 import { ServiceBase } from '@opra/core';
-import { Type } from 'ts-gems';
-import { IsObject } from 'valgen';
 /**
  * The namespace for the ElasticService.
  *
@@ -11,12 +7,9 @@ import { IsObject } from 'valgen';
  */
 export declare namespace ElasticService {
     interface Options {
-        client?: ElasticService<any>['client'];
-        resourceName?: ElasticService<any>['$resourceName'];
-        commonFilter?: ElasticService<any>['$commonFilter'];
-        interceptor?: ElasticService<any>['$interceptor'];
-        idGenerator?: ElasticService<any>['$idGenerator'];
-        onError?: ElasticService<any>['$onError'];
+        client?: ElasticService['client'];
+        interceptor?: ElasticService['interceptor'];
+        onError?: ElasticService['onError'];
     }
     type CrudOp = 'create' | 'read' | 'update' | 'delete';
     interface CommandInfo {
@@ -24,101 +17,45 @@ export declare namespace ElasticService {
         method: string;
         byId: boolean;
         documentId?: any;
-        input?: Record<string, any>;
-        options?: Record<string, any>;
+        input?: any;
+        options?: any;
     }
 }
+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 _this - The reference to the current object.
+     * @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
  * @template T - The type of the documents in the collection.
  */
-export declare class ElasticService<T extends object> extends ServiceBase {
-    protected _dataType_: Type | string;
-    protected _dataType?: ComplexType;
-    protected _inputCodecs: Record<string, IsObject.Validator<T>>;
-    protected _outputCodecs: Record<string, IsObject.Validator<T>>;
-    /**
-     * Represents the name of a index in ElasticDB
-     */
-    $indexName: string | ((_this: any) => string);
-    /**
-     * Represents the name of a resource.
-     * @type {string}
-     */
-    $resourceName?: string | ((_this: any) => string);
+export declare class ElasticService extends ServiceBase {
     /**
      * Represents a ElasticDB database object.
      */
     client?: Client | ((_this: any) => Client);
-    /**
-     * Generates a new id for new inserting Document.
-     *
-     */
-    $idGenerator?: (_this: any) => any;
     /**
      * Callback function for handling errors.
      *
      * @param {unknown} error - The error object.
      * @param _this - The context object.
      */
-    $onError?: (error: unknown, _this: any) => void | Promise<void>;
-    /**
-     * Represents a common filter function for a ElasticService.
-     *
-     * @type {QueryDslQueryContainer | Function}
-     */
-    $commonFilter?: QueryDslQueryContainer | ((args: ElasticService.CommandInfo, _this: this) => QueryDslQueryContainer | Promise<QueryDslQueryContainer> | undefined);
-    /**
-     * Interceptor function for handling callback execution with provided arguments.
-     *
-     * @param callback - The callback function to be intercepted.
-     * @param {ElasticService.CommandInfo} info - The arguments object containing the following properties:
-     * @param _this - The reference to the current object.
-     * @returns - The promise that resolves to the result of the callback execution.
-     */
-    $interceptor?: (callback: () => any, info: ElasticService.CommandInfo, _this: any) => Promise<any>;
+    onError?: (error: unknown, _this: any) => void | Promise<void>;
     /**
      * 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: Type | string, indexName: string, options?: ElasticService.Options);
-    /**
-     * Retrieves the index name.
-     *
-     * @protected
-     * @returns The index name.
-     * @throws {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.
-     */
-    getResourceName(): string;
-    /**
-     * Retrieves the OPRA data type
-     *
-     * @throws {NotAcceptableError} If the data type is not a ComplexType.
-     */
-    get dataType(): ComplexType;
-    /**
-     * Retrieves the codec for the specified operation.
-     *
-     * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
-     */
-    getInputCodec(operation: string): IsObject.Validator<T>;
-    /**
-     * Retrieves the codec.
-     */
-    getOutputCodec(operation: string): IsObject.Validator<T>;
+    constructor(options?: ElasticService.Options);
     /**
      * Retrieves the ElasticSearch client.
      *
@@ -127,21 +64,5 @@ export declare class ElasticService<T extends object> extends ServiceBase {
      * @throws {Error} If the context or client is not set.
      */
     getClient(): Client;
-    /**
-     * Generates an ID.
-     *
-     * @protected
-     * @returns The generated ID.
-     */
-    protected _generateId(): any;
-    /**
-     * 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.
-     */
-    protected _getCommonFilter(info: ElasticService.CommandInfo): QueryDslQueryContainer | Promise<QueryDslQueryContainer> | undefined;
-    protected _intercept(callback: (...args: any[]) => any, info: ElasticService.CommandInfo): Promise<any>;
+    protected _executeCommand(command: ElasticService.CommandInfo, commandFn: () => any): Promise<any>;
 }

package/types/index.d.cts

@@ -0,0 +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/types/index.d.ts

@@ -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/cjs/adapter-utils/prepare-key-values.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = prepareKeyValues;
-const tslib_1 = require("tslib");
-const putil_isplainobject_1 = tslib_1.__importDefault(require("putil-isplainobject"));
-const defaultPrimaryKey = ['_id'];
-function prepareKeyValues(keyValue, primaryKey) {
-    primaryKey = primaryKey || defaultPrimaryKey;
-    const b = (0, putil_isplainobject_1.default)(keyValue);
-    if (primaryKey.length > 1 && !b) {
-        throw new TypeError(`Argument "keyValue" must be an object that contains all key values`);
-    }
-    if (primaryKey.length > 1 || b) {
-        return primaryKey.reduce((o, k) => {
-            o[k] = keyValue[k];
-            if (o[k] == null)
-                throw new Error(`Value of key "${k}" is required`);
-            return o;
-        }, {});
-    }
-    return { [primaryKey[0]]: keyValue };
-}