@opra/sqb 1.0.0-alpha.2 → 1.0.0-alpha.21

package/esm/sqb-singleton-service.js

@@ -37,27 +37,29 @@ export class SqbSingletonService extends SqbEntityService {
      * @throws {Error} if an unknown error occurs while creating the resource
      */
     async create(input, options) {
-        const info = {
+        const command = {
             crud: 'create',
             method: 'create',
             byId: false,
             input,
             options,
         };
-        return this._intercept(async () => {
+        return this._executeCommand(command, async () => {
             const primaryFields = EntityMetadata.getPrimaryIndexColumns(this.entityMetadata);
-            const data = { ...input };
+            const data = { ...command.input };
             if (primaryFields.length > 1) {
-                if (typeof primaryFields !== 'object')
+                if (typeof primaryFields !== 'object') {
                     throw new TypeError(`"${this.entityMetadata.name}" should has multiple primary key fields. So you should provide and object that contains key fields`);
+                }
                 for (const field of primaryFields) {
                     data[field.name] = this.id[field.name];
                 }
             }
             else
                 data[primaryFields[0].name] = this.id;
-            return await this._create(data, options);
-        }, info);
+            command.input = data;
+            return await this._create(command);
+        });
     }
     /**
      * Deletes the singleton record
@@ -66,17 +68,18 @@ export class SqbSingletonService extends SqbEntityService {
      * @return {Promise<number>} - A Promise that resolves to the number of records deleted
      */
     async delete(options) {
-        const info = {
+        const command = {
             crud: 'delete',
             method: 'delete',
             byId: true,
             documentId: this.id,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._delete(this.id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._delete(command);
+        });
     }
     /**
      * Checks if the singleton record exists.
@@ -85,17 +88,18 @@ export class SqbSingletonService extends SqbEntityService {
      * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the record exists or not.
      */
     async exists(options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'exists',
             byId: true,
             documentId: this.id,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._exists(this.id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._exists(command);
+        });
     }
     /**
      * Finds the singleton record. Returns `undefined` if not found
@@ -104,17 +108,18 @@ export class SqbSingletonService extends SqbEntityService {
      * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
      */
     async find(options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'findById',
             byId: true,
             documentId: this.id,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._findById(this.id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._findById(command);
+        });
     }
     /**
      * Retrieves the singleton record. Throws error if not found.
@@ -139,7 +144,7 @@ export class SqbSingletonService extends SqbEntityService {
      * undefined if the document was not found.
      */
     async update(input, options) {
-        const info = {
+        const command = {
             crud: 'update',
             method: 'update',
             documentId: this.id,
@@ -147,10 +152,11 @@ export class SqbSingletonService extends SqbEntityService {
             input,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._update(this.id, input, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._update(command);
+        });
     }
     /**
      * Updates the singleton and  returns updated record count
@@ -160,7 +166,7 @@ export class SqbSingletonService extends SqbEntityService {
      * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
      */
     async updateOnly(input, options) {
-        const info = {
+        const command = {
             crud: 'update',
             method: 'update',
             documentId: this.id,
@@ -168,9 +174,10 @@ export class SqbSingletonService extends SqbEntityService {
             input,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._updateOnly(this.id, input, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._updateOnly(command);
+        });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/sqb",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.21",
   "description": "Opra SQB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -17,25 +17,29 @@
     "build:esm": "tsc -b tsconfig-build-esm.json",
     "postbuild": "cp README.md package.json ../../LICENSE ../../build/sqb && cp ../../package.cjs.json ../../build/sqb/cjs/package.json",
     "lint": "eslint . --max-warnings=0",
+    "lint:fix": "eslint . --max-warnings=0 --fix",
     "format": "prettier . --write --log-level=warn",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
+    "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": {
+    "reflect-metadata": "^0.2.2"
+  },
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",
-    "@sqb/builder": "^4.12.0",
-    "@sqb/connect": "^4.12.0",
-    "@sqb/postgres": "^4.12.0",
-    "postgresql-client": "^2.11.0",
+    "@sqb/builder": "^4.12.1",
+    "@sqb/connect": "^4.12.1",
+    "@sqb/postgres": "^4.12.1",
+    "postgresql-client": "^2.12.0",
     "ts-gems": "^3.4.0"
   },
   "peerDependencies": {
-    "@opra/core": "^1.0.0-alpha.2",
+    "@opra/core": "^1.0.0-alpha.21",
     "@sqb/connect": ">= 4.10.6"
   },
   "type": "module",

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

@@ -7,7 +7,7 @@ import { SqbEntityService } from './sqb-entity-service.js';
 export declare namespace SqbCollectionService {
     interface Options extends SqbEntityService.Options {
         defaultLimit?: SqbCollectionService<any>['defaultLimit'];
-        interceptor?: SqbCollectionService<any>['$interceptor'];
+        interceptor?: SqbCollectionService<any>['interceptor'];
     }
     /**
      * Represents options for "create" operation
@@ -70,14 +70,14 @@ export declare namespace SqbCollectionService {
      *
      * @interface
      */
-    interface UpdateOptions extends SqbEntityService.UpdateOptions {
+    interface UpdateOptions extends SqbEntityService.UpdateOneOptions {
     }
     /**
      * Represents options for "updateOnly" operation
      *
      * @interface
      */
-    interface UpdateOnlyOptions extends SqbEntityService.UpdateOptions {
+    interface UpdateOnlyOptions extends SqbEntityService.UpdateOneOptions {
     }
     /**
      * Represents options for "updateMany" operation
@@ -163,11 +163,11 @@ export declare abstract class SqbCollectionService<T extends object = object> ex
     /**
      * Finds a record by ID.
      *
-     * @param {SQBAdapter.Id} id - The ID of the record.
+     * @param {SQBAdapter.IdOrIds} id - The ID of the record.
      * @param {SqbCollectionService.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: SQBAdapter.Id, options?: SqbCollectionService.FindOneOptions): Promise<PartialDTO<T> | undefined>;
+    findById(id: SQBAdapter.IdOrIds, options?: SqbCollectionService.FindOneOptions): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds a record in the collection that matches the specified options.
      *
@@ -196,13 +196,13 @@ export declare abstract class SqbCollectionService<T extends object = object> ex
     /**
      * Retrieves a records from the collection by its ID. Throws error if not found.
      *
-     * @param {SQBAdapter.Id} id - The ID of the document to retrieve.
+     * @param {SQBAdapter.IdOrIds} id - The ID of the document to retrieve.
      * @param {SqbCollectionService.FindOneOptions} [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: SQBAdapter.Id, options?: SqbCollectionService.FindOneOptions): Promise<PartialDTO<T>>;
+    get(id: SQBAdapter.IdOrIds, options?: SqbCollectionService.FindOneOptions): Promise<PartialDTO<T>>;
     /**
      * Updates a record with the given id in the collection.
      *
@@ -221,7 +221,7 @@ export declare abstract class SqbCollectionService<T extends object = object> ex
      * @param {SqbCollectionService.UpdateOptions} options - The options for updating the document.
      * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
      */
-    updateOnly(id: SQBAdapter.Id, input: PatchDTO<T>, options?: SqbCollectionService.UpdateOnlyOptions): Promise<number>;
+    updateOnly(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: SqbCollectionService.UpdateOnlyOptions): Promise<number>;
     /**
      * Updates multiple records in the collection based on the specified input and options.
      *

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

@@ -1,8 +1,8 @@
-import { PartialDTO, PatchDTO, Type } from 'ts-gems';
-import { IsObject } from 'valgen';
 import { ComplexType } from '@opra/common';
 import { ServiceBase } from '@opra/core';
 import { EntityMetadata, Repository, SqbClient, SqbConnection } from '@sqb/connect';
+import { PartialDTO, PatchDTO, RequiredSome, StrictOmit, Type } from 'ts-gems';
+import { IsObject } from 'valgen';
 import { SQBAdapter } from './sqb-adapter.js';
 /**
  * @namespace SqbEntityService
@@ -10,10 +10,10 @@ import { SQBAdapter } from './sqb-adapter.js';
 export declare namespace SqbEntityService {
     interface Options {
         db?: SqbEntityService<any>['db'];
-        resourceName?: SqbEntityService<any>['$resourceName'];
-        onError?: SqbEntityService<any>['$onError'];
-        commonFilter?: SqbEntityService<any>['$commonFilter'];
-        interceptor?: SqbEntityService<any>['$interceptor'];
+        resourceName?: SqbEntityService<any>['resourceName'];
+        onError?: SqbEntityService<any>['onError'];
+        commonFilter?: SqbEntityService<any>['commonFilter'];
+        interceptor?: SqbEntityService<any>['interceptor'];
     }
     type CrudOp = 'create' | 'read' | 'update' | 'delete';
     interface CommandInfo {
@@ -85,14 +85,7 @@ export declare namespace SqbEntityService {
      *
      * @interface
      */
-    interface UpdateOptions extends Repository.UpdateOptions {
-    }
-    /**
-     * Represents options for "updateOnly" operation
-     *
-     * @interface
-     */
-    interface UpdateOnlyOptions extends Repository.UpdateOptions {
+    interface UpdateOneOptions extends Repository.UpdateOptions {
     }
     /**
      * Represents options for "updateMany" operation
@@ -101,6 +94,55 @@ export declare namespace SqbEntityService {
      */
     interface UpdateManyOptions extends Repository.UpdateManyOptions {
     }
+    interface CreateCommand extends StrictOmit<RequiredSome<CommandInfo, 'input'>, 'documentId'> {
+        crud: 'create';
+        options?: CreateOptions;
+    }
+    interface CountCommand extends StrictOmit<CommandInfo, 'documentId' | 'input'> {
+        crud: 'read';
+        options?: CountOptions;
+    }
+    interface DeleteOneCommand extends StrictOmit<CommandInfo, 'input'> {
+        crud: 'delete';
+        options?: DeleteOptions;
+    }
+    interface DeleteManyCommand extends StrictOmit<CommandInfo, 'input'> {
+        crud: 'delete';
+        options?: DeleteManyOptions;
+    }
+    interface ExistsCommand extends StrictOmit<CommandInfo, 'input'> {
+        crud: 'read';
+        options?: ExistsOptions;
+    }
+    interface FindOneCommand extends StrictOmit<CommandInfo, 'input'> {
+        crud: 'read';
+        options?: FindOneOptions;
+    }
+    interface FindManyCommand extends StrictOmit<CommandInfo, 'input'> {
+        crud: 'read';
+        options?: FindManyOptions;
+    }
+    interface UpdateOneCommand<T> extends CommandInfo {
+        crud: 'update';
+        input: PatchDTO<T>;
+        options?: UpdateOneOptions;
+    }
+    interface UpdateManyCommand<T> extends CommandInfo {
+        crud: 'update';
+        input: PatchDTO<T>;
+        options?: UpdateManyOptions;
+    }
+}
+export interface SqbEntityService {
+    /**
+     * Interceptor function for handling callback execution with provided arguments.
+     * @type Function
+     * @param next - The callback function to be intercepted.
+     * @param {SqbEntityService.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: SqbEntityService.CommandInfo, _this: any): Promise<any>;
 }
 /**
  * @class SqbEntityService
@@ -111,8 +153,8 @@ export declare class SqbEntityService<T extends object = object> extends Service
     protected _dataType: ComplexType;
     protected _dataTypeClass?: Type;
     protected _entityMetadata?: EntityMetadata;
-    protected _encoders: Record<string, IsObject.Validator<T>>;
-    protected _decoder?: IsObject.Validator<T>;
+    protected _inputCodecs: Record<string, IsObject.Validator<T>>;
+    protected _outputCodecs: Record<string, IsObject.Validator<T>>;
     /**
      * Represents a SqbClient or SqbConnection object
      */
@@ -121,29 +163,20 @@ export declare class SqbEntityService<T extends object = object> extends Service
      * Represents the name of a resource.
      * @type {string}
      */
-    $resourceName?: string | ((_this: any) => string);
+    resourceName?: string | ((_this: any) => string);
     /**
      * Represents a common filter function for a service.
      *
      * @type {SqbEntityService.Filter | Function}
      */
-    $commonFilter?: SQBAdapter.FilterInput | ((args: SqbEntityService.CommandInfo, _this: this) => SQBAdapter.FilterInput | Promise<SQBAdapter.FilterInput> | undefined);
-    /**
-     * Interceptor function for handling callback execution with provided arguments.
-     *
-     * @param {Function} callback - The callback function to be intercepted.
-     * @param {SqbEntityService.CommandInfo} info - The arguments object containing the following properties:
-     * @param {SqbEntityService} _this - The reference to the current object.
-     * @returns - The promise that resolves to the result of the callback execution.
-     */
-    $interceptor?: (callback: () => any, info: SqbEntityService.CommandInfo, _this: any) => Promise<any>;
+    commonFilter?: SQBAdapter.FilterInput | ((args: SqbEntityService.CommandInfo, _this: this) => SQBAdapter.FilterInput | Promise<SQBAdapter.FilterInput> | undefined);
     /**
      * Callback function for handling errors.
      *
      * @param {unknown} error - The error object.
      * @param {SqbEntityService} _this - The context object.
      */
-    $onError?: (error: unknown, _this: any) => void | Promise<void>;
+    onError?: (error: unknown, _this: any) => void | Promise<void>;
     /**
      * Constructs a new instance
      *
@@ -178,122 +211,110 @@ export declare class SqbEntityService<T extends object = object> extends Service
      */
     getResourceName(): string;
     /**
-     * Retrieves the encoder for the specified operation.
+     * Retrieves the codec for the specified operation.
      *
      * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
      */
-    getEncoder(operation: 'create' | 'update'): IsObject.Validator<T>;
+    getInputCodec(operation: string): IsObject.Validator<T>;
     /**
-     * Retrieves the decoder.
+     * Retrieves the codec.
      */
-    getDecoder(): IsObject.Validator<T>;
+    getOutputCodec(operation: string): IsObject.Validator<T>;
     /**
      * Insert a new record into database
      *
-     * @param {PartialDTO<T>} input - The input data
-     * @param {SqbEntityService.CreateOptions} [options] - The options object
-     * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created resource
-     * @throws {InternalServerError} if an unknown error occurs while creating the resource
+     * @param command
+     * @returns - A promise that resolves to the created resource
      * @protected
      */
-    protected _create(input: PartialDTO<T>, options?: SqbEntityService.CreateOptions): Promise<PartialDTO<T>>;
+    protected _create(command: SqbEntityService.CreateCommand): Promise<PartialDTO<T>>;
     /**
      * Returns the count of records based on the provided options
      *
-     * @param {SqbEntityService.CountOptions} options - The options for the count operation.
-     * @return {Promise<number>} - A promise that resolves to the count of records
+     * @param command
+     * @return - A promise that resolves to the count of records
      * @protected
      */
-    protected _count(options?: SqbEntityService.CountOptions): Promise<number>;
+    protected _count(command: SqbEntityService.CountCommand): Promise<number>;
     /**
      * Deletes a record from the collection.
      *
-     * @param {SQBAdapter.IdOrIds} id - The ID of the document to delete.
-     * @param {SqbEntityService.DeleteOptions} [options] - Optional delete options.
-     * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
+     * @param command
+     * @return - A Promise that resolves to the number of documents deleted.
      * @protected
      */
-    protected _delete(id: SQBAdapter.IdOrIds, options?: SqbEntityService.DeleteOptions): Promise<number>;
+    protected _delete(command: SqbEntityService.DeleteOneCommand): Promise<number>;
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {SqbEntityService.DeleteManyOptions} options - The options for the delete operation.
-     * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
+     * @param command
+     * @return - A promise that resolves to the number of documents deleted.
      * @protected
      */
-    protected _deleteMany(options?: SqbEntityService.DeleteManyOptions): Promise<number>;
+    protected _deleteMany(command: SqbEntityService.DeleteManyCommand): Promise<number>;
     /**
      * Checks if a record with the given id exists.
      *
-     * @param {SQBAdapter.IdOrIds} id - The id of the object to check.
-     * @param {SqbEntityService.ExistsOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the record exists or not.
+     * @param command
      * @protected
      */
-    protected _exists(id: SQBAdapter.IdOrIds, options?: SqbEntityService.ExistsOptions): Promise<boolean>;
+    protected _exists(command: SqbEntityService.ExistsCommand): Promise<boolean>;
     /**
      * Checks if a record with the given arguments exists.
      *
-     * @param {SqbEntityService.ExistsOneOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the record exists or not.
+     * @param command
+     * @return - A Promise that resolves to a boolean indicating whether the record exists or not.
      * @protected
      */
-    protected _existsOne(options?: SqbEntityService.ExistsOptions): Promise<boolean>;
+    protected _existsOne(command: SqbEntityService.ExistsCommand): Promise<boolean>;
     /**
      * Finds a record by ID.
      *
-     * @param {SQBAdapter.Id} id - The ID of the record.
-     * @param {SqbEntityService.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 command
+     * @return - A promise resolving to the found document, or undefined if not found.
      * @protected
      */
-    protected _findById(id: SQBAdapter.Id, options?: SqbEntityService.FindOneOptions): Promise<PartialDTO<T> | undefined>;
+    protected _findById(command: SqbEntityService.FindOneCommand): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds a record in the collection that matches the specified options.
      *
-     * @param {SqbEntityService.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 command
+     * @return - A promise that resolves with the found document or undefined if no document is found.
      * @protected
      */
-    protected _findOne(options?: SqbEntityService.FindOneOptions): Promise<PartialDTO<T> | undefined>;
+    protected _findOne(command: SqbEntityService.FindOneCommand): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds multiple records in collection.
      *
-     * @param {SqbEntityService.FindManyOptions} [options] - The options for the find operation.
-     * @return A Promise that resolves to an array of partial outputs of type T.
+     * @param command
+     * @return - A Promise that resolves to an array of partial outputs of type T.
      * @protected
      */
-    protected _findMany(options?: SqbEntityService.FindManyOptions): Promise<PartialDTO<T>[]>;
+    protected _findMany(command: SqbEntityService.FindManyCommand): Promise<PartialDTO<T>[]>;
     /**
      * Updates a record with the given id in the collection.
      *
-     * @param {SQBAdapter.IdOrIds} id - The id of the document to update.
-     * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
-     * @param {SqbEntityService.UpdateOptions} [options] - The options for the update operation.
-     * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the updated document or
-     * undefined if the document was not found.
+     * @param command
+     * @returns  A promise that resolves to the updated document or undefined if the document was not found.
      * @protected
      */
-    protected _update(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: SqbEntityService.UpdateOptions): Promise<PartialDTO<T> | undefined>;
+    protected _update(command: SqbEntityService.UpdateOneCommand<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Updates a record in the collection with the specified ID and returns updated record count
      *
-     * @param {any} id - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial input data to update the document with.
-     * @param {SqbEntityService.UpdateOptions} options - The options for updating the document.
-     * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
+     * @param command
+     * @returns - A promise that resolves to the number of documents modified.
      * @protected
      */
-    protected _updateOnly(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: SqbEntityService.UpdateOptions): Promise<boolean>;
+    protected _updateOnly(command: SqbEntityService.UpdateOneCommand<T>): Promise<boolean>;
     /**
      * Updates multiple records in the collection based on the specified input and options.
      *
-     * @param {PatchDTO<T>} input - The partial input to update the documents with.
-     * @param {SqbEntityService.UpdateManyOptions} options - The options for updating the documents.
-     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     * @param command
+     * @return - A promise that resolves to the number of documents matched and modified.
      * @protected
      */
-    protected _updateMany(input: PatchDTO<T>, options?: SqbEntityService.UpdateManyOptions): Promise<number>;
+    protected _updateMany(command: SqbEntityService.UpdateOneCommand<T>): Promise<number>;
     /**
      * Acquires a connection and performs Repository.create operation
      *
@@ -411,12 +432,5 @@ export declare class SqbEntityService<T extends object = object> extends Service
         input?: Object;
         options?: Record<string, any>;
     }): SQBAdapter.FilterInput | Promise<SQBAdapter.FilterInput> | undefined;
-    protected _intercept(callback: (...args: any[]) => any, args: {
-        crud: SqbEntityService.CrudOp;
-        method: string;
-        byId: boolean;
-        documentId?: any;
-        input?: Object;
-        options?: Record<string, any>;
-    }): Promise<any>;
+    protected _executeCommand(command: SqbEntityService.CommandInfo, commandFn: () => any): Promise<any>;
 }

package/types/sqb-singleton-service.d.ts

@@ -1,5 +1,5 @@
-import { PartialDTO, PatchDTO, Type } from 'ts-gems';
 import { ColumnFieldMetadata } from '@sqb/connect';
+import { PartialDTO, PatchDTO, Type } from 'ts-gems';
 import { SQBAdapter } from './sqb-adapter.js';
 import { SqbEntityService } from './sqb-entity-service.js';
 /**
@@ -42,14 +42,14 @@ export declare namespace SqbSingletonService {
      *
      * @interface
      */
-    interface UpdateOptions extends SqbEntityService.UpdateOptions {
+    interface UpdateOptions extends SqbEntityService.UpdateOneOptions {
     }
     /**
      * Represents options for "updateOnly" operation
      *
      * @interface
      */
-    interface UpdateOnlyOptions extends SqbEntityService.UpdateOptions {
+    interface UpdateOnlyOptions extends SqbEntityService.UpdateOneOptions {
     }
 }
 /**
@@ -60,9 +60,9 @@ export declare abstract class SqbSingletonService<T extends object = object> ext
     protected _primaryKeyFields?: ColumnFieldMetadata[];
     /**
      * Represents a unique identifier for singleton record
-     * @property {SQBAdapter.Id}
+     * @property {SQBAdapter.IdOrIds}
      */
-    id: SQBAdapter.Id;
+    id: SQBAdapter.IdOrIds;
     /**
      * Constructs a new instance
      *