@sqb/connect 4.13.0 → 4.14.1

package/cjs/client/sqb-connection.js

@@ -78,7 +78,7 @@ class SqbConnection extends (0, strict_typed_events_1.TypedEventEmitterClass)(st
         await this.emitAsyncSerial('close');
         const intlcon = this._intlcon;
         this._intlcon = undefined;
-        this.client.pool.release(intlcon, e => {
+        this.client.pool.release(intlcon, (e) => {
             if (e)
                 this.client.emit('error', e);
         });

package/cjs/orm/repository.class.js

@@ -9,6 +9,10 @@ const delete_command_js_1 = require("./commands/delete.command.js");
 const find_command_js_1 = require("./commands/find.command.js");
 const update_command_js_1 = require("./commands/update.command.js");
 const extract_keyvalues_js_1 = require("./util/extract-keyvalues.js");
+/**
+ * @class Repository
+ * @template T - The data type class type of the record
+ */
 class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_typed_events_1.AsyncEventEmitter) {
     constructor(entityDef, executor, schema) {
         super();
@@ -22,29 +26,74 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
     get type() {
         return this._entity.ctor;
     }
-    create(values, options) {
+    create(input, options) {
         return this._execute(async (connection) => {
-            const keyValue = await this._create(values, { ...options, connection, returning: true });
+            const keyValue = await this._create(input, { ...options, connection, returning: true });
             const result = keyValue && (await this._find(keyValue, { ...options, connection }));
             if (!result)
                 throw new Error('Unable to insert new row');
             return result;
         }, options);
     }
-    createOnly(values, options) {
+    /**
+     * Creates a new resource but returns nothing
+     *
+     * @param {PartialDTO<T>} input - The input data
+     * @param {Repository.CreateOptions} [options] - The options object
+     * @throws {Error} if an unknown error occurs while creating the resource
+     */
+    createOnly(input, options) {
         return this._execute(async (connection) => {
-            await this._create(values, { ...options, connection, returning: false });
+            await this._create(input, { ...options, connection, returning: false });
         }, options);
     }
+    /**
+     * Returns the count of records based on the provided options
+     *
+     * @param {Repository.CountOptions} options - The options for the count operation.
+     * @return {Promise<number>} - A promise that resolves to the count of records
+     */
+    count(options) {
+        return this._execute(async (connection) => this._count({ ...options, connection }), options);
+    }
+    /**
+     * Deletes a record from the collection.
+     *
+     * @param {any} keyValue - The ID of the resource to delete.
+     * @param {Repository.DeleteOptions} [options] - Optional delete options.
+     * @return {Promise<boolean>} - A Promise that resolves true or false. True when resource deleted.
+     */
+    delete(keyValue, options) {
+        return this._execute(async (connection) => this._delete(keyValue, { ...options, connection }), options);
+    }
+    /**
+     * Deletes multiple documents from the collection that meet the specified filter criteria.
+     *
+     * @param {Repository.DeleteManyOptions} options - The options for the delete operation.
+     * @return {Promise<number>} - A promise that resolves to the number of resources deleted.
+     */
+    deleteMany(options) {
+        return this._execute(async (connection) => this._deleteMany({ ...options, connection }), options);
+    }
+    /**
+     * Checks if a record with the given id exists.
+     *
+     * @param {any} keyValue - The id of the object to check.
+     * @param {Repository.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(keyValue, options) {
         return this._execute(async (connection) => this._exists(keyValue, { ...options, connection }), options);
     }
+    /**
+     * Checks if a record with the given arguments exists.
+     *
+     * @param {Repository.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.
+     */
     existsOne(options) {
         return this._execute(async (connection) => this._existsOne({ ...options, connection }), options);
     }
-    count(options) {
-        return this._execute(async (connection) => this._count({ ...options, connection }), options);
-    }
     findById(keyValue, options) {
         return this._execute(async (connection) => this._find(keyValue, { ...options, connection }), options);
     }
@@ -57,25 +106,34 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
     findMany(options) {
         return this._execute(async (connection) => this._findMany({ ...options, connection }), options);
     }
-    delete(keyValue, options) {
-        return this._execute(async (connection) => this._delete(keyValue, { ...options, connection }), options);
-    }
-    deleteMany(options) {
-        return this._execute(async (connection) => this._deleteMany({ ...options, connection }), options);
-    }
-    update(keyValue, values, options) {
+    update(keyValue, input, options) {
         return this._execute(async (connection) => {
             const opts = { ...options, connection };
-            const keyValues = await this._update(keyValue, values, opts);
+            const keyValues = await this._update(keyValue, input, opts);
             if (keyValues)
                 return this._find(keyValues, opts);
         }, options);
     }
-    updateOnly(keyValue, values, options) {
-        return this._execute(async (connection) => !!(await this._update(keyValue, values, { ...options, connection })), options);
+    /**
+     * Updates a record in the collection with the specified ID and returns updated record count
+     *
+     * @param {any} keyValue - The ID of the document to update.
+     * @param {PatchDTO<T>} input - The partial input data to update the document with.
+     * @param {Repository.UpdateOptions} options - The options for updating the document.
+     * @returns {Promise<number>} - A Promise that resolves true or false. True when resource updated.
+     */
+    updateOnly(keyValue, input, options) {
+        return this._execute(async (connection) => !!(await this._update(keyValue, input, { ...options, connection })), options);
     }
-    updateMany(values, options) {
-        return this._execute(async (connection) => this._updateMany(values, { ...options, connection }));
+    /**
+     * 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 {Repository.UpdateManyOptions} options - The options for updating the documents.
+     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     */
+    updateMany(input, options) {
+        return this._execute(async (connection) => this._updateMany(input, { ...options, connection }));
     }
     async _execute(fn, opts) {
         let connection = opts?.connection;

package/esm/client/sqb-connection.js

@@ -74,7 +74,7 @@ export class SqbConnection extends TypedEventEmitterClass(AsyncEventEmitter) {
         await this.emitAsyncSerial('close');
         const intlcon = this._intlcon;
         this._intlcon = undefined;
-        this.client.pool.release(intlcon, e => {
+        this.client.pool.release(intlcon, (e) => {
             if (e)
                 this.client.emit('error', e);
         });

package/esm/orm/repository.class.js

@@ -6,6 +6,10 @@ import { DeleteCommand } from './commands/delete.command.js';
 import { FindCommand } from './commands/find.command.js';
 import { UpdateCommand } from './commands/update.command.js';
 import { extractKeyValues } from './util/extract-keyvalues.js';
+/**
+ * @class Repository
+ * @template T - The data type class type of the record
+ */
 export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     constructor(entityDef, executor, schema) {
         super();
@@ -19,29 +23,74 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     get type() {
         return this._entity.ctor;
     }
-    create(values, options) {
+    create(input, options) {
         return this._execute(async (connection) => {
-            const keyValue = await this._create(values, { ...options, connection, returning: true });
+            const keyValue = await this._create(input, { ...options, connection, returning: true });
             const result = keyValue && (await this._find(keyValue, { ...options, connection }));
             if (!result)
                 throw new Error('Unable to insert new row');
             return result;
         }, options);
     }
-    createOnly(values, options) {
+    /**
+     * Creates a new resource but returns nothing
+     *
+     * @param {PartialDTO<T>} input - The input data
+     * @param {Repository.CreateOptions} [options] - The options object
+     * @throws {Error} if an unknown error occurs while creating the resource
+     */
+    createOnly(input, options) {
         return this._execute(async (connection) => {
-            await this._create(values, { ...options, connection, returning: false });
+            await this._create(input, { ...options, connection, returning: false });
         }, options);
     }
+    /**
+     * Returns the count of records based on the provided options
+     *
+     * @param {Repository.CountOptions} options - The options for the count operation.
+     * @return {Promise<number>} - A promise that resolves to the count of records
+     */
+    count(options) {
+        return this._execute(async (connection) => this._count({ ...options, connection }), options);
+    }
+    /**
+     * Deletes a record from the collection.
+     *
+     * @param {any} keyValue - The ID of the resource to delete.
+     * @param {Repository.DeleteOptions} [options] - Optional delete options.
+     * @return {Promise<boolean>} - A Promise that resolves true or false. True when resource deleted.
+     */
+    delete(keyValue, options) {
+        return this._execute(async (connection) => this._delete(keyValue, { ...options, connection }), options);
+    }
+    /**
+     * Deletes multiple documents from the collection that meet the specified filter criteria.
+     *
+     * @param {Repository.DeleteManyOptions} options - The options for the delete operation.
+     * @return {Promise<number>} - A promise that resolves to the number of resources deleted.
+     */
+    deleteMany(options) {
+        return this._execute(async (connection) => this._deleteMany({ ...options, connection }), options);
+    }
+    /**
+     * Checks if a record with the given id exists.
+     *
+     * @param {any} keyValue - The id of the object to check.
+     * @param {Repository.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(keyValue, options) {
         return this._execute(async (connection) => this._exists(keyValue, { ...options, connection }), options);
     }
+    /**
+     * Checks if a record with the given arguments exists.
+     *
+     * @param {Repository.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.
+     */
     existsOne(options) {
         return this._execute(async (connection) => this._existsOne({ ...options, connection }), options);
     }
-    count(options) {
-        return this._execute(async (connection) => this._count({ ...options, connection }), options);
-    }
     findById(keyValue, options) {
         return this._execute(async (connection) => this._find(keyValue, { ...options, connection }), options);
     }
@@ -54,25 +103,34 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     findMany(options) {
         return this._execute(async (connection) => this._findMany({ ...options, connection }), options);
     }
-    delete(keyValue, options) {
-        return this._execute(async (connection) => this._delete(keyValue, { ...options, connection }), options);
-    }
-    deleteMany(options) {
-        return this._execute(async (connection) => this._deleteMany({ ...options, connection }), options);
-    }
-    update(keyValue, values, options) {
+    update(keyValue, input, options) {
         return this._execute(async (connection) => {
             const opts = { ...options, connection };
-            const keyValues = await this._update(keyValue, values, opts);
+            const keyValues = await this._update(keyValue, input, opts);
             if (keyValues)
                 return this._find(keyValues, opts);
         }, options);
     }
-    updateOnly(keyValue, values, options) {
-        return this._execute(async (connection) => !!(await this._update(keyValue, values, { ...options, connection })), options);
+    /**
+     * Updates a record in the collection with the specified ID and returns updated record count
+     *
+     * @param {any} keyValue - The ID of the document to update.
+     * @param {PatchDTO<T>} input - The partial input data to update the document with.
+     * @param {Repository.UpdateOptions} options - The options for updating the document.
+     * @returns {Promise<number>} - A Promise that resolves true or false. True when resource updated.
+     */
+    updateOnly(keyValue, input, options) {
+        return this._execute(async (connection) => !!(await this._update(keyValue, input, { ...options, connection })), options);
     }
-    updateMany(values, options) {
-        return this._execute(async (connection) => this._updateMany(values, { ...options, connection }));
+    /**
+     * 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 {Repository.UpdateManyOptions} options - The options for updating the documents.
+     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     */
+    updateMany(input, options) {
+        return this._execute(async (connection) => this._updateMany(input, { ...options, connection }));
     }
     async _execute(fn, opts) {
         let connection = opts?.connection;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/connect",
   "description": "Multi-dialect database connection framework written with TypeScript",
-  "version": "4.13.0",
+  "version": "4.14.1",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>",
@@ -35,26 +35,26 @@
     "clean:cover": "rimraf ../../coverage/connect"
   },
   "dependencies": {
-    "debug": "^4.3.5",
+    "debug": "^4.3.6",
     "doublylinked": "^2.5.4",
     "fast-tokenizer": "^1.3.0",
-    "lightning-pool": "^4.2.2",
+    "lightning-pool": "^4.4.3",
     "lodash": "^4.17.21",
-    "power-tasks": "^1.7.4",
+    "power-tasks": "^1.7.7",
     "putil-isplainobject": "^1.1.5",
-    "putil-merge": "^3.12.1",
+    "putil-merge": "^3.13.0",
     "putil-promisify": "^1.10.1",
     "putil-varhelpers": "^1.6.5",
-    "strict-typed-events": "^2.3.3",
+    "strict-typed-events": "^2.4.0",
     "ts-gems": "^3.4.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
     "@types/lodash": "^4.17.7",
-    "postgresql-client": "^2.12.0"
+    "postgrejs": "^2.15.4"
   },
   "peerDependencies": {
-    "@sqb/builder": "^4.13.0",
+    "@sqb/builder": "^4.14.1",
     "reflect-metadata": "^0.2.2"
   },
   "engines": {

package/types/orm/repository.class.d.ts

@@ -1,5 +1,5 @@
 import { LogicalOperator } from '@sqb/builder';
-import { PartialDTO, PatchDTO, StrictOmit, Type } from 'ts-gems';
+import { PartialDTO, PatchDTO, RequiredSome, StrictOmit, Type } from 'ts-gems';
 import { FieldInfoMap } from '../client/field-info-map.js';
 import { SqbClient } from '../client/sqb-client.js';
 import { SqbConnection } from '../client/sqb-connection.js';
@@ -54,6 +54,10 @@ interface RepositoryEvents {
     acquire: (connection: SqbConnection) => Promise<void>;
 }
 declare const Repository_base: Type<import("strict-typed-events").TypedEventEmitter<any, RepositoryEvents, RepositoryEvents>>;
+/**
+ * @class Repository
+ * @template T - The data type class type of the record
+ */
 export declare class Repository<T> extends Repository_base {
     private readonly _executor;
     private readonly _entity;
@@ -61,19 +65,114 @@ export declare class Repository<T> extends Repository_base {
     constructor(entityDef: EntityMetadata, executor: SqbClient | SqbConnection, schema?: string);
     get entity(): EntityMetadata;
     get type(): Type<T>;
-    create(values: PartialDTO<T>, options?: Repository.CreateOptions): Promise<PartialDTO<T>>;
-    createOnly(values: PartialDTO<T>, options?: StrictOmit<Repository.CreateOptions, keyof Projection>): Promise<void>;
-    exists(keyValue: any | Record<string, any>, options?: Repository.ExistsOptions): Promise<boolean>;
-    existsOne(options?: Repository.ExistsOptions): Promise<boolean>;
+    /**
+     * Creates a new resource
+     *
+     * @param {PartialDTO<T>} input - The input data
+     * @param {Repository.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: RequiredSome<Repository.CreateOptions, 'projection'>): Promise<PartialDTO<T>>;
+    create(input: PartialDTO<T>, options?: Repository.CreateOptions): Promise<T>;
+    /**
+     * Creates a new resource but returns nothing
+     *
+     * @param {PartialDTO<T>} input - The input data
+     * @param {Repository.CreateOptions} [options] - The options object
+     * @throws {Error} if an unknown error occurs while creating the resource
+     */
+    createOnly(input: PartialDTO<T>, options?: StrictOmit<Repository.CreateOptions, keyof Projection>): Promise<void>;
+    /**
+     * Returns the count of records based on the provided options
+     *
+     * @param {Repository.CountOptions} options - The options for the count operation.
+     * @return {Promise<number>} - A promise that resolves to the count of records
+     */
     count(options?: Repository.CountOptions): Promise<number>;
-    findById(keyValue: any | Record<string, any>, options?: Repository.FindOptions): Promise<PartialDTO<T> | undefined>;
-    findOne(options?: Repository.FindOneOptions): Promise<PartialDTO<T> | undefined>;
-    findMany(options?: Repository.FindManyOptions): Promise<PartialDTO<T>[]>;
+    /**
+     * Deletes a record from the collection.
+     *
+     * @param {any} keyValue - The ID of the resource to delete.
+     * @param {Repository.DeleteOptions} [options] - Optional delete options.
+     * @return {Promise<boolean>} - A Promise that resolves true or false. True when resource deleted.
+     */
     delete(keyValue: any | Record<string, any>, options?: Repository.DeleteOptions): Promise<boolean>;
+    /**
+     * Deletes multiple documents from the collection that meet the specified filter criteria.
+     *
+     * @param {Repository.DeleteManyOptions} options - The options for the delete operation.
+     * @return {Promise<number>} - A promise that resolves to the number of resources deleted.
+     */
     deleteMany(options?: Repository.DeleteManyOptions): Promise<number>;
-    update(keyValue: any | Record<string, any>, values: PatchDTO<T>, options?: Repository.UpdateOptions): Promise<PartialDTO<T> | undefined>;
-    updateOnly(keyValue: any | Record<string, any>, values: PatchDTO<T>, options?: Repository.UpdateOnlyOptions): Promise<boolean>;
-    updateMany(values: PartialDTO<T>, options?: Repository.UpdateManyOptions): Promise<number>;
+    /**
+     * Checks if a record with the given id exists.
+     *
+     * @param {any} keyValue - The id of the object to check.
+     * @param {Repository.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(keyValue: any | Record<string, any>, options?: Repository.ExistsOptions): Promise<boolean>;
+    /**
+     * Checks if a record with the given arguments exists.
+     *
+     * @param {Repository.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.
+     */
+    existsOne(options?: Repository.ExistsOptions): Promise<boolean>;
+    /**
+     * Finds a record by ID.
+     *
+     * @param {any} keyValue - The ID of the record.
+     * @param {Repository.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(keyValue: any | Record<string, any>, options: RequiredSome<Repository.FindOptions, 'projection'>): Promise<PartialDTO<T> | undefined>;
+    findById(keyValue: any | Record<string, any>, options?: Repository.FindOptions): Promise<T | undefined>;
+    /**
+     * Finds a record in the collection that matches the specified options.
+     *
+     * @param {Repository.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.
+     */
+    findOne(options: RequiredSome<Repository.FindOneOptions, 'projection'>): Promise<PartialDTO<T> | undefined>;
+    findOne(options?: Repository.FindOneOptions): Promise<T | undefined>;
+    /**
+     * Finds multiple records in collection.
+     *
+     * @param {Repository.FindManyOptions} options - The options for the find operation.
+     * @return A Promise that resolves to an array of partial outputs of type T.
+     */
+    findMany(options: RequiredSome<Repository.FindManyOptions, 'projection'>): Promise<PartialDTO<T>[]>;
+    findMany(options?: Repository.FindManyOptions): Promise<T[]>;
+    /**
+     * Updates a record with the given id in the collection.
+     *
+     * @param {any} keyValue - The id of the document to update.
+     * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
+     * @param {Repository.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(keyValue: any | Record<string, any>, input: PatchDTO<T>, options: RequiredSome<Repository.UpdateOptions, 'projection'>): Promise<PartialDTO<T> | undefined>;
+    update(keyValue: any | Record<string, any>, input: PatchDTO<T>, options?: Repository.UpdateOptions): Promise<T | undefined>;
+    /**
+     * Updates a record in the collection with the specified ID and returns updated record count
+     *
+     * @param {any} keyValue - The ID of the document to update.
+     * @param {PatchDTO<T>} input - The partial input data to update the document with.
+     * @param {Repository.UpdateOptions} options - The options for updating the document.
+     * @returns {Promise<number>} - A Promise that resolves true or false. True when resource updated.
+     */
+    updateOnly(keyValue: any | Record<string, any>, input: PatchDTO<T>, options?: Repository.UpdateOnlyOptions): 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 {Repository.UpdateManyOptions} options - The options for updating the documents.
+     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     */
+    updateMany(input: PartialDTO<T>, options?: Repository.UpdateManyOptions): Promise<number>;
     protected _execute(fn: TransactionFunction, opts?: Repository.CommandOptions): Promise<any>;
     protected _create(values: PartialDTO<T>, options: Repository.CreateOptions & {
         connection: SqbConnection;