@opra/sqb 0.33.13 → 1.0.0-alpha.2

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

@@ -1,22 +1,422 @@
-import { Type } from 'ts-gems';
-import { DTO, PartialDTO, PatchDTO } from '@opra/common';
-import { EntityInput, Repository } from '@sqb/connect';
-import { SqbEntityServiceBase } from './sqb-entity-service-base.js';
+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 { SQBAdapter } from './sqb-adapter.js';
+/**
+ * @namespace SqbEntityService
+ */
 export declare namespace SqbEntityService {
-    interface Options extends SqbEntityServiceBase.Options {
+    interface Options {
+        db?: SqbEntityService<any>['db'];
+        resourceName?: SqbEntityService<any>['$resourceName'];
+        onError?: SqbEntityService<any>['$onError'];
+        commonFilter?: SqbEntityService<any>['$commonFilter'];
+        interceptor?: SqbEntityService<any>['$interceptor'];
+    }
+    type CrudOp = 'create' | 'read' | 'update' | 'delete';
+    interface CommandInfo {
+        crud: SqbEntityService.CrudOp;
+        method: string;
+        byId: boolean;
+        documentId?: SQBAdapter.IdOrIds;
+        input?: Record<string, any>;
+        options?: Record<string, any>;
+    }
+    /**
+     * Represents options for "create" operation
+     *
+     * @interface
+     */
+    interface CreateOptions extends Repository.CreateOptions {
+    }
+    /**
+     * Represents options for "count" operation
+     *
+     * @interface
+     */
+    interface CountOptions extends Repository.CountOptions {
+    }
+    /**
+     * Represents options for "delete" operation
+     *
+     * @interface
+     */
+    interface DeleteOptions extends Repository.DeleteOptions {
+    }
+    /**
+     * Represents options for "deleteMany" operation
+     *
+     * @interface
+     */
+    interface DeleteManyOptions extends Repository.DeleteManyOptions {
+    }
+    /**
+     * Represents options for "exists" operation
+     *
+     * @interface
+     */
+    interface ExistsOptions extends Repository.ExistsOptions {
+    }
+    /**
+     * Represents options for "existsOne" operation
+     *
+     * @interface
+     */
+    interface ExistsOneOptions extends Repository.ExistsOptions {
+    }
+    /**
+     * Represents options for "findOne" operation
+     *
+     * @interface
+     */
+    interface FindOneOptions extends Repository.FindOneOptions {
+    }
+    /**
+     * Represents options for "findMany" operation
+     *
+     * @interface
+     */
+    interface FindManyOptions extends Repository.FindManyOptions {
+    }
+    /**
+     * Represents options for "update" operation
+     *
+     * @interface
+     */
+    interface UpdateOptions extends Repository.UpdateOptions {
+    }
+    /**
+     * Represents options for "updateOnly" operation
+     *
+     * @interface
+     */
+    interface UpdateOnlyOptions extends Repository.UpdateOptions {
+    }
+    /**
+     * Represents options for "updateMany" operation
+     *
+     * @interface
+     */
+    interface UpdateManyOptions extends Repository.UpdateManyOptions {
     }
 }
-export declare class SqbEntityService<T> extends SqbEntityServiceBase<T> {
-    readonly typeClass: Type<T>;
-    constructor(typeClass: Type<T>, options?: SqbEntityService.Options);
-    count(options?: Repository.CountOptions): Promise<number>;
-    create(data: DTO<T>, options?: Repository.CreateOptions): Promise<PartialDTO<T>>;
-    delete(keyValue: any, options?: Repository.DeleteOptions): Promise<number>;
-    deleteMany(options?: Repository.DeleteManyOptions): Promise<number>;
-    find(keyValue: any, options?: Repository.FindOptions): Promise<PartialDTO<T> | undefined>;
-    findOne(options?: Repository.FindOneOptions): Promise<PartialDTO<T> | undefined>;
-    findMany(options?: Repository.FindManyOptions): Promise<PartialDTO<T>[]>;
-    exists(options?: Repository.ExistsOptions): Promise<boolean>;
-    update(keyValue: any, data: EntityInput<T>, options?: Repository.UpdateOptions): Promise<PartialDTO<T> | undefined>;
-    updateMany(data: PatchDTO<T>, options?: Repository.UpdateManyOptions): Promise<number>;
+/**
+ * @class SqbEntityService
+ * @template T - The data type class type of the resource
+ */
+export declare class SqbEntityService<T extends object = object> extends ServiceBase {
+    protected _dataType_: Type | string;
+    protected _dataType: ComplexType;
+    protected _dataTypeClass?: Type;
+    protected _entityMetadata?: EntityMetadata;
+    protected _encoders: Record<string, IsObject.Validator<T>>;
+    protected _decoder?: IsObject.Validator<T>;
+    /**
+     * Represents a SqbClient or SqbConnection object
+     */
+    db?: (SqbClient | SqbConnection) | ((_this: any) => SqbClient | SqbConnection);
+    /**
+     * Represents the name of a resource.
+     * @type {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>;
+    /**
+     * 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>;
+    /**
+     * Constructs a new instance
+     *
+     * @param dataType - The data type of the returning results
+     * @param [options] - The options for the service.
+     * @constructor
+     */
+    constructor(dataType: Type<T> | string, options?: SqbEntityService.Options);
+    /**
+     * Retrieves the OPRA data type
+     *
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataType(): ComplexType;
+    /**
+     * Retrieves the Class of the data type
+     *
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataTypeClass(): Type;
+    /**
+     * Retrieves the SQB entity metadata object
+     *
+     * @throws {TypeError} If metadata is not available
+     */
+    get entityMetadata(): EntityMetadata;
+    /**
+     * Retrieves the resource name.
+     *
+     * @returns {string} The resource name.
+     * @throws {Error} If the collection name is not defined.
+     */
+    getResourceName(): string;
+    /**
+     * Retrieves the encoder 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>;
+    /**
+     * Retrieves the decoder.
+     */
+    getDecoder(): 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
+     * @protected
+     */
+    protected _create(input: PartialDTO<T>, options?: SqbEntityService.CreateOptions): 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
+     * @protected
+     */
+    protected _count(options?: SqbEntityService.CountOptions): 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.
+     * @protected
+     */
+    protected _delete(id: SQBAdapter.IdOrIds, options?: SqbEntityService.DeleteOptions): 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.
+     * @protected
+     */
+    protected _deleteMany(options?: SqbEntityService.DeleteManyOptions): 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.
+     * @protected
+     */
+    protected _exists(id: SQBAdapter.IdOrIds, options?: SqbEntityService.ExistsOptions): 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.
+     * @protected
+     */
+    protected _existsOne(options?: SqbEntityService.ExistsOptions): 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.
+     * @protected
+     */
+    protected _findById(id: SQBAdapter.Id, options?: SqbEntityService.FindOneOptions): 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.
+     * @protected
+     */
+    protected _findOne(options?: SqbEntityService.FindOneOptions): 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.
+     * @protected
+     */
+    protected _findMany(options?: SqbEntityService.FindManyOptions): 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.
+     * @protected
+     */
+    protected _update(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: SqbEntityService.UpdateOptions): 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.
+     * @protected
+     */
+    protected _updateOnly(id: SQBAdapter.IdOrIds, input: PatchDTO<T>, options?: SqbEntityService.UpdateOptions): 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.
+     * @protected
+     */
+    protected _updateMany(input: PatchDTO<T>, options?: SqbEntityService.UpdateManyOptions): Promise<number>;
+    /**
+     * Acquires a connection and performs Repository.create operation
+     *
+     * @param input - The document to insert
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbCreate(input: PartialDTO<T>, options?: Repository.CreateOptions): Promise<PartialDTO<T>>;
+    /**
+     * Acquires a connection and performs Repository.count operation
+     *
+     * @param options - The options for counting documents.
+     * @protected
+     */
+    protected _dbCount(options?: Repository.CountOptions): Promise<number>;
+    /**
+     * Acquires a connection and performs Repository.delete operation
+     *
+     * @param id - Value of the key field used to select the record
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbDelete(id: SQBAdapter.IdOrIds, options?: Repository.DeleteOptions): Promise<number>;
+    /**
+     * Acquires a connection and performs Repository.deleteMany operation
+     *
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbDeleteMany(options?: Repository.DeleteManyOptions): Promise<number>;
+    /**
+     * Acquires a connection and performs Repository.exists operation
+     *
+     * @param id - Value of the key field used to select the record
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbExists(id: SQBAdapter.IdOrIds, options?: Repository.ExistsOptions): Promise<boolean>;
+    /**
+     * Acquires a connection and performs Repository.existsOne operation
+     *
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbExistsOne(options?: Repository.ExistsOptions): Promise<boolean>;
+    /**
+     * Acquires a connection and performs Repository.findById operation
+     *
+     * @param id - Value of the key field used to select the record
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbFindById(id: SQBAdapter.IdOrIds, options?: Repository.FindOptions): Promise<PartialDTO<T> | undefined>;
+    /**
+     * Acquires a connection and performs Repository.findOne operation
+     *
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbFindOne(options?: Repository.FindOneOptions): Promise<PartialDTO<T> | undefined>;
+    /**
+     * Acquires a connection and performs Repository.findMany operation
+     *
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbFindMany(options?: Repository.FindManyOptions): Promise<PartialDTO<T>[]>;
+    /**
+     * Acquires a connection and performs Repository.update operation
+     *
+     * @param id - Value of the key field used to select the record
+     * @param data - The update values to be applied to the document
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbUpdate(id: SQBAdapter.IdOrIds, data: PatchDTO<T>, options?: Repository.UpdateOptions): Promise<PartialDTO<T> | undefined>;
+    /**
+     * Acquires a connection and performs Repository.updateOnly operation
+     *
+     * @param id - Value of the key field used to select the record
+     * @param data - The update values to be applied to the document
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbUpdateOnly(id: SQBAdapter.IdOrIds, data: PatchDTO<T>, options?: Repository.UpdateOptions): Promise<boolean>;
+    /**
+     * Acquires a connection and performs Repository.updateMany operation
+     *
+     * @param data - The update values to be applied to the document
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    protected _dbUpdateMany(data: PatchDTO<T>, options?: Repository.UpdateManyOptions): Promise<number>;
+    /**
+     * Retrieves the database connection.
+     *
+     * @protected
+     *
+     * @throws {Error} If the context or database is not set.
+     */
+    protected getConnection(): SqbConnection | SqbClient | Promise<SqbConnection | SqbClient>;
+    /**
+     * 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 _getCommonFilter(args: {
+        crud: SqbEntityService.CrudOp;
+        method: string;
+        byId: boolean;
+        documentId?: SQBAdapter.IdOrIds;
+        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>;
 }

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

@@ -0,0 +1,137 @@
+import { PartialDTO, PatchDTO, Type } from 'ts-gems';
+import { ColumnFieldMetadata } from '@sqb/connect';
+import { SQBAdapter } from './sqb-adapter.js';
+import { SqbEntityService } from './sqb-entity-service.js';
+/**
+ * @namespace SqbSingletonService
+ */
+export declare namespace SqbSingletonService {
+    interface Options extends SqbEntityService.Options {
+        id?: SqbSingletonService<any>['id'];
+    }
+    /**
+     * Represents options for "create" operation
+     *
+     * @interface
+     */
+    interface CreateOptions extends SqbEntityService.CreateOptions {
+    }
+    /**
+     * Represents options for "delete" operation
+     *
+     * @interface
+     */
+    interface DeleteOptions extends SqbEntityService.DeleteOptions {
+    }
+    /**
+     * Represents options for "exists" operation
+     *
+     * @interface
+     */
+    interface ExistsOptions extends SqbEntityService.ExistsOptions {
+    }
+    /**
+     * Represents options for "find" operation
+     *
+     * @interface
+     */
+    interface FindOptions extends SqbEntityService.FindOneOptions {
+    }
+    /**
+     * Represents options for "update" operation
+     *
+     * @interface
+     */
+    interface UpdateOptions extends SqbEntityService.UpdateOptions {
+    }
+    /**
+     * Represents options for "updateOnly" operation
+     *
+     * @interface
+     */
+    interface UpdateOnlyOptions extends SqbEntityService.UpdateOptions {
+    }
+}
+/**
+ * @class SqbSingletonService
+ * @template T - The data type class type of the resource
+ */
+export declare abstract class SqbSingletonService<T extends object = object> extends SqbEntityService {
+    protected _primaryKeyFields?: ColumnFieldMetadata[];
+    /**
+     * Represents a unique identifier for singleton record
+     * @property {SQBAdapter.Id}
+     */
+    id: SQBAdapter.Id;
+    /**
+     * Constructs a new instance
+     *
+     * @param {Type | string} dataType - The data type of the array elements.
+     * @param {SqbSingletonService.Options} [options] - The options for the array service.
+     * @constructor
+     */
+    constructor(dataType: Type<T> | string, options?: SqbSingletonService.Options);
+    /**
+     * Asserts the existence of a resource based on the given options.
+     *
+     * @returns {Promise<void>} A Promise that resolves when the resource exists.
+     * @throws {ResourceNotAvailableError} If the resource does not exist.
+     */
+    assert(options?: SqbSingletonService.ExistsOptions): Promise<void>;
+    /**
+     * Inserts a single record into the database.
+     *
+     * @param {PartialDTO<T>} input - The input data
+     * @param {SqbSingletonService.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
+     */
+    create(input: PartialDTO<T>, options?: SqbSingletonService.CreateOptions): Promise<PartialDTO<T>>;
+    /**
+     * Deletes the singleton record
+     *
+     * @param {SqbSingletonService.DeleteOptions} [options] - The options object
+     * @return {Promise<number>} - A Promise that resolves to the number of records deleted
+     */
+    delete(options?: SqbSingletonService.DeleteOptions): Promise<number>;
+    /**
+     * Checks if the singleton record exists.
+     *
+     * @param {SqbSingletonService.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.
+     */
+    exists(options?: SqbSingletonService.ExistsOptions): Promise<boolean>;
+    /**
+     * Finds the singleton record. Returns `undefined` if not found
+     *
+     * @param {SqbSingletonService.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.
+     */
+    find(options?: SqbSingletonService.FindOptions): Promise<PartialDTO<T> | undefined>;
+    /**
+     * Retrieves the singleton record. Throws error if not found.
+     *
+     * @param {SqbSingletonService.FindOptions} [options] - Optional options for the `find` 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 does not exist.
+     */
+    get(options?: SqbSingletonService.FindOptions): Promise<PartialDTO<T>>;
+    /**
+     * Updates the singleton.
+     *
+     * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
+     * @param {SqbSingletonService.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.
+     */
+    update(input: PatchDTO<T>, options?: SqbSingletonService.UpdateOptions): Promise<PartialDTO<T> | undefined>;
+    /**
+     * Updates the singleton and  returns updated record count
+     *
+     * @param {PatchDTO<T>} input - The partial input data to update the document with.
+     * @param {SqbSingletonService.UpdateOptions} options - The options for updating the document.
+     * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
+     */
+    updateOnly(input: PatchDTO<T>, options?: SqbSingletonService.UpdateOnlyOptions): Promise<number>;
+}

package/cjs/augmentation/api-document-factory.augmentation.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@opra/common");
-const connect_1 = require("@sqb/connect");
-// @ts-ignore
-const _createResource = common_1.ApiDocumentFactory.prototype.createResource;
-// @ts-ignore
-common_1.ApiDocumentFactory.prototype.createResource = function (container, initArguments) {
-    // Determine primaryKey if not defined
-    if (initArguments.kind === 'Collection' && !initArguments.primaryKey && initArguments.type.ctor) {
-        const entityMetadata = connect_1.EntityMetadata.get(initArguments.type.ctor);
-        if (entityMetadata?.indexes) {
-            const primaryIndex = entityMetadata.indexes.find(x => x.primary);
-            if (primaryIndex) {
-                initArguments.primaryKey = primaryIndex.columns;
-            }
-        }
-    }
-    return _createResource.call(this, container, initArguments);
-};