@sqb/connect 4.1.5 → 4.5.0

package/esm/client/sqb-client.js

@@ -0,0 +1,166 @@
+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 { adapters } from './extensions.js';
+import { SqbConnection } from './sqb-connection.js';
+const debug = _debug('sqb:client');
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
+    _adapter;
+    _pool;
+    _defaults;
+    _entities = {};
+    constructor(config) {
+        super();
+        if (!(config && typeof config === 'object'))
+            throw new TypeError('Configuration object required');
+        let adapter;
+        if (config.driver) {
+            adapter = adapters.find(x => x.driver === config.driver);
+            if (!adapter)
+                throw new Error(`No database adapter registered for "${config.driver}" driver`);
+        }
+        else if (config.dialect) {
+            adapter = adapters.find(x => x.dialect === config.dialect);
+            if (!adapter)
+                throw new Error(`No database adapter registered for "${config.dialect}" dialect`);
+        }
+        if (!adapter)
+            throw new Error(`You must provide one of "driver" or "dialect" properties`);
+        this._adapter = adapter;
+        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);
+        const cfg = { ...config };
+        const poolFactory = {
+            create: () => adapter.connect(cfg),
+            destroy: instance => instance.close(),
+            reset: instance => instance.reset(),
+            validate: instance => instance.test()
+        };
+        this._pool = createPool(poolFactory, poolOptions);
+        this._pool.on('closing', () => this.emit('closing'));
+        this._pool.on('close', () => this.emit('close'));
+        this._pool.on('terminate', () => this.emit('terminate'));
+        // @ts-ignore
+        this._pool.on('error', (...args) => this.emit('error', ...args));
+    }
+    get defaults() {
+        return this._defaults;
+    }
+    /**
+     * Returns dialect
+     */
+    get dialect() {
+        return this._adapter.dialect;
+    }
+    /**
+     * Returns database driver name
+     */
+    get driver() {
+        return this._adapter.driver;
+    }
+    /**
+     * Returns true if pool is closed
+     */
+    get isClosed() {
+        return this._pool.state === PoolState.CLOSED;
+    }
+    get pool() {
+        return this._pool;
+    }
+    async acquire(arg0, arg1) {
+        debug('acquire');
+        if (typeof arg0 === 'function') {
+            const connection = await this.acquire(arg1);
+            try {
+                return await arg0(connection);
+            }
+            finally {
+                connection.release();
+            }
+        }
+        const options = arg1;
+        const adapterConnection = await this._pool.acquire();
+        const opts = { autoCommit: this.defaults.autoCommit, ...options };
+        const connection = new 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));
+        return connection;
+    }
+    /**
+     * Shuts down the pool and destroys all resources.
+     */
+    async close(terminateWait) {
+        const ms = terminateWait == null ? Infinity : 0;
+        return this._pool.close(ms);
+    }
+    /**
+     * Executes a query or callback with a new acquired connection.
+     */
+    async execute(query, options) {
+        debug('execute');
+        const connection = await this.acquire();
+        try {
+            const qr = await connection.execute(query, options);
+            if (qr && qr.cursor) {
+                connection.retain();
+                qr.cursor.once('close', () => connection.release());
+            }
+            return qr;
+        }
+        finally {
+            connection.release();
+        }
+    }
+    /**
+     * Tests the pool
+     */
+    async test() {
+        const connection = await this.acquire();
+        try {
+            await connection.test();
+        }
+        finally {
+            connection.release();
+        }
+    }
+    getRepository(entity, opts) {
+        let ctor;
+        if (typeof entity === 'string') {
+            ctor = this.getEntity(entity);
+            if (!ctor)
+                throw new Error(`Repository "${entity}" is not registered`);
+        }
+        else
+            ctor = entity;
+        const entityDef = EntityMetadata.get(ctor);
+        if (!entityDef)
+            throw new Error(`You must provide an @Entity annotated constructor`);
+        return new Repository(entityDef, this, opts?.schema);
+    }
+    getEntity(name) {
+        return this._entities[name];
+    }
+    toString() {
+        return '[object ' + Object.getPrototypeOf(this).constructor.name + '(' +
+            this.dialect + ')]';
+    }
+    [inspect]() {
+        return this.toString();
+    }
+}

