@sqb/connect 4.14.0 → 4.15.0

package/esm/orm/repository.class.js

@@ -1,12 +1,19 @@
-import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
-import { SqbConnection } from '../client/sqb-connection.js';
-import { CountCommand } from './commands/count.command.js';
-import { CreateCommand } from './commands/create.command.js';
-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';
-export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = void 0;
+const strict_typed_events_1 = require("strict-typed-events");
+const sqb_connection_js_1 = require("../client/sqb-connection.js");
+const count_command_js_1 = require("./commands/count.command.js");
+const create_command_js_1 = require("./commands/create.command.js");
+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();
         this._executor = executor;
@@ -19,29 +26,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,29 +106,38 @@ 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;
-        if (!connection && this._executor instanceof SqbConnection)
+        if (!connection && this._executor instanceof sqb_connection_js_1.SqbConnection)
             connection = this._executor;
         if (connection) {
             if (this._schema)
@@ -93,7 +154,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     async _create(values, options) {
         if (!values)
             throw new TypeError('You must provide values');
-        const keyValues = await CreateCommand.execute({
+        const keyValues = await create_command_js_1.CreateCommand.execute({
             ...options,
             entity: this._entity,
             values,
@@ -103,7 +164,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         return keyValues;
     }
     async _exists(keyValue, options) {
-        const filter = [extractKeyValues(this._entity, keyValue, true)];
+        const filter = [(0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true)];
         if (options && options.filter) {
             if (Array.isArray(options.filter))
                 filter.push(...options.filter);
@@ -123,7 +184,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             else
                 filter.push(options.filter);
         }
-        const resp = await FindCommand.execute({
+        const resp = await find_command_js_1.FindCommand.execute({
             ...options,
             filter,
             entity: this._entity,
@@ -131,13 +192,13 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         return resp.length > 0;
     }
     async _count(options) {
-        return CountCommand.execute({
+        return count_command_js_1.CountCommand.execute({
             ...options,
             entity: this._entity,
         });
     }
     async _findMany(options) {
-        return await FindCommand.execute({
+        return await find_command_js_1.FindCommand.execute({
             ...options,
             entity: this._entity,
         });
@@ -150,7 +211,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         return rows && rows[0];
     }
     async _find(keyValue, options) {
-        const filter = [extractKeyValues(this._entity, keyValue, true)];
+        const filter = [(0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true)];
         if (options && options.filter) {
             if (Array.isArray(options.filter))
                 filter.push(...options.filter);
@@ -160,21 +221,21 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         return await this._findOne({ ...options, filter, offset: 0 });
     }
     async _delete(keyValue, options) {
-        const filter = [extractKeyValues(this._entity, keyValue, true)];
+        const filter = [(0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true)];
         if (options && options.filter) {
             if (Array.isArray(options.filter))
                 filter.push(...options.filter);
             else
                 filter.push(options.filter);
         }
-        return !!(await DeleteCommand.execute({
+        return !!(await delete_command_js_1.DeleteCommand.execute({
             ...options,
             filter,
             entity: this._entity,
         }));
     }
     async _deleteMany(options) {
-        return DeleteCommand.execute({
+        return delete_command_js_1.DeleteCommand.execute({
             ...options,
             entity: this._entity,
             filter: options?.filter,
@@ -184,7 +245,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     async _update(keyValue, values, options) {
         if (!values)
             throw new TypeError('You must provide values');
-        const keyValues = extractKeyValues(this._entity, keyValue, true);
+        const keyValues = (0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true);
         const filter = [keyValues];
         if (options.filter) {
             if (Array.isArray(options.filter))
@@ -194,7 +255,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         }
         const updateValues = { ...values };
         Object.keys(keyValues).forEach(k => delete updateValues[k]);
-        const rowsAffected = await UpdateCommand.execute({
+        const rowsAffected = await update_command_js_1.UpdateCommand.execute({
             ...options,
             entity: this._entity,
             values: updateValues,
@@ -205,10 +266,11 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     async _updateMany(values, options) {
         if (!values)
             throw new TypeError('You must provide values');
-        return await UpdateCommand.execute({
+        return await update_command_js_1.UpdateCommand.execute({
             ...options,
             entity: this._entity,
             values,
         });
     }
 }
+exports.Repository = Repository;

package/esm/orm/util/apply-mixins.js

@@ -1,4 +1,7 @@
-export function applyMixins(derivedCtor, baseCtor, filter) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyMixins = applyMixins;
+function applyMixins(derivedCtor, baseCtor, filter) {
     for (const name of Object.getOwnPropertyNames(baseCtor.prototype)) {
         if (name === 'constructor' ||
             name === '__proto__' ||

package/esm/orm/util/extract-keyvalues.js

@@ -1,14 +1,17 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-import { isColumnField } from './orm.helper.js';
-export function extractKeyValues(entityDef, valueOrInstance, keepOther) {
-    const primaryIndex = EntityMetadata.getPrimaryIndex(entityDef);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractKeyValues = extractKeyValues;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+const orm_helper_js_1 = require("./orm.helper.js");
+function extractKeyValues(entityDef, valueOrInstance, keepOther) {
+    const primaryIndex = entity_metadata_js_1.EntityMetadata.getPrimaryIndex(entityDef);
     if (!primaryIndex)
         throw new Error(`No primary fields defined for "${entityDef.name}" entity`);
     const validateCol = k => {
-        const col = EntityMetadata.getField(entityDef, k);
+        const col = entity_metadata_js_1.EntityMetadata.getField(entityDef, k);
         if (!col)
             throw new Error(`Unknown column (${k}) defined as primary key in entity "${entityDef.name}"`);
-        if (!isColumnField(col)) {
+        if (!(0, orm_helper_js_1.isColumnField)(col)) {
             throw new Error(`Column (${k}) defined as primary key in entity "${entityDef.name}" is not a data column`);
         }
     };

package/esm/orm/util/orm.helper.js

@@ -1,16 +1,26 @@
-import { ENTITY_METADATA_KEY } from '../orm.const.js';
-export function isClass(fn) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssociationField = exports.isEmbeddedField = void 0;
+exports.isClass = isClass;
+exports.isEntityClass = isEntityClass;
+exports.isColumnField = isColumnField;
+exports.resolveEntity = resolveEntity;
+exports.resolveEntityMeta = resolveEntityMeta;
+const orm_const_js_1 = require("../orm.const.js");
+function isClass(fn) {
     return typeof fn === 'function' && /^\s*class/.test(fn.toString());
 }
-export function isEntityClass(fn) {
-    return isClass(fn) && Reflect.hasMetadata(ENTITY_METADATA_KEY, fn);
+function isEntityClass(fn) {
+    return isClass(fn) && Reflect.hasMetadata(orm_const_js_1.ENTITY_METADATA_KEY, fn);
 }
-export function isColumnField(f) {
+function isColumnField(f) {
     return !!(f && f.name && f.kind === 'column');
 }
-export const isEmbeddedField = (f) => !!(f && f.name && f.kind === 'object');
-export const isAssociationField = (f) => !!(f && f.name && f.kind === 'association');
-export async function resolveEntity(ctorThunk) {
+const isEmbeddedField = (f) => !!(f && f.name && f.kind === 'object');
+exports.isEmbeddedField = isEmbeddedField;
+const isAssociationField = (f) => !!(f && f.name && f.kind === 'association');
+exports.isAssociationField = isAssociationField;
+async function resolveEntity(ctorThunk) {
     if (typeof ctorThunk !== 'function')
         return;
     if (!isClass(ctorThunk))
@@ -18,7 +28,7 @@ export async function resolveEntity(ctorThunk) {
     if (isEntityClass(ctorThunk))
         return ctorThunk;
 }
-export async function resolveEntityMeta(ctorThunk) {
+async function resolveEntityMeta(ctorThunk) {
     const ctor = await resolveEntity(ctorThunk);
-    return ctor && Reflect.getMetadata(ENTITY_METADATA_KEY, ctor);
+    return ctor && Reflect.getMetadata(orm_const_js_1.ENTITY_METADATA_KEY, ctor);
 }

package/esm/orm/util/parse-fields-projection.js

@@ -1,14 +1,19 @@
-import { splitString } from 'fast-tokenizer';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldsProjection = void 0;
+exports.parseFieldsProjection = parseFieldsProjection;
+const fast_tokenizer_1 = require("fast-tokenizer");
 const FIELD_PATTERN = /^([+-])?([a-z_$]\w*)$/i;
 const NO_DOT_BRACKET_PATTERN = /[^.]\(/g;
-export class FieldsProjection {
+class FieldsProjection {
 }
+exports.FieldsProjection = FieldsProjection;
 (function (FieldsProjection) {
     class Item {
     }
     FieldsProjection.Item = Item;
-})(FieldsProjection || (FieldsProjection = {}));
-export function parseFieldsProjection(projection, keepCase) {
+})(FieldsProjection || (exports.FieldsProjection = FieldsProjection = {}));
+function parseFieldsProjection(projection, keepCase) {
     const arr = Array.isArray(projection) ? projection : [projection];
     if (!(arr && arr.length))
         return;
@@ -23,7 +28,7 @@ export function parseFieldsProjection(projection, keepCase) {
 function parse(input, target) {
     /** Add dot before brackets which is required to split fields */
     input = input.replace(NO_DOT_BRACKET_PATTERN, s => s.charAt(0) + '.' + s.substring(1));
-    const fields = splitString(input, {
+    const fields = (0, fast_tokenizer_1.splitString)(input, {
         delimiters: '.',
         brackets: true,
         keepBrackets: false,
@@ -31,7 +36,7 @@ function parse(input, target) {
     for (let i = 0; i < fields.length; i++) {
         const f = fields[i];
         if (f.includes(',')) {
-            const subFields = splitString(f, {
+            const subFields = (0, fast_tokenizer_1.splitString)(f, {
                 delimiters: ',',
                 brackets: true,
                 keepBrackets: true,

package/esm/orm/util/serialize-field.js

@@ -1,13 +1,16 @@
-import { DataType } from '@sqb/builder';
-import { isColumnField } from './orm.helper.js';
-export function serializeColumn(col, v) {
-    if (isColumnField(col)) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeColumn = serializeColumn;
+const builder_1 = require("@sqb/builder");
+const orm_helper_js_1 = require("./orm.helper.js");
+function serializeColumn(col, v) {
+    if ((0, orm_helper_js_1.isColumnField)(col)) {
         if (col.isArray) {
             if (Array.isArray(v))
-                return v.map(x => serializeDataValue(col.dataType || DataType.VARCHAR, x));
-            return [serializeDataValue(col.dataType || DataType.VARCHAR, v)];
+                return v.map(x => serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, x));
+            return [serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, v)];
         }
-        return serializeDataValue(col.dataType || DataType.VARCHAR, v);
+        return serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, v);
     }
     if (typeof v === 'object' && typeof v.toJSON === 'function')
         return v.toJSON();
@@ -17,19 +20,19 @@ const padZero = (n) => (n < 9 ? '0' : '') + n;
 function serializeDataValue(dataType, v) {
     if (v == null)
         return;
-    if (v instanceof Date && (dataType === DataType.DATE || dataType === DataType.TIMESTAMP)) {
+    if (v instanceof Date && (dataType === builder_1.DataType.DATE || dataType === builder_1.DataType.TIMESTAMP)) {
         return (v.getFullYear() +
             '-' +
             padZero(v.getMonth() + 1) +
             '-' +
             padZero(v.getDate()) +
-            (dataType === DataType.TIMESTAMP
+            (dataType === builder_1.DataType.TIMESTAMP
                 ? 'T' + padZero(v.getHours()) + ':' + padZero(v.getMinutes()) + ':' + padZero(v.getSeconds())
                 : ''));
     }
     if (v instanceof Buffer)
         return v.toString('base64');
-    if (typeof v === 'number' && (dataType === DataType.SMALLINT || dataType === DataType.INTEGER))
+    if (typeof v === 'number' && (dataType === builder_1.DataType.SMALLINT || dataType === builder_1.DataType.INTEGER))
         return Math.trunc(v);
     if (typeof v === 'bigint')
         return v.toString();

package/package.json

@@ -1,29 +1,16 @@
 {
   "name": "@sqb/connect",
   "description": "Multi-dialect database connection framework written with TypeScript",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "author": "Panates",
-  "contributors": [
-    "Eray Hanoglu <e.hanoglu@panates.com>",
-    "Ilker Gurelli <i.gurelli@panates.com>"
-  ],
   "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/sqbjs/sqb.git",
-    "directory": "packages/connect"
-  },
-  "type": "module",
-  "module": "./esm/index.js",
-  "main": "./cjs/index.js",
-  "types": "./types/index.d.ts",
   "scripts": {
     "compile": "tsc",
     "prebuild": "npm run lint && npm run clean",
     "build": "npm run build:cjs && npm run build:esm",
     "build:cjs": "tsc -b tsconfig-build-cjs.json",
     "build:esm": "tsc -b tsconfig-build-esm.json",
-    "postbuild": "cp README.md package.json ../../LICENSE ../../build/connect && cp ../../package.cjs.json ../../build/connect/cjs/package.json",
+    "postbuild": "cp README.md package.json ../../LICENSE ../../build/connect",
     "lint": "eslint . --max-warnings=0",
     "lint:fix": "eslint . --max-warnings=0 --fix",
     "format": "prettier . --write --log-level=warn",
@@ -35,28 +22,47 @@
     "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",
+    "fast-tokenizer": "^1.4.0",
+    "lightning-pool": "^4.5.0",
     "lodash": "^4.17.21",
-    "power-tasks": "^1.7.4",
+    "power-tasks": "^1.8.0",
     "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",
-    "ts-gems": "^3.4.0"
+    "strict-typed-events": "^2.5.0",
+    "ts-gems": "^3.5.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
     "@types/lodash": "^4.17.7",
-    "postgrejs": "^2.15.1"
+    "postgrejs": "^2.16.0"
   },
   "peerDependencies": {
-    "@sqb/builder": "^4.14.0",
+    "@sqb/builder": "^4.15.0",
     "reflect-metadata": "^0.2.2"
   },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "import": "./esm/index.js",
+      "types": "./types/index.d.ts"
+    }
+  },
+  "contributors": [
+    "Eray Hanoglu <e.hanoglu@panates.com>",
+    "Ilker Gurelli <i.gurelli@panates.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sqbjs/sqb.git",
+    "directory": "packages/connect"
+  },
   "engines": {
     "node": ">=16.0",
     "npm": ">=7.0.0"