@sqb/connect 4.14.0 → 4.15.0

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/adapter.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/client/cursor-stream.js

@@ -1,8 +1,12 @@
-import _debug from 'debug';
-import { Readable } from 'stream';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorStream = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const stream_1 = require("stream");
 const inspect = Symbol.for('nodejs.util.inspect.custom');
-const debug = _debug('sqb:cursorstream');
-export class CursorStream extends Readable {
+const debug = (0, debug_1.default)('sqb:cursorstream');
+class CursorStream extends stream_1.Readable {
     constructor(cursor, options) {
         super(options);
         this._rowNum = -1;
@@ -94,3 +98,4 @@ export class CursorStream extends Readable {
         }
     }
 }
+exports.CursorStream = CursorStream;

package/esm/client/cursor.js

@@ -1,16 +1,20 @@
-import _debug from 'debug';
-import DoublyLinked from 'doublylinked';
-import { TaskQueue } from 'power-tasks';
-import { coerceToInt } from 'putil-varhelpers';
-import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
-import { CursorStream } from './cursor-stream.js';
-import { callFetchHooks, normalizeRowsToArrayRows, normalizeRowsToObjectRows } from './helpers.js';
-const debug = _debug('sqb:cursor');
-export class Cursor extends TypedEventEmitterClass(AsyncEventEmitter) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cursor = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const doublylinked_1 = tslib_1.__importDefault(require("doublylinked"));
+const power_tasks_1 = require("power-tasks");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const strict_typed_events_1 = require("strict-typed-events");
+const cursor_stream_js_1 = require("./cursor-stream.js");
+const helpers_js_1 = require("./helpers.js");
+const debug = (0, debug_1.default)('sqb:cursor');
+class Cursor extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_typed_events_1.AsyncEventEmitter) {
     constructor(connection, fields, adapterCursor, request) {
         super();
-        this._taskQueue = new TaskQueue();
-        this._fetchCache = new DoublyLinked();
+        this._taskQueue = new power_tasks_1.TaskQueue();
+        this._fetchCache = new doublylinked_1.default();
         this._rowNum = 0;
         this._fetchedAll = false;
         this._fetchedRows = 0;
@@ -75,7 +79,7 @@ export class Cursor extends TypedEventEmitterClass(AsyncEventEmitter) {
         if (this.fetchedRows)
             throw new Error('Cache can be enabled before fetching rows');
         if (!this._cache)
-            this._cache = new DoublyLinked();
+            this._cache = new doublylinked_1.default();
     }
     /**
      * Closes cursor
@@ -157,7 +161,7 @@ export class Cursor extends TypedEventEmitterClass(AsyncEventEmitter) {
      * Creates and returns a readable stream.
      */
     toStream(options) {
-        return new CursorStream(this, options);
+        return new cursor_stream_js_1.CursorStream(this, options);
     }
     toString() {
         return '[object ' + Object.getPrototypeOf(this).constructor.name + ']';
@@ -169,7 +173,7 @@ export class Cursor extends TypedEventEmitterClass(AsyncEventEmitter) {
      *
      */
     async _seek(step, silent) {
-        step = coerceToInt(step, 0);
+        step = (0, putil_varhelpers_1.coerceToInt)(step, 0);
         if (!step || (step > 0 && this.isClosed))
             return this.rowNum;
         if (step < 0 && !this._cache)
@@ -226,9 +230,9 @@ export class Cursor extends TypedEventEmitterClass(AsyncEventEmitter) {
             debug('Fetched %d rows from database', rows.length);
             // Normalize rows
             rows = this._request.objectRows
-                ? normalizeRowsToObjectRows(this._fields, this._intlcur.rowType, rows, this._request)
-                : normalizeRowsToArrayRows(this._fields, this._intlcur.rowType, rows, this._request);
-            callFetchHooks(rows, this._request);
+                ? (0, helpers_js_1.normalizeRowsToObjectRows)(this._fields, this._intlcur.rowType, rows, this._request)
+                : (0, helpers_js_1.normalizeRowsToArrayRows)(this._fields, this._intlcur.rowType, rows, this._request);
+            (0, helpers_js_1.callFetchHooks)(rows, this._request);
             for (const [idx, row] of rows.entries()) {
                 this.emit('fetch', row, this._rowNum + idx + 1);
             }
@@ -245,3 +249,4 @@ export class Cursor extends TypedEventEmitterClass(AsyncEventEmitter) {
         return this.close();
     }
 }
+exports.Cursor = Cursor;

package/esm/client/extensions.js

@@ -1,4 +1,7 @@
-export class AdapterRegistry {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdapterRegistry = void 0;
+class AdapterRegistry {
     static get size() {
         return this.adapters.length;
     }
@@ -34,4 +37,5 @@ export class AdapterRegistry {
         return !!this.adapters.find(x => x === extension);
     }
 }
+exports.AdapterRegistry = AdapterRegistry;
 AdapterRegistry.adapters = [];

package/esm/client/field-info-map.js

@@ -1,4 +1,7 @@
-export class FieldInfoMap {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldInfoMap = void 0;
+class FieldInfoMap {
     constructor() {
         Object.defineProperty(this, '_obj', {
             enumerable: false,
@@ -46,3 +49,4 @@ export class FieldInfoMap {
         return { ...this._obj };
     }
 }
+exports.FieldInfoMap = FieldInfoMap;

package/esm/client/helpers.js

@@ -1,6 +1,13 @@
-import { camelCase, pascalCase } from 'putil-varhelpers';
-import { FieldInfoMap } from './field-info-map.js';
-export function applyNamingStrategy(value, namingStrategy) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyNamingStrategy = applyNamingStrategy;
+exports.wrapAdapterFields = wrapAdapterFields;
+exports.normalizeRowsToObjectRows = normalizeRowsToObjectRows;
+exports.normalizeRowsToArrayRows = normalizeRowsToArrayRows;
+exports.callFetchHooks = callFetchHooks;
+const putil_varhelpers_1 = require("putil-varhelpers");
+const field_info_map_js_1 = require("./field-info-map.js");
+function applyNamingStrategy(value, namingStrategy) {
     if (typeof namingStrategy === 'string' && namingStrategy !== 'original') {
         switch (namingStrategy.toLowerCase()) {
             case 'lowercase':
@@ -9,13 +16,13 @@ export function applyNamingStrategy(value, namingStrategy) {
                 return value.toUpperCase();
             case 'camelcase':
                 if (!value.match(/[a-z]/))
-                    return camelCase(value.toLowerCase());
-                value = camelCase(value);
+                    return (0, putil_varhelpers_1.camelCase)(value.toLowerCase());
+                value = (0, putil_varhelpers_1.camelCase)(value);
                 return value[0].toLowerCase() + value.substring(1);
             case 'pascalcase':
                 if (!value.match(/[a-z]/))
-                    return pascalCase(value.toLowerCase());
-                return pascalCase(value);
+                    return (0, putil_varhelpers_1.pascalCase)(value.toLowerCase());
+                return (0, putil_varhelpers_1.pascalCase)(value);
             default:
                 break;
         }
@@ -24,13 +31,13 @@ export function applyNamingStrategy(value, namingStrategy) {
         return namingStrategy(value);
     return value;
 }
-export function wrapAdapterFields(oldFields, fieldNaming) {
+function wrapAdapterFields(oldFields, fieldNaming) {
     const mapFieldInfo = (f, index) => {
         const name = applyNamingStrategy(f.fieldName, fieldNaming);
         if (name)
             return { ...f, name, index };
     };
-    const result = new FieldInfoMap();
+    const result = new field_info_map_js_1.FieldInfoMap();
     let i = 0;
     oldFields.forEach(f => {
         const x = mapFieldInfo(f, i);
@@ -41,10 +48,10 @@ export function wrapAdapterFields(oldFields, fieldNaming) {
     });
     return result;
 }
-export function normalizeRowsToObjectRows(fields, rowType, oldRows, options) {
+function normalizeRowsToObjectRows(fields, rowType, oldRows, options) {
     return normalizeRows(fields, rowType, oldRows, { ...options, objectRows: true });
 }
-export function normalizeRowsToArrayRows(fields, rowType, oldRows, options) {
+function normalizeRowsToArrayRows(fields, rowType, oldRows, options) {
     return normalizeRows(fields, rowType, oldRows, { ...options, objectRows: false });
 }
 function normalizeRows(fields, rowType, oldRows, options) {
@@ -115,7 +122,7 @@ function normalizeRows(fields, rowType, oldRows, options) {
         return r;
     });
 }
-export function callFetchHooks(rows, request) {
+function callFetchHooks(rows, request) {
     const fetchHooks = request.fetchHooks;
     if (!fetchHooks)
         return;

package/esm/client/sqb-client.js

@@ -1,14 +1,18 @@
-import _debug from 'debug';
-import { createPool, PoolState } from 'lightning-pool';
-import { coerceToBoolean, coerceToInt } from 'putil-varhelpers';
-import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
-import { EntityMetadata } from '../orm/model/entity-metadata.js';
-import { Repository } from '../orm/repository.class.js';
-import { AdapterRegistry } from './extensions.js';
-import { SqbConnection } from './sqb-connection.js';
-const debug = _debug('sqb:client');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbClient = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const lightning_pool_1 = require("lightning-pool");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const strict_typed_events_1 = require("strict-typed-events");
+const entity_metadata_js_1 = require("../orm/model/entity-metadata.js");
+const repository_class_js_1 = require("../orm/repository.class.js");
+const extensions_js_1 = require("./extensions.js");
+const sqb_connection_js_1 = require("./sqb-connection.js");
+const debug = (0, debug_1.default)('sqb:client');
 const inspect = Symbol.for('nodejs.util.inspect.custom');
-export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
+class SqbClient extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_typed_events_1.AsyncEventEmitter) {
     constructor(config) {
         super();
         this._entities = {};
@@ -16,12 +20,12 @@ export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
             throw new TypeError('Configuration object required');
         let adapter;
         if (config.driver) {
-            adapter = AdapterRegistry.findDriver(config.driver);
+            adapter = extensions_js_1.AdapterRegistry.findDriver(config.driver);
             if (!adapter)
                 throw new Error(`No database adapter registered for "${config.driver}" driver`);
         }
         else if (config.dialect) {
-            adapter = AdapterRegistry.findDialect(config.dialect);
+            adapter = extensions_js_1.AdapterRegistry.findDialect(config.dialect);
             if (!adapter)
                 throw new Error(`No database adapter registered for "${config.dialect}" dialect`);
         }
@@ -31,16 +35,16 @@ export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
         this._defaults = config.defaults || {};
         const poolOptions = {};
         const popts = config.pool || {};
-        poolOptions.acquireMaxRetries = coerceToInt(popts.acquireMaxRetries, 0);
-        poolOptions.acquireRetryWait = coerceToInt(popts.acquireRetryWait, 2000);
-        poolOptions.acquireTimeoutMillis = coerceToInt(popts.acquireTimeoutMillis, 0);
-        poolOptions.idleTimeoutMillis = coerceToInt(popts.idleTimeoutMillis, 30000);
-        poolOptions.max = coerceToInt(popts.max, 10);
-        poolOptions.maxQueue = coerceToInt(popts.maxQueue, 1000);
-        poolOptions.max = coerceToInt(popts.max, 10);
-        poolOptions.min = coerceToInt(popts.min, 0);
-        poolOptions.minIdle = coerceToInt(popts.minIdle, 0);
-        poolOptions.validation = coerceToBoolean(popts.validation, false);
+        poolOptions.acquireMaxRetries = (0, putil_varhelpers_1.coerceToInt)(popts.acquireMaxRetries, 0);
+        poolOptions.acquireRetryWait = (0, putil_varhelpers_1.coerceToInt)(popts.acquireRetryWait, 2000);
+        poolOptions.acquireTimeoutMillis = (0, putil_varhelpers_1.coerceToInt)(popts.acquireTimeoutMillis, 0);
+        poolOptions.idleTimeoutMillis = (0, putil_varhelpers_1.coerceToInt)(popts.idleTimeoutMillis, 30000);
+        poolOptions.max = (0, putil_varhelpers_1.coerceToInt)(popts.max, 10);
+        poolOptions.maxQueue = (0, putil_varhelpers_1.coerceToInt)(popts.maxQueue, 1000);
+        poolOptions.max = (0, putil_varhelpers_1.coerceToInt)(popts.max, 10);
+        poolOptions.min = (0, putil_varhelpers_1.coerceToInt)(popts.min, 0);
+        poolOptions.minIdle = (0, putil_varhelpers_1.coerceToInt)(popts.minIdle, 0);
+        poolOptions.validation = (0, putil_varhelpers_1.coerceToBoolean)(popts.validation, false);
         const cfg = { ...config };
         const poolFactory = {
             create: () => adapter.connect(cfg),
@@ -48,7 +52,7 @@ export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
             reset: async (instance) => instance.reset(),
             validate: instance => instance.test(),
         };
-        this._pool = createPool(poolFactory, poolOptions);
+        this._pool = (0, lightning_pool_1.createPool)(poolFactory, poolOptions);
         this._pool.on('closing', () => this.emit('closing'));
         this._pool.on('close', () => this.emit('close'));
         this._pool.on('terminate', () => this.emit('terminate'));
@@ -74,7 +78,7 @@ export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
      * Returns true if pool is closed
      */
     get isClosed() {
-        return this._pool.state === PoolState.CLOSED;
+        return this._pool.state === lightning_pool_1.PoolState.CLOSED;
     }
     get pool() {
         return this._pool;
@@ -93,7 +97,7 @@ export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
         const options = arg1;
         const adapterConnection = await this._pool.acquire();
         const opts = { autoCommit: this.defaults.autoCommit, ...options };
-        const connection = new SqbConnection(this, adapterConnection, opts);
+        const connection = new sqb_connection_js_1.SqbConnection(this, adapterConnection, opts);
         await this.emitAsyncSerial('acquire', connection);
         connection.on('execute', (request) => this.emit('execute', request));
         connection.on('error', (error) => this.emit('error', error));
@@ -146,10 +150,10 @@ export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
         }
         else
             ctor = entity;
-        const entityDef = EntityMetadata.get(ctor);
+        const entityDef = entity_metadata_js_1.EntityMetadata.get(ctor);
         if (!entityDef)
             throw new Error(`You must provide an @Entity annotated constructor`);
-        return new Repository(entityDef, this, opts?.schema);
+        return new repository_class_js_1.Repository(entityDef, this, opts?.schema);
     }
     getEntity(name) {
         return this._entities[name];
@@ -161,3 +165,4 @@ export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
         return this.toString();
     }
 }
+exports.SqbClient = SqbClient;

package/esm/client/sqb-connection.js

@@ -1,19 +1,23 @@
-import { classes } from '@sqb/builder';
-import assert from 'assert';
-import _debug from 'debug';
-import { TaskQueue } from 'power-tasks';
-import { coalesce, coerceToBoolean, coerceToInt, coerceToString } from 'putil-varhelpers';
-import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
-import { EntityMetadata } from '../orm/model/entity-metadata.js';
-import { Repository } from '../orm/repository.class.js';
-import { Cursor } from './cursor.js';
-import { callFetchHooks, normalizeRowsToArrayRows, normalizeRowsToObjectRows, wrapAdapterFields } from './helpers.js';
-const debug = _debug('sqb:connection');
-export class SqbConnection extends TypedEventEmitterClass(AsyncEventEmitter) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbConnection = void 0;
+const tslib_1 = require("tslib");
+const builder_1 = require("@sqb/builder");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const power_tasks_1 = require("power-tasks");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const strict_typed_events_1 = require("strict-typed-events");
+const entity_metadata_js_1 = require("../orm/model/entity-metadata.js");
+const repository_class_js_1 = require("../orm/repository.class.js");
+const cursor_js_1 = require("./cursor.js");
+const helpers_js_1 = require("./helpers.js");
+const debug = (0, debug_1.default)('sqb:connection');
+class SqbConnection extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_typed_events_1.AsyncEventEmitter) {
     constructor(client, adapterConnection, options) {
         super();
         this.client = client;
-        this._tasks = new TaskQueue();
+        this._tasks = new power_tasks_1.TaskQueue();
         this._inTransaction = false;
         this._refCount = 1;
         this._intlcon = adapterConnection;
@@ -74,7 +78,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);
         });
@@ -94,26 +98,26 @@ export class SqbConnection extends TypedEventEmitterClass(AsyncEventEmitter) {
         }
         else
             ctor = entity;
-        const entityDef = EntityMetadata.get(ctor);
+        const entityDef = entity_metadata_js_1.EntityMetadata.get(ctor);
         if (!entityDef)
             throw new Error(`You must provide an @Entity annotated constructor`);
-        return new Repository(entityDef, this, opts?.schema);
+        return new repository_class_js_1.Repository(entityDef, this, opts?.schema);
     }
     async getSchema() {
-        assert.ok(this._intlcon, `Can't set schema, because connection is released`);
-        assert.ok(this._intlcon.getSchema, `${this.client.dialect} adapter does have Schema support`);
+        assert_1.default.ok(this._intlcon, `Can't set schema, because connection is released`);
+        assert_1.default.ok(this._intlcon.getSchema, `${this.client.dialect} adapter does have Schema support`);
         return await this._intlcon.getSchema();
     }
     async setSchema(schema) {
-        assert.ok(this._intlcon, `Can't set schema, because connection is released`);
-        assert.ok(this._intlcon.setSchema, `${this.client.dialect} adapter does have Schema support`);
+        assert_1.default.ok(this._intlcon, `Can't set schema, because connection is released`);
+        assert_1.default.ok(this._intlcon.setSchema, `${this.client.dialect} adapter does have Schema support`);
         await this._intlcon.setSchema(schema);
     }
     /**
      * Executes a query
      */
     async _execute(query, options) {
-        assert.ok(this._intlcon, `Can't execute query, because connection is released`);
+        assert_1.default.ok(this._intlcon, `Can't execute query, because connection is released`);
         const intlcon = this._intlcon;
         this.retain();
         try {
@@ -140,16 +144,16 @@ export class SqbConnection extends TypedEventEmitterClass(AsyncEventEmitter) {
                     throw new Error('Adapter did not returned fields info');
                 if (!response.rowType)
                     throw new Error('Adapter did not returned rowType');
-                result.fields = wrapAdapterFields(response.fields, request.fieldNaming);
+                result.fields = (0, helpers_js_1.wrapAdapterFields)(response.fields, request.fieldNaming);
                 result.rowType = response.rowType;
                 if (response.rows) {
                     result.rows = request.objectRows
-                        ? normalizeRowsToObjectRows(result.fields, response.rowType, response.rows, request)
-                        : normalizeRowsToArrayRows(result.fields, response.rowType, response.rows, request);
-                    callFetchHooks(result.rows, request);
+                        ? (0, helpers_js_1.normalizeRowsToObjectRows)(result.fields, response.rowType, response.rows, request)
+                        : (0, helpers_js_1.normalizeRowsToArrayRows)(result.fields, response.rowType, response.rows, request);
+                    (0, helpers_js_1.callFetchHooks)(result.rows, request);
                 }
                 else if (response.cursor) {
-                    const cursor = (result.cursor = new Cursor(this, result.fields, response.cursor, request));
+                    const cursor = (result.cursor = new cursor_js_1.Cursor(this, result.fields, response.cursor, request));
                     const hook = () => cursor.close();
                     cursor.once('close', () => this.off('close', hook));
                     this.on('close', hook);
@@ -227,20 +231,20 @@ export class SqbConnection extends TypedEventEmitterClass(AsyncEventEmitter) {
             sql: '',
             autoCommit: this.inTransaction
                 ? false
-                : coerceToBoolean(coalesce(options.autoCommit, this._options?.autoCommit, defaults.autoCommit), true),
-            cursor: coerceToBoolean(coalesce(options.cursor, defaults.cursor), false),
-            objectRows: coerceToBoolean(coalesce(options.objectRows, defaults.objectRows), true),
-            ignoreNulls: coerceToBoolean(coalesce(options.ignoreNulls, defaults.ignoreNulls), false),
-            fetchRows: coerceToInt(coalesce(options.fetchRows, defaults.fetchRows), 100),
-            fieldNaming: coalesce(options.namingStrategy, defaults.fieldNaming),
-            transform: coalesce(options.transform, defaults.transform),
-            showSql: coerceToBoolean(coalesce(options.showSql, defaults.showSql), false),
-            prettyPrint: coerceToBoolean(coalesce(options.prettyPrint, defaults.prettyPrint), false),
-            action: coerceToString(options.action),
+                : (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.autoCommit, this._options?.autoCommit, defaults.autoCommit), true),
+            cursor: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.cursor, defaults.cursor), false),
+            objectRows: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.objectRows, defaults.objectRows), true),
+            ignoreNulls: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.ignoreNulls, defaults.ignoreNulls), false),
+            fetchRows: (0, putil_varhelpers_1.coerceToInt)((0, putil_varhelpers_1.coalesce)(options.fetchRows, defaults.fetchRows), 100),
+            fieldNaming: (0, putil_varhelpers_1.coalesce)(options.namingStrategy, defaults.fieldNaming),
+            transform: (0, putil_varhelpers_1.coalesce)(options.transform, defaults.transform),
+            showSql: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.showSql, defaults.showSql), false),
+            prettyPrint: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.prettyPrint, defaults.prettyPrint), false),
+            action: (0, putil_varhelpers_1.coerceToString)(options.action),
             fetchAsString: options.fetchAsString,
         };
         request.ignoreNulls = request.ignoreNulls && request.objectRows;
-        if (query instanceof classes.Query) {
+        if (query instanceof builder_1.classes.Query) {
             if (this._intlcon.onGenerateQuery)
                 this._intlcon.onGenerateQuery(request, query);
             const q = query.generate({
@@ -273,3 +277,4 @@ export class SqbConnection extends TypedEventEmitterClass(AsyncEventEmitter) {
         return request;
     }
 }
+exports.SqbConnection = SqbConnection;

package/esm/client/types.js

@@ -1 +1,5 @@
-export { DataType } from '@sqb/builder';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = void 0;
+var builder_1 = require("@sqb/builder");
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return builder_1.DataType; } });