@opra/sqb 0.33.13 → 1.0.0-alpha.1

package/cjs/{transform-filter.js → adapter-utils/parse-filter.js}

@@ -4,13 +4,39 @@ const tslib_1 = require("tslib");
 require("@opra/core");
 const common_1 = require("@opra/common");
 const sqb = tslib_1.__importStar(require("@sqb/builder"));
-function transformFilter(ast) {
+/**
+ * Prepare 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.
+ */
+function parseFilter(filters) {
+    const filtersArray = Array.isArray(filters) ? filters : [filters];
+    if (!filtersArray.length)
+        return undefined;
+    const arr = [];
+    for (const filter of filtersArray) {
+        if (!filter)
+            continue;
+        let ast;
+        if (typeof filter === 'string')
+            ast = prepareFilterAst(common_1.OpraFilter.parse(filter));
+        else if (filter instanceof common_1.OpraFilter.Expression)
+            ast = prepareFilterAst(filter);
+        else
+            ast = filter;
+        if (ast)
+            arr.push(ast);
+    }
+    return arr.length > 1 ? sqb.And(...arr) : arr[0];
+}
+exports.default = parseFilter;
+function prepareFilterAst(ast) {
     if (!ast)
         return;
-    if (ast instanceof common_1.OpraFilter.QualifiedIdentifier) {
-        return sqb.Field(ast.value);
-    }
-    if (ast instanceof common_1.OpraFilter.NumberLiteral ||
+    if (ast instanceof common_1.OpraFilter.QualifiedIdentifier ||
+        ast instanceof common_1.OpraFilter.NumberLiteral ||
         ast instanceof common_1.OpraFilter.StringLiteral ||
         ast instanceof common_1.OpraFilter.BooleanLiteral ||
         ast instanceof common_1.OpraFilter.NullLiteral ||
@@ -19,22 +45,22 @@ function transformFilter(ast) {
         return ast.value;
     }
     if (ast instanceof common_1.OpraFilter.ArrayExpression) {
-        return ast.items.map(transformFilter);
+        return ast.items.map(prepareFilterAst);
     }
     if (ast instanceof common_1.OpraFilter.NegativeExpression) {
-        return sqb.Not(transformFilter(ast.expression));
+        return sqb.Not(prepareFilterAst(ast.expression));
     }
     if (ast instanceof common_1.OpraFilter.LogicalExpression) {
         if (ast.op === 'or')
-            return sqb.Or(...ast.items.map(transformFilter));
-        return sqb.And(...ast.items.map(transformFilter));
+            return sqb.Or(...ast.items.map(prepareFilterAst));
+        return sqb.And(...ast.items.map(prepareFilterAst));
     }
     if (ast instanceof common_1.OpraFilter.ParenthesizedExpression) {
-        return transformFilter(ast.expression);
+        return prepareFilterAst(ast.expression);
     }
     if (ast instanceof common_1.OpraFilter.ComparisonExpression) {
         const left = String(ast.left);
-        const right = transformFilter(ast.right);
+        const right = prepareFilterAst(ast.right);
         switch (ast.op) {
             case '=':
                 return sqb.Eq(left, right);
@@ -66,4 +92,3 @@ function transformFilter(ast) {
     }
     throw new Error(`${ast.kind} is not implemented yet`);
 }
-exports.default = transformFilter;

package/cjs/augmentation/datatype-factory.augmentation.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@opra/common");
+const connect_1 = require("@sqb/connect");
+var DataTypeFactory = common_1.classes.DataTypeFactory;
+const _prepareComplexTypeArgs = DataTypeFactory._prepareComplexTypeArgs;
+DataTypeFactory._prepareComplexTypeArgs = async function (context, owner, initArgs, metadata) {
+    let sqbMeta;
+    if (initArgs.ctor && metadata.fields && (sqbMeta = connect_1.EntityMetadata.get(initArgs.ctor))) {
+        metadata = (0, common_1.cloneObject)(metadata);
+        for (const [fieldName, fieldSchema] of Object.entries(metadata.fields)) {
+            const sqbField = sqbMeta && connect_1.EntityMetadata.getField(sqbMeta, fieldName);
+            if (!sqbField)
+                continue;
+            /** Copy type information from sqb metadata to opra */
+            if (!fieldSchema.type || fieldSchema.type === Object) {
+                if ((0, connect_1.isAssociationField)(sqbField)) {
+                    if (!fieldSchema.type) {
+                        const trg = await sqbField.association.resolveTarget();
+                        if (trg?.ctor)
+                            fieldSchema.type = trg.ctor;
+                    }
+                }
+                else if ((0, connect_1.isColumnField)(sqbField)) {
+                    fieldSchema.type = sqbField.enum || sqbField.type;
+                }
+            }
+            if ((0, connect_1.isColumnField)(sqbField)) {
+                const hasNoType = !fieldSchema.type || fieldSchema.type === Object;
+                switch (sqbField.dataType) {
+                    case connect_1.DataType.INTEGER:
+                    case connect_1.DataType.SMALLINT:
+                        if (hasNoType || fieldSchema.type === Number)
+                            fieldSchema.type = 'integer';
+                        break;
+                    case connect_1.DataType.GUID:
+                        if (hasNoType || fieldSchema.type === String)
+                            fieldSchema.type = 'uuid';
+                        break;
+                    case connect_1.DataType.DATE:
+                        if (fieldSchema.type === String)
+                            fieldSchema.type = 'datestring';
+                        else if (hasNoType || fieldSchema.type === Date)
+                            fieldSchema.type = 'date';
+                        break;
+                    case connect_1.DataType.TIMESTAMP:
+                        if (fieldSchema.type === String)
+                            fieldSchema.type = 'datetimestring';
+                        else if (hasNoType || fieldSchema.type === Date)
+                            fieldSchema.type = 'datetime';
+                        break;
+                    case connect_1.DataType.TIMESTAMPTZ:
+                        if (fieldSchema.type === Date)
+                            fieldSchema.type = 'datetime';
+                        else if (hasNoType || fieldSchema.type === String)
+                            fieldSchema.type = 'datetimestring';
+                        break;
+                    case connect_1.DataType.TIME:
+                        if (hasNoType || fieldSchema.type === String)
+                            fieldSchema.type = 'time';
+                        break;
+                }
+            }
+            if ((0, connect_1.isAssociationField)(sqbField)) {
+                if (sqbField.association.returnsMany())
+                    fieldSchema.isArray = true;
+                if (!fieldSchema.hasOwnProperty('exclusive'))
+                    fieldSchema.exclusive = true;
+            }
+            if (!fieldSchema.hasOwnProperty('exclusive') && sqbField.hasOwnProperty('exclusive'))
+                fieldSchema.exclusive = sqbField.exclusive;
+        }
+    }
+    return _prepareComplexTypeArgs.apply(DataTypeFactory, [context, owner, initArgs, metadata]);
+};

package/cjs/augmentation/mixin-type.augmentation.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const common_1 = require("@opra/common");
 const connect_1 = require("@sqb/connect");
-const _applyMixin = common_1.MixinType._applyMixin;
-common_1.MixinType._applyMixin = function (target, ...sources) {
-    _applyMixin.call(null, target, ...sources);
+const oldDecorator = common_1.MixinType[common_1.DECORATOR];
+common_1.MixinType[common_1.DECORATOR] = function (...sources) {
+    sources = sources.filter(x => typeof x === 'function');
+    const target = oldDecorator(...sources);
     connect_1.Entity.mixin(target, ...sources);
+    return target;
 };

package/cjs/index.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-require("./augmentation/type-document-factory.augmentation.js");
-require("./augmentation/api-document-factory.augmentation.js");
+require("./augmentation/datatype-factory.augmentation.js");
 require("./augmentation/mapped-type.augmentation.js");
 require("./augmentation/mixin-type.augmentation.js");
 tslib_1.__exportStar(require("./sqb-adapter.js"), exports);
-tslib_1.__exportStar(require("./sqb-collection.js"), exports);
+tslib_1.__exportStar(require("./sqb-collection-service.js"), exports);
 tslib_1.__exportStar(require("./sqb-entity-service.js"), exports);
-tslib_1.__exportStar(require("./sqb-singleton.js"), exports);
+tslib_1.__exportStar(require("./sqb-singleton-service.js"), exports);

package/cjs/sqb-adapter.js

@@ -2,112 +2,78 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQBAdapter = void 0;
 const tslib_1 = require("tslib");
-const common_1 = require("@opra/common");
 const connect_1 = require("@sqb/connect");
-const transform_filter_js_1 = tslib_1.__importDefault(require("./transform-filter.js"));
-const transform_key_values_js_1 = tslib_1.__importDefault(require("./transform-key-values.js"));
+const parse_filter_js_1 = tslib_1.__importDefault(require("./adapter-utils/parse-filter.js"));
 var SQBAdapter;
 (function (SQBAdapter) {
-    SQBAdapter.transformFilter = transform_filter_js_1.default;
-    SQBAdapter.transformKeyValues = transform_key_values_js_1.default;
-    function transformRequest(request) {
-        const { resource } = request;
-        if (resource instanceof common_1.Collection || resource instanceof common_1.Singleton) {
-            const { params, endpoint } = request;
-            let options = {};
-            const entityMetadata = connect_1.EntityMetadata.get(resource.type.ctor);
+    SQBAdapter.parseFilter = parse_filter_js_1.default;
+    async function parseRequest(context) {
+        const { operation } = context;
+        if (operation.composition?.startsWith('Entity.') && operation.compositionOptions?.type) {
+            const dataType = context.document.node.getComplexType(operation.compositionOptions?.type);
+            const entityMetadata = connect_1.EntityMetadata.get(dataType.ctor);
             if (!entityMetadata)
-                throw new Error(`Type class "${resource.type.ctor}" is not an SQB entity`);
-            if (resource instanceof common_1.Collection) {
-                const primaryIndex = entityMetadata.indexes.find(x => x.primary);
-                // Check if resource primary keys are same with entity
-                const primaryKeys = [...(primaryIndex && primaryIndex.columns) || []];
-                if (primaryKeys.sort().join() !== [...resource.primaryKey].sort().join())
-                    throw new Error('Resource primaryKey definition differs from SQB Entity primaryKey definition');
-            }
-            const operation = endpoint.name;
-            if (operation === 'create' || operation === 'update' ||
-                operation === 'get' || operation === 'findMany') {
-                options.pick = params?.pick;
-                options.omit = params?.omit;
-                options.include = params?.include;
-            }
-            if (resource instanceof common_1.Collection && params?.filter) {
-                options.filter = (0, transform_filter_js_1.default)(params.filter);
-            }
-            if (operation === 'findMany') {
-                options.sort = params?.sort;
-                options.limit = params?.limit;
-                options.offset = params?.skip;
-                options.distinct = params?.distinct;
-                options.count = params?.count;
-            }
-            options = (0, common_1.omitNullish)(options);
-            if (operation === 'create') {
-                return {
-                    method: 'create',
-                    data: request.data,
-                    options,
-                    args: [request.data, options]
-                };
-            }
-            if (operation === 'deleteMany' || (operation === 'delete' && resource instanceof common_1.Singleton)) {
-                return {
-                    method: 'deleteMany',
-                    options,
-                    args: [options]
-                };
-            }
-            if (operation === 'delete') {
-                return {
-                    method: 'delete',
-                    key: request.key,
-                    options,
-                    args: [request.key, options]
-                };
-            }
-            if (operation === 'get') {
-                if (resource instanceof common_1.Singleton)
-                    return {
-                        method: 'findOne',
-                        options,
-                        args: [options]
+                throw new Error(`Type class "${dataType.ctor}" is not an SQB entity`);
+            const { compositionOptions } = operation;
+            switch (operation.composition) {
+                case 'Entity.Create': {
+                    const data = await context.getBody();
+                    const options = {
+                        projection: context.queryParams.projection,
                     };
-                return {
-                    method: 'find',
-                    key: request.key,
-                    options,
-                    args: [request.key, options]
-                };
-            }
-            if (operation === 'findMany') {
-                const out = {
-                    method: 'findMany',
-                    options,
-                    args: [options]
-                };
-                out.count = params?.count;
-                return out;
-            }
-            if (operation === 'updateMany' || (operation === 'update' && resource instanceof common_1.Singleton)) {
-                return {
-                    method: 'updateMany',
-                    data: request.data,
-                    options,
-                    args: [request.data, options]
-                };
-            }
-            if (operation === 'update') {
-                return {
-                    method: 'update',
-                    key: request.key,
-                    data: request.data,
-                    options,
-                    args: [request.key, request.data, options]
-                };
+                    return { method: 'create', data, options };
+                }
+                case 'Entity.Delete': {
+                    const key = context.pathParams[compositionOptions.keyParameter];
+                    const options = {
+                        filter: SQBAdapter.parseFilter(context.queryParams.filter),
+                    };
+                    return { method: 'delete', key, options };
+                }
+                case 'Entity.DeleteMany': {
+                    const options = {
+                        filter: SQBAdapter.parseFilter(context.queryParams.filter),
+                    };
+                    return { method: 'deleteMany', options };
+                }
+                case 'Entity.FindMany': {
+                    const options = {
+                        count: context.queryParams.count,
+                        filter: SQBAdapter.parseFilter(context.queryParams.filter),
+                        limit: context.queryParams.limit,
+                        offset: context.queryParams.skip,
+                        projection: context.queryParams.projection,
+                        sort: context.queryParams.sort,
+                    };
+                    return { method: 'findMany', options };
+                }
+                case 'Entity.Get': {
+                    const key = context.pathParams[compositionOptions.keyParameter];
+                    const options = {
+                        projection: context.queryParams.projection,
+                        filter: SQBAdapter.parseFilter(context.queryParams.filter),
+                    };
+                    return { method: 'get', key, options };
+                }
+                case 'Entity.Update': {
+                    const data = await context.getBody();
+                    const key = context.pathParams[compositionOptions.keyParameter];
+                    const options = {
+                        projection: context.queryParams.projection,
+                        filter: SQBAdapter.parseFilter(context.queryParams.filter),
+                    };
+                    return { method: 'update', key, data, options };
+                }
+                case 'Entity.UpdateMany': {
+                    const data = await context.getBody();
+                    const options = {
+                        filter: SQBAdapter.parseFilter(context.queryParams.filter),
+                    };
+                    return { method: 'updateMany', data, options };
+                }
             }
         }
-        throw new Error(`Unimplemented request method "${request.operation}"`);
+        throw new Error(`This operation is not compatible to SQB Adapter`);
     }
-    SQBAdapter.transformRequest = transformRequest;
+    SQBAdapter.parseRequest = parseRequest;
 })(SQBAdapter || (exports.SQBAdapter = SQBAdapter = {}));

package/cjs/sqb-collection-service.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbCollectionService = void 0;
+const common_1 = require("@opra/common");
+const sqb_adapter_js_1 = require("./sqb-adapter.js");
+const sqb_entity_service_js_1 = require("./sqb-entity-service.js");
+/**
+ * @class SqbCollectionService
+ * @template T - The data type class type of the resource
+ */
+class SqbCollectionService extends sqb_entity_service_js_1.SqbEntityService {
+    /**
+     * 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, options) {
+        super(dataType, options);
+        this.defaultLimit = options?.defaultLimit || 100;
+    }
+    /**
+     * 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.
+     */
+    async assert(id, options) {
+        if (!(await this.exists(id, options)))
+            throw new common_1.ResourceNotAvailableError(this.getResourceName(), id);
+    }
+    /**
+     * Creates a new resource
+     *
+     * @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
+     */
+    async create(input, options) {
+        const info = {
+            crud: 'create',
+            method: 'create',
+            byId: false,
+            input,
+            options,
+        };
+        return this._intercept(() => this._create(input, options), info);
+    }
+    /**
+     * Returns the count of records based on the provided options
+     *
+     * @param {SqbCollectionService.CountOptions} options - The options for the count operation.
+     * @return {Promise<number>} - A promise that resolves to the count of records
+     */
+    async count(options) {
+        const info = {
+            crud: 'read',
+            method: 'count',
+            byId: false,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._count({ ...options, filter });
+        }, info);
+    }
+    /**
+     * Deletes a record from the collection.
+     *
+     * @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.
+     */
+    async delete(id, options) {
+        const info = {
+            crud: 'delete',
+            method: 'delete',
+            byId: true,
+            documentId: id,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._delete(id, { ...options, filter });
+        }, info);
+    }
+    /**
+     * Deletes multiple documents from the collection that meet the specified filter criteria.
+     *
+     * @param {SqbCollectionService.DeleteManyOptions} options - The options for the delete operation.
+     * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
+     */
+    async deleteMany(options) {
+        const info = {
+            crud: 'delete',
+            method: 'deleteMany',
+            byId: false,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._deleteMany({ ...options, filter });
+        }, info);
+    }
+    /**
+     * Checks if a record with the given id exists.
+     *
+     * @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.
+     */
+    async exists(id, options) {
+        const info = {
+            crud: 'read',
+            method: 'exists',
+            byId: true,
+            documentId: id,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._exists(id, { ...options, filter });
+        }, info);
+    }
+    /**
+     * Checks if a record with the given arguments exists.
+     *
+     * @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.
+     */
+    async existsOne(options) {
+        const info = {
+            crud: 'read',
+            method: 'existsOne',
+            byId: false,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._existsOne({ ...options, filter });
+        }, info);
+    }
+    /**
+     * Finds a record by ID.
+     *
+     * @param {SQBAdapter.Id} 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.
+     */
+    async findById(id, options) {
+        const info = {
+            crud: 'read',
+            method: 'findById',
+            byId: true,
+            documentId: id,
+            options,
+        };
+        return this._intercept(async () => {
+            const documentFilter = await this._getCommonFilter(info);
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([documentFilter, options?.filter]);
+            return this._findById(id, { ...options, filter });
+        }, info);
+    }
+    /**
+     * Finds a record in the collection that matches the specified options.
+     *
+     * @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.
+     */
+    async findOne(options) {
+        const info = {
+            crud: 'read',
+            method: 'findOne',
+            byId: false,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._findOne({ ...options, filter });
+        }, info);
+    }
+    /**
+     * Finds multiple records in collection.
+     *
+     * @param {SqbCollectionService.FindManyOptions} options - The options for the find operation.
+     * @return A Promise that resolves to an array of partial outputs of type T.
+     */
+    async findMany(options) {
+        const info = {
+            crud: 'read',
+            method: 'findMany',
+            byId: false,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._findMany({ ...options, filter });
+        }, info);
+    }
+    /**
+     * Finds multiple records in the collection and returns both records (max limit)
+     * and total count that matched the given criteria
+     *
+     * @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.
+     */
+    async findManyWithCount(options) {
+        const [items, count] = await Promise.all([this.findMany(options), this.count(options)]);
+        return { count, items };
+    }
+    /**
+     * 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 {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.
+     */
+    async get(id, options) {
+        const out = await this.findById(id, options);
+        if (!out)
+            throw new common_1.ResourceNotAvailableError(this.getResourceName(), id);
+        return out;
+    }
+    /**
+     * 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 {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.
+     */
+    async update(id, input, options) {
+        const info = {
+            crud: 'update',
+            method: 'update',
+            documentId: id,
+            byId: true,
+            input,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._update(id, input, { ...options, filter });
+        }, info);
+    }
+    /**
+     * 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 {SqbCollectionService.UpdateOptions} options - The options for updating the document.
+     * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
+     */
+    async updateOnly(id, input, options) {
+        const info = {
+            crud: 'update',
+            method: 'update',
+            documentId: id,
+            byId: true,
+            input,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._updateOnly(id, input, { ...options, filter });
+        }, info);
+    }
+    /**
+     * 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 {SqbCollectionService.UpdateManyOptions} options - The options for updating the documents.
+     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     */
+    async updateMany(input, options) {
+        const info = {
+            crud: 'update',
+            method: 'updateMany',
+            byId: false,
+            input,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = sqb_adapter_js_1.SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
+            return this._updateMany(input, { ...options, filter });
+        }, info);
+    }
+}
+exports.SqbCollectionService = SqbCollectionService;