package/{dist/client/SqbConnection.d.ts → esm/client/sqb-connection.d.ts}

@@ -1,9 +1,9 @@
 import { Type } from 'ts-gems';
 import { classes } from '@sqb/builder';
-import { Repository } from '../orm/repository.class';
-import { Adapter } from './Adapter';
-import { SqbClient } from './SqbClient';
-import { ConnectionOptions, QueryExecuteOptions, QueryRequest } from './types';
+import { Repository } from '../orm/repository.class.js';
+import { Adapter } from './adapter.js';
+import { SqbClient } from './sqb-client.js';
+import { ConnectionOptions, QueryExecuteOptions, QueryRequest } from './types.js';
 interface SqbConnectionEvents {
     close: () => void;
     execute: (request: QueryRequest) => void;

package/esm/client/sqb-connection.js

@@ -0,0 +1,270 @@
+import assert from 'assert';
+import _debug from 'debug';
+import TaskQueue from 'putil-taskqueue';
+import { coalesce, coerceToBoolean, coerceToInt, coerceToString } from "putil-varhelpers";
+import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
+import { classes } from '@sqb/builder';
+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) {
+    client;
+    _intlcon;
+    _tasks = new TaskQueue();
+    _options;
+    _inTransaction = false;
+    _refCount = 1;
+    constructor(client, adapterConnection, options) {
+        super();
+        this.client = client;
+        this._intlcon = adapterConnection;
+        this._options = options || {};
+    }
+    /**
+     * Returns session id
+     */
+    get sessionId() {
+        return this._intlcon && this._intlcon.sessionId;
+    }
+    /**
+     * Returns reference counter value
+     */
+    get refCount() {
+        return this._refCount;
+    }
+    /**
+     * Returns true if transaction started
+     */
+    get inTransaction() {
+        if (this._intlcon && typeof this._intlcon.getInTransaction === 'function') {
+            this._inTransaction = this._intlcon.getInTransaction();
+        }
+        return this._inTransaction;
+    }
+    /**
+     * Increases internal reference counter to keep session alive
+     */
+    retain() {
+        this._refCount++;
+        debug('[%s] retain | refCount: %s', this.sessionId, this._refCount);
+        this.emit('retain', this._refCount);
+    }
+    /**
+     * Decreases the internal reference counter.
+     * When reference count is 0, connection returns to the pool.
+     * Returns true if connection released.
+     */
+    release() {
+        if (!this._intlcon)
+            return true;
+        const ref = --this._refCount;
+        this.emit('release', this._refCount);
+        debug('[%s] release | refCount: %s', this.sessionId, ref);
+        if (!ref) {
+            this.close().catch(() => 0);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Immediately releases the connection.
+     */
+    async close() {
+        if (!this._intlcon)
+            return;
+        await this.emitAsyncSerial('close');
+        const intlcon = this._intlcon;
+        this._intlcon = undefined;
+        this.client.pool.release(intlcon)
+            .catch(e => this.client.emit('error', e));
+        debug('[%s] closed', intlcon.sessionId);
+    }
+    async execute(query, options) {
+        if (!this._intlcon)
+            throw new Error(`Can't execute query, because connection is released`);
+        return this._tasks.enqueue(() => this._execute(query, options));
+    }
+    getRepository(entity, opts) {
+        let ctor;
+        if (typeof entity === 'string') {
+            ctor = this.client.getEntity(entity);
+            if (!ctor)
+                throw new Error(`Repository "${entity}" is not registered`);
+        }
+        else
+            ctor = entity;
+        const entityDef = EntityMetadata.get(ctor);
+        if (!entityDef)
+            throw new Error(`You must provide an @Entity annotated constructor`);
+        return new 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`);
+        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`);
+        await this._intlcon.setSchema(schema);
+    }
+    /**
+     * Executes a query
+     */
+    async _execute(query, options) {
+        assert.ok(this._intlcon, `Can't execute query, because connection is released`);
+        const intlcon = this._intlcon;
+        this.retain();
+        try {
+            const startTime = Date.now();
+            const request = this._prepareQueryRequest(query, options);
+            debug('[%s] execute | %o', this.sessionId, request);
+            this.emit('execute', request);
+            // Call execute hooks
+            if (request.executeHooks) {
+                for (const fn of request.executeHooks) {
+                    await fn(this, request);
+                }
+            }
+            const response = await intlcon.execute(request);
+            if (!response)
+                throw new Error('Database adapter returned an empty response');
+            const result = {
+                executeTime: Date.now() - startTime
+            };
+            if (request.showSql)
+                result.query = request;
+            if (response.rows || response.cursor) {
+                if (!response.fields)
+                    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.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);
+                }
+                else if (response.cursor) {
+                    const cursor = result.cursor = new Cursor(this, result.fields, response.cursor, request);
+                    const hook = () => cursor.close();
+                    cursor.once('close', () => this.off('close', hook));
+                    this.on('close', hook);
+                }
+            }
+            if (response.rowsAffected)
+                result.rowsAffected = response.rowsAffected;
+            return result;
+        }
+        finally {
+            this.release();
+        }
+    }
+    async startTransaction() {
+        if (!this._intlcon)
+            throw new Error('Can not call startTransaction() on a released connection');
+        await this._intlcon.startTransaction();
+        this._inTransaction = true;
+        this.emit('start-transaction');
+    }
+    async commit() {
+        if (!this._intlcon)
+            throw new Error('Can not call commit() on a released connection');
+        await this._intlcon.commit();
+        this._inTransaction = false;
+        this.emit('commit');
+    }
+    async rollback() {
+        if (!this._intlcon)
+            throw new Error('Can not call rollback() on a released connection');
+        await this._intlcon.rollback();
+        this._inTransaction = false;
+        this.emit('rollback');
+    }
+    async setSavepoint(savepoint) {
+        if (!this._intlcon)
+            throw new Error('Can not call setSavepoint() on a released connection');
+        if (typeof this._intlcon.setSavepoint !== 'function')
+            throw new Error(this.client.driver + ' does not support setSavepoint method');
+        if (!this.inTransaction)
+            await this.startTransaction();
+        await this._intlcon.setSavepoint(savepoint);
+        this.emit('set-savepoint');
+    }
+    async releaseSavepoint(savepoint) {
+        if (!this._intlcon)
+            throw new Error('Can not call releaseSavepoint() on a released connection');
+        if (typeof this._intlcon.releaseSavepoint !== 'function')
+            throw new Error(this.client.driver + ' does not support releaseSavepoint method');
+        await this._intlcon.releaseSavepoint(savepoint);
+        this.emit('release-savepoint');
+    }
+    async rollbackSavepoint(savepoint) {
+        if (!this._intlcon)
+            throw new Error('Can not call rollbackSavepoint() on a released connection');
+        if (typeof this._intlcon.rollbackSavepoint !== 'function')
+            throw new Error(this.client.driver + ' does not support rollbackSavepoint method');
+        await this._intlcon.rollbackSavepoint(savepoint);
+        this.emit('rollback-savepoint');
+    }
+    async test() {
+        if (!this._intlcon)
+            throw new Error('Can not call test() on a released connection');
+        await this._intlcon.test();
+    }
+    _prepareQueryRequest(query, options = {}) {
+        if (!this._intlcon)
+            throw new Error('Session released');
+        const defaults = this.client.defaults;
+        const request = {
+            dialect: this.client.dialect,
+            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),
+            fetchAsString: options.fetchAsString
+        };
+        request.ignoreNulls = request.ignoreNulls && request.objectRows;
+        if (query instanceof classes.Query) {
+            if (this._intlcon.onGenerateQuery)
+                this._intlcon.onGenerateQuery(request, query);
+            const q = query
+                .generate({
+                dialect: request.dialect,
+                dialectVersion: request.dialectVersion,
+                params: options.params,
+                strictParams: true,
+                prettyPrint: request.prettyPrint
+            });
+            request.sql = q.sql;
+            request.params = q.params;
+            request.paramOptions = q.paramOptions;
+            if (q.returningFields)
+                request.returningFields = q.returningFields;
+            if (query.listenerCount('execute'))
+                request.executeHooks = query.listeners('execute');
+            if (query.listenerCount('fetch'))
+                request.fetchHooks = query.listeners('fetch');
+        }
+        else if (typeof query === 'string') {
+            request.sql = query;
+            request.params = options.params;
+        }
+        // @ts-ignore
+        if (!request.sql)
+            throw new Error('No sql given');
+        return request;
+    }
+}

