@opra/sqb 1.26.3 → 1.26.4

package/README.md

@@ -1,3 +1,26 @@
 # @opra/sqb
 
-OPRA SQB 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/sqb
+[npm-url]: https://npmjs.org/package/@opra/sqb
+[downloads-image]: https://img.shields.io/npm/dm/@opra/sqb.svg
+[downloads-url]: https://npmjs.org/package/@opra/sqb
+[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,10 +1,9 @@
 import '@opra/core';
 import type { SQBAdapter } from '../sqb-adapter.js';
 /**
- * Prepare the SQB filter based on the provided filters and options.
+ * Prepares the SQB filter based on the provided filters and options.
  *
- * @param {SQBAdapter.FilterInput|SQBAdapter.FilterInput[]} filters - The filter(s) to be applied.
- *
- * @returns {Expression} - The prepared SQB Expression.
+ * @param filters - The filter(s) to be applied. Can be a single filter or an array of filters.
+ * @returns The prepared SQB Expression, or `undefined` if no filters are provided.
  */
 export default function prepareFilter(filters: SQBAdapter.FilterInput | SQBAdapter.FilterInput[]): any;

package/adapter-utils/prepare-filter.js

@@ -3,11 +3,10 @@ import { OpraFilter } from '@opra/common';
 import * as sqb from '@sqb/builder';
 import { vg } from 'valgen';
 /**
- * Prepare the SQB filter based on the provided filters and options.
+ * Prepares the SQB filter based on the provided filters and options.
  *
- * @param {SQBAdapter.FilterInput|SQBAdapter.FilterInput[]} filters - The filter(s) to be applied.
- *
- * @returns {Expression} - The prepared SQB Expression.
+ * @param filters - The filter(s) to be applied. Can be a single filter or an array of filters.
+ * @returns The prepared SQB Expression, or `undefined` if no filters are provided.
  */
 export default function prepareFilter(filters) {
     const filtersArray = Array.isArray(filters) ? filters : [filters];

package/augmentation/datatype-factory.augmentation.js

@@ -13,7 +13,7 @@ DataTypeFactory._prepareComplexTypeArgs = async function (context, owner, initAr
             const sqbField = sqbMeta && EntityMetadata.getField(sqbMeta, fieldName);
             if (!sqbField)
                 continue;
-            /** Copy type information from sqb metadata to opra */
+            /* Copy type information from sqb metadata to opra */
             if (!fieldSchema.type || fieldSchema.type === Object) {
                 if (isAssociationField(sqbField)) {
                     if (!fieldSchema.type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/sqb",
-  "version": "1.26.3",
+  "version": "1.26.4",
   "description": "Opra SQB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -10,8 +10,8 @@
     "valgen": "^6.0.3"
   },
   "peerDependencies": {
-    "@opra/core": "^1.26.3",
-    "@opra/http": "^1.26.3",
+    "@opra/core": "^1.26.4",
+    "@opra/http": "^1.26.4",
     "@sqb/builder": ">4.0.0 <5",
     "@sqb/connect": ">4.0.0 <5"
   },

package/sqb-adapter.d.ts

@@ -2,20 +2,60 @@ import type { OpraFilter } from '@opra/common';
 import type { ExecutionContext } from '@opra/core';
 import { type Repository } from '@sqb/connect';
 import _prepareFilter from './adapter-utils/prepare-filter.js';
+/**
+ * SQBAdapter namespace provides types and utility functions for integrating SQB with Opra.
+ */
 export declare namespace SQBAdapter {
+    /**
+     * Represents a single identifier type.
+     */
     type Id = string | number | boolean | Date;
+    /**
+     * Represents a single identifier or a composite key.
+     */
     type IdOrIds = Id | Record<string, Id>;
+    /**
+     * Represents the input for a filter, which can be an Opra filter expression,
+     * a SQB filter object, a string, or undefined.
+     */
     type FilterInput = OpraFilter.Expression | Repository.FindManyOptions['filter'] | string | undefined;
     /**
-     * @deprecated Use prepareFilter instead
+     * Parses the given filter input into a SQB filter expression.
+     * @deprecated Use {@link prepareFilter} instead.
      */
     const parseFilter: typeof _prepareFilter;
+    /**
+     * Prepares the given filter input into a SQB filter expression.
+     */
     const prepareFilter: typeof _prepareFilter;
+    /**
+     * Represents a request that has been transformed for SQB operations.
+     */
     interface TransformedRequest {
+        /**
+         * The operation method name.
+         */
         method: 'create' | 'delete' | 'deleteMany' | 'get' | 'replace' | 'findMany' | 'update' | 'updateMany';
+        /**
+         * The primary key for the operation, if applicable.
+         */
         key?: any;
+        /**
+         * The data object for create or update operations.
+         */
         data?: any;
+        /**
+         * Additional options for the SQB operation.
+         */
         options: any;
     }
+    /**
+     * Parses an execution context and transforms it into a SQB-compatible request.
+     *
+     * @param context - The execution context to parse.
+     * @returns A promise that resolves to the transformed request.
+     * @throws {TypeError} If the context transport is not 'http'.
+     * @throws {Error} If the operation is not compatible with SQB Adapter.
+     */
     function parseRequest(context: ExecutionContext): Promise<TransformedRequest>;
 }

package/sqb-adapter.js

@@ -1,12 +1,27 @@
 import { EntityMetadata } from '@sqb/connect';
 import _prepareFilter from './adapter-utils/prepare-filter.js';
+/**
+ * SQBAdapter namespace provides types and utility functions for integrating SQB with Opra.
+ */
 export var SQBAdapter;
 (function (SQBAdapter) {
     /**
-     * @deprecated Use prepareFilter instead
+     * Parses the given filter input into a SQB filter expression.
+     * @deprecated Use {@link prepareFilter} instead.
      */
     SQBAdapter.parseFilter = _prepareFilter;
+    /**
+     * Prepares the given filter input into a SQB filter expression.
+     */
     SQBAdapter.prepareFilter = _prepareFilter;
+    /**
+     * Parses an execution context and transforms it into a SQB-compatible request.
+     *
+     * @param context - The execution context to parse.
+     * @returns A promise that resolves to the transformed request.
+     * @throws {TypeError} If the context transport is not 'http'.
+     * @throws {Error} If the operation is not compatible with SQB Adapter.
+     */
     async function parseRequest(context) {
         if (context.transport !== 'http') {
             throw new TypeError('SQBAdapter can parse only HttpContext');
@@ -37,7 +52,7 @@ export var SQBAdapter;
                         controller.parameters.find(p => p.keyParam);
                     const key = keyParam && ctx.pathParams[String(keyParam.name)];
                     const options = {
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
+                        filter: SQBAdapter.prepareFilter(ctx.queryParams.filter),
                     };
                     return {
                         method: 'delete',
@@ -47,14 +62,14 @@ export var SQBAdapter;
                 }
                 case 'Entity.DeleteMany': {
                     const options = {
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
+                        filter: SQBAdapter.prepareFilter(ctx.queryParams.filter),
                     };
                     return { method: 'deleteMany', options };
                 }
                 case 'Entity.FindMany': {
                     const options = {
                         count: ctx.queryParams.count,
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
+                        filter: SQBAdapter.prepareFilter(ctx.queryParams.filter),
                         projection: ctx.queryParams.projection ||
                             __oprDef.compositionOptions.defaultProjection,
                         limit: ctx.queryParams.limit || __oprDef.compositionOptions.defaultLimit,
@@ -96,7 +111,7 @@ export var SQBAdapter;
                     const key = keyParam && ctx.pathParams[String(keyParam.name)];
                     const options = {
                         projection: ctx.queryParams.projection,
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
+                        filter: SQBAdapter.prepareFilter(ctx.queryParams.filter),
                     };
                     return {
                         method: 'update',
@@ -108,7 +123,7 @@ export var SQBAdapter;
                 case 'Entity.UpdateMany': {
                     const data = await ctx.getBody();
                     const options = {
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
+                        filter: SQBAdapter.prepareFilter(ctx.queryParams.filter),
                     };
                     return {
                         method: 'updateMany',

package/sqb-collection-service.d.ts

@@ -1,243 +1,225 @@
-import type { PartialDTO, PatchDTO, RequiredSome, Type } from 'ts-gems';
+import type { DTO, PartialDTO, PatchDTO, RequiredSome, Type } from 'ts-gems';
 import { SQBAdapter } from './sqb-adapter.js';
 import { SqbEntityService } from './sqb-entity-service.js';
 /**
- * @namespace SqbCollectionService
+ * Options for SqbCollectionService.
  */
 export declare namespace SqbCollectionService {
+    /**
+     * Configuration options for SqbCollectionService.
+     */
     interface Options extends SqbEntityService.Options {
+        /**
+         * Default maximum number of records returned by `findMany`.
+         */
         defaultLimit?: SqbCollectionService<any>['defaultLimit'];
+        /**
+         * Optional interceptor for the service operations.
+         */
         interceptor?: SqbCollectionService<any>['interceptor'];
     }
+}
+/**
+ * Service for managing a collection of entities backed by an SQB data source.
+ *
+ * @typeParam T - The entity type managed by this service
+ */
+export declare class SqbCollectionService<T extends object = object> extends SqbEntityService<T> {
     /**
-     * Represents options for "create" operation
-     *
-     * @interface
+     * Default maximum number of records returned by `findMany`.
      */
-    interface CreateOptions extends SqbEntityService.CreateOptions {
-    }
+    defaultLimit: number;
     /**
-     * Represents options for "count" operation
+     * Constructs a new instance.
      *
-     * @interface
+     * @param dataType - The data type of the collection elements.
+     * @param options - Options for the collection service.
      */
-    interface CountOptions extends SqbEntityService.CountOptions {
-    }
+    constructor(dataType: Type<T> | string, options?: SqbCollectionService.Options);
     /**
-     * Represents options for "delete" operation
+     * Asserts that a resource with the given ID exists.
+     * Throws {@link ResourceNotAvailableError} if it does not.
      *
-     * @interface
+     * @param id - The ID of the resource to check.
+     * @param options - Optional existence check options.
+     * @throws {@link ResourceNotAvailableError} If the resource does not exist.
      */
-    interface DeleteOptions extends SqbEntityService.DeleteOptions {
-    }
+    assert(id: SQBAdapter.IdOrIds, options?: SqbEntityService.ExistsOptions): Promise<void>;
     /**
-     * Represents options for "deleteMany" operation
+     * Creates a new resource and returns it with the requested projection.
      *
-     * @interface
+     * @param input - The input data for the new resource.
+     * @param options - Options including a required `projection`.
+     * @returns The created resource as a partial DTO.
      */
-    interface DeleteManyOptions extends SqbEntityService.DeleteManyOptions {
-    }
+    create(input: PartialDTO<T>, options: RequiredSome<SqbEntityService.CreateOptions, 'projection'>): Promise<PartialDTO<T>>;
     /**
-     * Represents options for "exists" operation
+     * Creates a new resource and returns the full DTO.
      *
-     * @interface
+     * @param input - The input data for the new resource.
+     * @param options - Optional create options.
+     * @returns The created resource as a full DTO.
      */
-    interface ExistsOptions extends SqbEntityService.ExistsOptions {
-    }
+    create(input: PartialDTO<T>, options?: SqbEntityService.CreateOptions): Promise<T>;
     /**
-     * Represents options for "existsOne" operation
+     * Creates a new resource without returning it.
      *
-     * @interface
+     * @param input - The input data for the new resource.
+     * @param options - Optional create options.
      */
-    interface ExistsOneOptions extends SqbEntityService.ExistsOptions {
-    }
+    createOnly(input: PartialDTO<T>, options?: SqbEntityService.CreateOptions): Promise<void>;
     /**
-     * Represents options for "findOne" operation
+     * Returns the number of records matching the given options.
      *
-     * @interface
+     * @param options - Options for the count operation.
+     * @returns The number of matching records.
      */
-    interface FindOneOptions extends SqbEntityService.FindOneOptions {
-    }
+    count(options?: SqbEntityService.CountOptions): Promise<number>;
     /**
-     * Represents options for "findMany" operation
+     * Deletes the record with the given ID.
      *
-     * @interface
+     * @param id - The ID of the record to delete.
+     * @param options - Optional delete options.
+     * @returns The number of records deleted.
      */
-    interface FindManyOptions extends SqbEntityService.FindManyOptions {
-    }
+    delete(id: SQBAdapter.IdOrIds, options?: SqbEntityService.DeleteOptions): Promise<number>;
     /**
-     * Represents options for "update" operation
+     * Deletes all records matching the given options.
      *
-     * @interface
+     * @param options - Options including filter criteria.
+     * @returns The number of records deleted.
      */
-    interface UpdateOptions extends SqbEntityService.UpdateOneOptions {
-    }
+    deleteMany(options?: SqbEntityService.DeleteManyOptions): Promise<number>;
     /**
-     * Represents options for "updateOnly" operation
+     * Checks whether a record with the given ID exists.
      *
-     * @interface
+     * @param id - The ID to check.
+     * @param options - Optional query options.
+     * @returns `true` if the record exists, `false` otherwise.
      */
-    interface UpdateOnlyOptions extends SqbEntityService.UpdateOneOptions {
-    }
+    exists(id: SQBAdapter.IdOrIds, options?: SqbEntityService.ExistsOptions): Promise<boolean>;
     /**
-     * Represents options for "updateMany" operation
+     * Checks whether any record matching the given options exists.
      *
-     * @interface
+     * @param options - Optional query options.
+     * @returns `true` if at least one matching record exists, `false` otherwise.
      */
-    interface UpdateManyOptions extends SqbEntityService.UpdateManyOptions {
-    }
-}
-/**
- * @class SqbCollectionService
- * @template T - The data type class type of the resource
- */
-export declare class SqbCollectionService<T extends object = object> extends SqbEntityService<T> {
-    /**
-     * Represents default limit for findMany operation
-     */
-    defaultLimit: number;
-    /**
-     * Constructs a new instance
-     *
-     * @param {Type | string} dataType - The data type of the array elements.
-     * @param {SqbCollectionService.Options} [options] - The options for the array service.
-     * @constructor
-     */
-    constructor(dataType: Type<T> | string, options?: SqbCollectionService.Options);
-    /**
-     * Asserts the existence of a resource with the given ID.
-     * Throws a ResourceNotFoundError if the resource does not exist.
-     *
-     * @param {SQBAdapter.IdOrIds} id - The ID of the resource to assert.
-     * @param {SqbCollectionService.ExistsOptions} [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: SQBAdapter.IdOrIds, options?: SqbCollectionService.ExistsOptions): Promise<void>;
+    existsOne(options?: SqbEntityService.ExistsOptions): Promise<boolean>;
     /**
-     * Creates a new resource
+     * Finds a record by ID and returns it with the requested projection.
      *
-     * @param {PartialDTO<T>} input - The input data
-     * @param {SqbCollectionService.CreateOptions} [options] - The options object
-     * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created resource
-     * @throws {Error} if an unknown error occurs while creating the resource
+     * @param id - The ID of the record.
+     * @param options - Options including a required `projection`.
+     * @returns The found record as a partial DTO, or `undefined` if not found.
      */
-    create(input: PartialDTO<T>, options: RequiredSome<SqbCollectionService.CreateOptions, 'projection'>): Promise<PartialDTO<T>>;
-    create(input: PartialDTO<T>, options?: SqbCollectionService.CreateOptions): Promise<T>;
+    findById(id: SQBAdapter.IdOrIds, options?: RequiredSome<SqbEntityService.FindOneOptions, 'projection'>): Promise<PartialDTO<T> | undefined>;
     /**
-     * Creates a new resource
+     * Finds a record by ID and returns the whole DTO.
      *
-     * @param {PartialDTO<T>} input - The input data
-     * @param {SqbCollectionService.CreateOptions} [options] - The options object
-     * @returns {Promise<void>} A promise that resolves create operation result
-     * @throws {Error} if an unknown error occurs while creating the resource
+     * @param id - The ID of the record.
+     * @param options - Optional query options.
+     * @returns The found record, or `undefined` if not found.
      */
-    createOnly(input: PartialDTO<T>, options?: SqbCollectionService.CreateOptions): Promise<void>;
+    findById(id: SQBAdapter.IdOrIds, options?: SqbEntityService.FindOneOptions): Promise<DTO<T> | undefined>;
     /**
-     * Returns the count of records based on the provided options
+     * Finds the first record matching the given options and returns it with the requested projection.
      *
-     * @param {SqbCollectionService.CountOptions} options - The options for the count operation.
-     * @return {Promise<number>} - A promise that resolves to the count of records
+     * @param options - Options including a required `projection`.
+     * @returns A promise that resolves to the found record as a partial DTO, or `undefined` if not found.
      */
-    count(options?: SqbCollectionService.CountOptions): Promise<number>;
+    findOne(options: RequiredSome<SqbEntityService.FindOneOptions, 'projection'>): Promise<PartialDTO<T> | undefined>;
     /**
-     * Deletes a record from the collection.
+     * Finds the first record matching the given options and returns the whole DTO.
      *
-     * @param {SQBAdapter.IdOrIds} id - The ID of the document to delete.
-     * @param {SqbCollectionService.DeleteOptions} [options] - Optional delete options.
-     * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
+     * @param options - Optional query options.
+     * @returns A promise that resolves to the found record, or `undefined` if not found.
      */
-    delete(id: SQBAdapter.IdOrIds, options?: SqbCollectionService.DeleteOptions): Promise<number>;
+    findOne(options?: SqbEntityService.FindOneOptions): Promise<DTO<T> | undefined>;
     /**
-     * Deletes multiple documents from the collection that meet the specified filter criteria.
+     * Finds multiple records matching the given options and returns partial DTOs.
      *
-     * @param {SqbCollectionService.DeleteManyOptions} options - The options for the delete operation.
-     * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
+     * @param options - Options including a required `projection`.
+     * @returns An array of matching records as partial DTOs.
      */
-    deleteMany(options?: SqbCollectionService.DeleteManyOptions): Promise<number>;
+    findMany(options?: RequiredSome<SqbEntityService.FindManyOptions, 'projection'>): Promise<PartialDTO<T>[]>;
     /**
-     * Checks if a record with the given id exists.
+     * Finds multiple records matching the given options and returns whole DTOs.
      *
-     * @param {SQBAdapter.IdOrIds} id - The id of the object to check.
-     * @param {SqbCollectionService.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 options - Optional query options.
+     * @returns An array of matching records as full DTOs.
      */
-    exists(id: SQBAdapter.IdOrIds, options?: SqbCollectionService.ExistsOptions): Promise<boolean>;
+    findMany(options?: SqbEntityService.FindManyOptions): Promise<DTO<T>[]>;
     /**
-     * Checks if a record with the given arguments exists.
+     * Finds multiple records and returns them together with the total count of matches.
      *
-     * @param {SqbCollectionService.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 options - Options including a required `projection`.
+     * @returns An object with `items` (partial DTOs) and `count` (total matches).
      */
-    existsOne(options?: SqbCollectionService.ExistsOneOptions): Promise<boolean>;
-    /**
-     * Finds a record by ID.
-     *
-     * @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.IdOrIds, options?: SqbCollectionService.FindOneOptions): Promise<PartialDTO<T> | undefined>;
+    findManyWithCount(options?: RequiredSome<SqbEntityService.FindManyOptions, 'projection'>): Promise<{
+        count: number;
+        items: PartialDTO<T>[];
+    }>;
     /**
-     * Finds a record in the collection that matches the specified options.
+     * Finds multiple records and returns them together with the total count of matches.
      *
-     * @param {SqbCollectionService.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 - Optional query options.
+     * @returns An object with `items` (full DTOs) and `count` (total matches).
      */
-    findOne(options?: SqbCollectionService.FindOneOptions): Promise<PartialDTO<T> | undefined>;
+    findManyWithCount(options?: SqbEntityService.FindManyOptions): Promise<{
+        count: number;
+        items: DTO<T>[];
+    }>;
     /**
-     * Finds multiple records in collection.
+     * Retrieves a record by ID. Throws if the record does not exist.
      *
-     * @param {SqbCollectionService.FindManyOptions} options - The options for the find operation.
-     * @return A Promise that resolves to an array of partial outputs of type T.
+     * @param id - The ID of the record to retrieve.
+     * @param options - Options including a required `projection`.
+     * @returns The record as a partial DTO.
+     * @throws {@link ResourceNotAvailableError} If the record does not exist.
      */
-    findMany(options?: SqbCollectionService.FindManyOptions): Promise<PartialDTO<T>[]>;
+    get(id: SQBAdapter.IdOrIds, options?: RequiredSome<SqbEntityService.FindOneOptions, 'projection'>): Promise<PartialDTO<T>>;
     /**
-     * Finds multiple records in the collection and returns both records (max limit)
-     * and total count that matched the given criteria
+     * Retrieves a record by ID. Throws if the record does not exist.
      *
-     * @param {SqbCollectionService.FindManyOptions} options - The options for the find operation.
-     * @return A Promise that resolves to an array of partial outputs of type T and total count.
+     * @param id - The ID of the record to retrieve.
+     * @param options - Optional query options.
+     * @returns The record as a full DTO.
+     * @throws {@link ResourceNotAvailableError} If the record does not exist.
      */
-    findManyWithCount(options?: SqbCollectionService.FindManyOptions): Promise<{
-        count: number;
-        items: PartialDTO<T>[];
-    }>;
+    get(id: SQBAdapter.IdOrIds, options?: SqbEntityService.FindOneOptions): Promise<DTO<T>>;
     /**
-     * Retrieves a records from the collection by its ID. Throws error if not found.
+     * Updates a record by ID and returns the updated record with the requested projection.
      *
-     * @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.
+     * @param id - The ID of the record to update.
+     * @param input - The fields to update.
+     * @param options - Options including a required `projection`.
+     * @returns The updated record as a partial DTO, or `undefined` if not found.
      */
-    get(id: SQBAdapter.IdOrIds, options?: SqbCollectionService.FindOneOptions): Promise<PartialDTO<T>>;
+    update(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: RequiredSome<SqbEntityService.UpdateOneOptions, 'projection'>): Promise<PartialDTO<T> | undefined>;
     /**
-     * Updates a record with the given id in the collection.
+     * Updates a record by ID and returns the full updated DTO.
      *
-     * @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 {SqbCollectionService.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 id - The ID of the record to update.
+     * @param input - The fields to update.
+     * @param options - Optional update options.
+     * @returns The updated record as a full DTO, or `undefined` if not found.
      */
-    update(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: SqbCollectionService.UpdateOptions): Promise<PartialDTO<T> | undefined>;
+    update(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: SqbEntityService.UpdateOneOptions): Promise<DTO<T> | undefined>;
     /**
-     * Updates a record in the collection with the specified ID and returns updated record count
+     * Updates a record by ID without returning it.
      *
-     * @param {any} id - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial input data to update the document with.
-     * @param {SqbCollectionService.UpdateOptions} options - The options for updating the document.
-     * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
+     * @param id - The ID of the record to update.
+     * @param input - The fields to update.
+     * @param options - Optional update options.
+     * @returns The number of records modified.
      */
-    updateOnly(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: SqbCollectionService.UpdateOnlyOptions): Promise<number>;
+    updateOnly(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: SqbEntityService.UpdateOneOptions): Promise<number>;
     /**
-     * Updates multiple records in the collection based on the specified input and options.
+     * Updates all records matching the given options.
      *
-     * @param {PatchDTO<T>} input - The partial input to update the documents with.
-     * @param {SqbCollectionService.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 fields to update.
+     * @param options - Options including filter criteria.
+     * @returns The number of records modified.
      */
-    updateMany(input: PatchDTO<T>, options?: SqbCollectionService.UpdateManyOptions): Promise<number>;
+    updateMany(input: PatchDTO<T>, options?: SqbEntityService.UpdateManyOptions): Promise<number>;
 }