@opra/sqb 0.33.13 → 1.0.0-alpha.2

package/esm/sqb-entity-service.js

@@ -1,37 +1,456 @@
-import { SqbEntityServiceBase } from './sqb-entity-service-base.js';
-export class SqbEntityService extends SqbEntityServiceBase {
-    constructor(typeClass, options) {
-        super(typeClass, options);
-        this.typeClass = typeClass;
+import { InternalServerError } from '@opra/common';
+import { ServiceBase } from '@opra/core';
+import { EntityMetadata } from '@sqb/connect';
+import { SQBAdapter } from './sqb-adapter.js';
+/**
+ * @class SqbEntityService
+ * @template T - The data type class type of the resource
+ */
+export class SqbEntityService extends ServiceBase {
+    /**
+     * Constructs a new instance
+     *
+     * @param dataType - The data type of the returning results
+     * @param [options] - The options for the service.
+     * @constructor
+     */
+    constructor(dataType, options) {
+        super();
+        this._encoders = {};
+        this._dataType_ = dataType;
+        this.db = options?.db;
+        this.$resourceName = options?.resourceName;
+        this.$commonFilter = this.$commonFilter || options?.commonFilter;
+        this.$interceptor = this.$interceptor || options?.interceptor;
     }
-    async count(options) {
-        return super._count(options);
+    /**
+     * Retrieves the OPRA data type
+     *
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataType() {
+        if (!this._dataType)
+            this._dataType = this.context.document.node.getComplexType(this._dataType_);
+        return this._dataType;
     }
-    async create(data, options) {
-        return super._create(data, options);
+    /**
+     * Retrieves the Class of the data type
+     *
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataTypeClass() {
+        if (!this._dataTypeClass)
+            this._dataTypeClass = this.entityMetadata.ctor;
+        return this._dataTypeClass;
     }
-    async delete(keyValue, options) {
-        return super._delete(keyValue, options);
+    /**
+     * Retrieves the SQB entity metadata object
+     *
+     * @throws {TypeError} If metadata is not available
+     */
+    get entityMetadata() {
+        if (!this._entityMetadata) {
+            const t = this.dataType.ctor;
+            const metadata = EntityMetadata.get(t);
+            if (!metadata)
+                throw new TypeError(`Class (${t}) is not decorated with $Entity() decorator`);
+            this._entityMetadata = metadata;
+        }
+        return this._entityMetadata;
     }
-    async deleteMany(options) {
-        return super._deleteMany(options);
+    /**
+     * Retrieves the resource name.
+     *
+     * @returns {string} The resource name.
+     * @throws {Error} If the collection name is not defined.
+     */
+    getResourceName() {
+        const out = typeof this.$resourceName === 'function' ? this.$resourceName(this) : this.$resourceName || this.dataType.name;
+        if (out)
+            return out;
+        throw new Error('resourceName is not defined');
     }
-    async find(keyValue, options) {
-        return super._find(keyValue, options);
+    /**
+     * Retrieves the encoder for the specified operation.
+     *
+     * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
+     */
+    getEncoder(operation) {
+        let encoder = this._encoders[operation];
+        if (encoder)
+            return encoder;
+        const options = { projection: '*' };
+        if (operation === 'update')
+            options.partial = 'deep';
+        const dataType = this.dataType;
+        encoder = dataType.generateCodec('encode', options);
+        this._encoders[operation] = encoder;
+        return encoder;
     }
-    async findOne(options) {
-        return super._findOne(options);
+    /**
+     * Retrieves the decoder.
+     */
+    getDecoder() {
+        let decoder = this._decoder;
+        if (decoder)
+            return decoder;
+        const options = { projection: '*', partial: 'deep' };
+        const dataType = this.dataType;
+        decoder = dataType.generateCodec('decode', options);
+        this._decoder = decoder;
+        return decoder;
     }
-    async findMany(options) {
-        return super._findMany(options);
+    /**
+     * 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
+     */
+    async _create(input, options) {
+        const encode = this.getEncoder('create');
+        const data = encode(input);
+        const out = await this._dbCreate(data, options);
+        if (out)
+            return out;
+        throw new InternalServerError(`Unknown error while creating document for "${this.getResourceName()}"`);
     }
-    async exists(options) {
-        return super._exists(options);
+    /**
+     * 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
+     */
+    async _count(options) {
+        return this._dbCount(options);
     }
-    async update(keyValue, data, options) {
-        return super._update(keyValue, data, options);
+    /**
+     * 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
+     */
+    async _delete(id, options) {
+        return this._dbDelete(id, options);
     }
-    async updateMany(data, options) {
-        return super._updateMany(data, options);
+    /**
+     * 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
+     */
+    async _deleteMany(options) {
+        return await this._dbDeleteMany(options);
+    }
+    /**
+     * 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
+     */
+    async _exists(id, options) {
+        return await this._dbExists(id, options);
+    }
+    /**
+     * 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
+     */
+    async _existsOne(options) {
+        return await this._dbExistsOne(options);
+    }
+    /**
+     * 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
+     */
+    async _findById(id, options) {
+        const decode = this.getDecoder();
+        const out = await this._dbFindById(id, options);
+        return out ? decode(out) : 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
+     */
+    async _findOne(options) {
+        const decode = this.getDecoder();
+        const out = await this._dbFindOne(options);
+        return out ? decode(out) : 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
+     */
+    async _findMany(options) {
+        const decode = this.getDecoder();
+        const out = await this._dbFindMany(options);
+        if (out?.length) {
+            return out.map(x => decode(x));
+        }
+        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 {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
+     */
+    async _update(id, input, options) {
+        const encode = this.getEncoder('update');
+        const decode = this.getDecoder();
+        const data = encode(input);
+        const out = await this._dbUpdate(id, data, options);
+        if (out)
+            return decode(out);
+    }
+    /**
+     * 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
+     */
+    async _updateOnly(id, input, options) {
+        const encode = this.getEncoder('create');
+        const data = encode(input);
+        return await this._dbUpdateOnly(id, data, options);
+    }
+    /**
+     * 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
+     */
+    async _updateMany(input, options) {
+        const encode = this.getEncoder('update');
+        const data = encode(input);
+        return await this._dbUpdateMany(data, options);
+    }
+    /**
+     * Acquires a connection and performs Repository.create operation
+     *
+     * @param input - The document to insert
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    async _dbCreate(input, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        return await repo.create(input, options);
+    }
+    /**
+     * Acquires a connection and performs Repository.count operation
+     *
+     * @param options - The options for counting documents.
+     * @protected
+     */
+    async _dbCount(options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.count(options);
+    }
+    /**
+     * 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
+     */
+    async _dbDelete(id, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return (await repo.delete(id, options)) ? 1 : 0;
+    }
+    /**
+     * Acquires a connection and performs Repository.deleteMany operation
+     *
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    async _dbDeleteMany(options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.deleteMany(options);
+    }
+    /**
+     * 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
+     */
+    async _dbExists(id, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.exists(id, options);
+    }
+    /**
+     * Acquires a connection and performs Repository.existsOne operation
+     *
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    async _dbExistsOne(options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.existsOne(options);
+    }
+    /**
+     * 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
+     */
+    async _dbFindById(id, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.findById(id, options);
+    }
+    /**
+     * Acquires a connection and performs Repository.findOne operation
+     *
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    async _dbFindOne(options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.findOne(options);
+    }
+    /**
+     * Acquires a connection and performs Repository.findMany operation
+     *
+     * @param options - Optional settings for the command
+     * @protected
+     */
+    async _dbFindMany(options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.findMany(options);
+    }
+    /**
+     * 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
+     */
+    async _dbUpdate(id, data, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.update(id, data, options);
+    }
+    /**
+     * 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
+     */
+    async _dbUpdateOnly(id, data, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.updateOnly(id, data, options);
+    }
+    /**
+     * 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
+     */
+    async _dbUpdateMany(data, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        if (options?.filter)
+            options.filter = SQBAdapter.parseFilter(options.filter);
+        return await repo.updateMany(data, options);
+    }
+    /**
+     * Retrieves the database connection.
+     *
+     * @protected
+     *
+     * @throws {Error} If the context or database is not set.
+     */
+    getConnection() {
+        const db = typeof this.db === 'function' ? this.db(this) : this.db;
+        if (!db)
+            throw new Error(`Database not set!`);
+        return db;
+    }
+    /**
+     * 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.
+     */
+    _getCommonFilter(args) {
+        return typeof this.$commonFilter === 'function' ? this.$commonFilter(args, this) : this.$commonFilter;
+    }
+    async _intercept(callback, args) {
+        try {
+            if (this.$interceptor)
+                return this.$interceptor(callback, args, this);
+            return callback();
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this._intercept);
+            await this.$onError?.(e, this);
+            throw e;
+        }
     }
 }

package/esm/sqb-singleton-service.js

@@ -0,0 +1,176 @@
+import { ResourceNotAvailableError } from '@opra/common';
+import { EntityMetadata } from '@sqb/connect';
+import { SQBAdapter } from './sqb-adapter.js';
+import { SqbEntityService } from './sqb-entity-service.js';
+/**
+ * @class SqbSingletonService
+ * @template T - The data type class type of the resource
+ */
+export class SqbSingletonService extends SqbEntityService {
+    /**
+     * 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, options) {
+        super(dataType, options);
+        this.id = this.id || options?.id || 1;
+    }
+    /**
+     * 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.
+     */
+    async assert(options) {
+        if (!(await this.exists(options)))
+            throw new ResourceNotAvailableError(this.getResourceName());
+    }
+    /**
+     * 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
+     */
+    async create(input, options) {
+        const info = {
+            crud: 'create',
+            method: 'create',
+            byId: false,
+            input,
+            options,
+        };
+        return this._intercept(async () => {
+            const primaryFields = EntityMetadata.getPrimaryIndexColumns(this.entityMetadata);
+            const data = { ...input };
+            if (primaryFields.length > 1) {
+                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);
+    }
+    /**
+     * Deletes the singleton record
+     *
+     * @param {SqbSingletonService.DeleteOptions} [options] - The options object
+     * @return {Promise<number>} - A Promise that resolves to the number of records deleted
+     */
+    async delete(options) {
+        const info = {
+            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);
+    }
+    /**
+     * 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.
+     */
+    async exists(options) {
+        const info = {
+            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);
+    }
+    /**
+     * 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.
+     */
+    async find(options) {
+        const info = {
+            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);
+    }
+    /**
+     * 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.
+     */
+    async get(options) {
+        const out = await this.find(options);
+        if (!out)
+            throw new ResourceNotAvailableError(this.getResourceName());
+        return out;
+    }
+    /**
+     * 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.
+     */
+    async update(input, options) {
+        const info = {
+            crud: 'update',
+            method: 'update',
+            documentId: this.id,
+            byId: true,
+            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);
+    }
+    /**
+     * 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.
+     */
+    async updateOnly(input, options) {
+        const info = {
+            crud: 'update',
+            method: 'update',
+            documentId: this.id,
+            byId: true,
+            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);
+    }
+}