package/{dist → esm}/client/types.d.ts

@@ -1,10 +1,10 @@
 import type { PoolConfiguration } from 'lightning-pool';
 import { Maybe } from 'ts-gems';
 import { DataType, ParamOptions } from '@sqb/builder';
-import type { Adapter } from './Adapter';
-import type { Cursor } from './Cursor';
-import type { FieldInfoMap } from './FieldInfoMap';
-import type { SqbConnection } from './SqbConnection';
+import type { Adapter } from './adapter';
+import type { Cursor } from './cursor';
+import type { FieldInfoMap } from './field-info-map';
+import type { SqbConnection } from './sqb-connection';
 export { DataType } from '@sqb/builder';
 export declare type ExecuteHookFunction = (connection: SqbConnection, request: QueryRequest) => Promise<void>;
 export declare type FetchFunction = (row: any, request: QueryRequest) => void;
@@ -144,21 +144,13 @@ export interface QueryExecuteOptions {
 export interface QueryResult {
     executeTime: number;
     fields?: FieldInfoMap;
-    rows?: Record<string, any>[] | any[][];
+    rows?: any;
     rowType?: RowType;
     query?: QueryRequest;
     returns?: any;
     rowsAffected?: number;
     cursor?: Cursor;
 }
-export interface ObjectQueryResult extends QueryResult {
-    rows?: Record<string, any>[];
-    rowType?: 'object';
-}
-export interface ArrayQueryResult extends QueryResult {
-    rows?: any[][];
-    rowType?: 'array';
-}
 export declare type FieldInfo = {
     index: number;
     name: string;

package/esm/client/types.js

@@ -0,0 +1 @@
+export { DataType } from '@sqb/builder';

package/esm/index.d.ts

@@ -0,0 +1,33 @@
+import 'reflect-metadata';
+export { Type, Maybe, DeepPartial, DeepPickWritable, DeepBuildable } from 'ts-gems';
+export * from './types.js';
+export * from './client/types.js';
+export * from './client/adapter.js';
+export * from './client/sqb-client.js';
+export * from './client/sqb-connection.js';
+export * from './client/cursor.js';
+export { registerAdapter, unRegisterAdapter } from './client/extensions.js';
+export * from './orm/orm.type.js';
+export * from './orm/orm.const.js';
+export * from './orm/base-entity.js';
+export * from './orm/repository.class.js';
+export * from './orm/model/entity-metadata.js';
+export * from './orm/model/field-metadata.js';
+export * from './orm/model/column-field-metadata.js';
+export * from './orm/model/embedded-field-metadata.js';
+export * from './orm/model/association-field-metadata.js';
+export * from './orm/model/association.js';
+export * from './orm/model/association-node.js';
+export * from './orm/model/index-metadata.js';
+export * from './orm/model/link-chain.js';
+export * from './orm/decorators/column.decorator.js';
+export * from './orm/decorators/embedded.decorator.js';
+export * from './orm/decorators/entity.decorator.js';
+export * from './orm/decorators/events.decorator.js';
+export * from './orm/decorators/foreignkey.decorator.js';
+export * from './orm/decorators/index.decorator.js';
+export * from './orm/decorators/link.decorator.js';
+export * from './orm/decorators/primarykey.decorator.js';
+export * from './orm/decorators/transform.decorator.js';
+export { isColumnField, isEmbeddedField, isAssociationField, isEntityClass } from './orm/util/orm.helper.js';
+export * from './orm/backward.js';

package/esm/index.js

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+export * from './types.js';
+export * from './client/types.js';
+export * from './client/adapter.js';
+export * from './client/sqb-client.js';
+export * from './client/sqb-connection.js';
+export * from './client/cursor.js';
+export { registerAdapter, unRegisterAdapter } from './client/extensions.js';
+export * from './orm/orm.type.js';
+export * from './orm/orm.const.js';
+export * from './orm/base-entity.js';
+export * from './orm/repository.class.js';
+export * from './orm/model/entity-metadata.js';
+export * from './orm/model/field-metadata.js';
+export * from './orm/model/column-field-metadata.js';
+export * from './orm/model/embedded-field-metadata.js';
+export * from './orm/model/association-field-metadata.js';
+export * from './orm/model/association.js';
+export * from './orm/model/association-node.js';
+export * from './orm/model/index-metadata.js';
+export * from './orm/model/link-chain.js';
+export * from './orm/decorators/column.decorator.js';
+export * from './orm/decorators/embedded.decorator.js';
+export * from './orm/decorators/entity.decorator.js';
+export * from './orm/decorators/events.decorator.js';
+export * from './orm/decorators/foreignkey.decorator.js';
+export * from './orm/decorators/index.decorator.js';
+export * from './orm/decorators/link.decorator.js';
+export * from './orm/decorators/primarykey.decorator.js';
+export * from './orm/decorators/transform.decorator.js';
+export { isColumnField, isEmbeddedField, isAssociationField, isEntityClass } from './orm/util/orm.helper.js';
+export * from './orm/backward.js';

package/{dist → esm}/orm/backward.d.ts

@@ -1,5 +1,5 @@
 import { PickWritable, Type } from 'ts-gems';
-import { Entity } from './decorators/entity.decorator';
+import { Entity } from './decorators/entity.decorator.js';
 export declare function getInsertColumnNames<T, K extends keyof PickWritable<T>>(ctor: Type<T>): K[];
 export declare function getUpdateColumnNames<T, K extends keyof PickWritable<T>>(ctor: Type<T>): K[];
 export declare function getNonAssociationElementNames<T, K extends keyof PickWritable<T>>(ctor: Type<T>): K[];

package/esm/orm/backward.js

@@ -0,0 +1,17 @@
+import { Entity } from './decorators/entity.decorator.js';
+export function getInsertColumnNames(ctor) {
+    return Entity.getInsertColumnNames(ctor);
+}
+export function getUpdateColumnNames(ctor) {
+    return Entity.getUpdateColumnNames(ctor);
+}
+export function getNonAssociationElementNames(ctor) {
+    return Entity.getNonAssociationFieldNames(ctor);
+}
+export function mixinEntities(derivedCtor, ...bases) {
+    // @ts-ignore
+    return Entity.mixin(derivedCtor, ...bases);
+}
+export const OmitEntity = Entity.Omit;
+export const PickEntity = Entity.Pick;
+export const UnionEntity = Entity.Union;

package/{dist → esm}/orm/base-entity.d.ts

@@ -1,4 +1,4 @@
-import { REPOSITORY_KEY } from './orm.const';
+import { REPOSITORY_KEY } from './orm.const.js';
 export declare class BaseEntity {
     private [REPOSITORY_KEY]?;
     constructor(partial?: any);

package/esm/orm/base-entity.js

@@ -0,0 +1,25 @@
+import { Entity } from './decorators/entity.decorator.js';
+import { REPOSITORY_KEY } from './orm.const.js';
+export class BaseEntity {
+    [REPOSITORY_KEY];
+    constructor(partial) {
+        const fields = Entity.getColumnFieldNames(Object.getPrototypeOf(this).constructor);
+        if (fields && partial) {
+            for (const k of fields)
+                if (partial[k] !== undefined)
+                    this[k] = partial[k];
+        }
+    }
+    async destroy() {
+        const repo = this[REPOSITORY_KEY];
+        return !!(repo && repo.destroy(this));
+    }
+    async exists() {
+        const repo = this[REPOSITORY_KEY];
+        return !!(repo && repo.exists(this));
+    }
+    toJSON() {
+        // this method is a placeholder and will be overwritten by declareEntity() method
+        return this;
+    }
+}

package/{dist → esm}/orm/commands/command.helper.d.ts

@@ -1,6 +1,6 @@
 import { JoinStatement, LogicalOperator } from '@sqb/builder';
-import { AssociationNode } from '../model/association-node';
-import { EntityMetadata } from '../model/entity-metadata';
+import { AssociationNode } from '../model/association-node.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
 export interface JoinInfo {
     association: AssociationNode;
     sourceEntity: EntityMetadata;