@sqb/connect 4.0.5 → 4.0.8

package/dist/client/SqbConnection.d.ts

@@ -1,74 +0,0 @@
-import { classes } from '@sqb/builder';
-import { AsyncEventEmitter } from 'strict-typed-events';
-import { Type } from 'ts-gems';
-import { SqbClient } from './SqbClient';
-import { ConnectionOptions, QueryExecuteOptions, QueryRequest } from './types';
-import { Adapter } from './Adapter';
-import { Repository } from '../orm/repository.class';
-interface SqbConnectionEvents {
-    close: () => void;
-    execute: (request: QueryRequest) => void;
-    error: (error: Error) => void;
-    retain: (refCount: number) => void;
-    release: (refCount: number) => void;
-    'start-transaction': () => void;
-    'set-savepoint': () => void;
-    'release-savepoint': () => void;
-    'rollback-savepoint': () => void;
-    commit: () => void;
-    rollback: () => void;
-}
-export declare class SqbConnection extends AsyncEventEmitter<SqbConnectionEvents> {
-    readonly client: SqbClient;
-    private _intlcon?;
-    private readonly _tasks;
-    private readonly _options?;
-    private _inTransaction;
-    private _refCount;
-    constructor(client: SqbClient, adapterConnection: Adapter.Connection, options?: ConnectionOptions);
-    /**
-     * Returns session id
-     */
-    get sessionId(): string;
-    /**
-     * Returns reference counter value
-     */
-    get refCount(): number;
-    /**
-     * Returns true if transaction started
-     */
-    get inTransaction(): boolean;
-    /**
-     * Increases internal reference counter to keep session alive
-     */
-    retain(): void;
-    /**
-     * Decreases the internal reference counter.
-     * When reference count is 0, connection returns to the pool.
-     * Returns true if connection released.
-     */
-    release(): boolean;
-    /**
-     * Immediately releases the connection.
-     */
-    close(): Promise<void>;
-    execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<any>;
-    getRepository<T>(entity: Type<T> | string, opts?: {
-        schema?: string;
-    }): Repository<T>;
-    getSchema(): Promise<string>;
-    setSchema(schema: string): Promise<void>;
-    /**
-     * Executes a query
-     */
-    protected _execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<any>;
-    startTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    setSavepoint(savepoint: string): Promise<void>;
-    releaseSavepoint(savepoint: string): Promise<void>;
-    rollbackSavepoint(savepoint: string): Promise<void>;
-    test(): Promise<void>;
-    private _prepareQueryRequest;
-}
-export {};

package/dist/client/SqbConnection.js

@@ -1,274 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqbConnection = void 0;
-const builder_1 = require("@sqb/builder");
-const strict_typed_events_1 = require("strict-typed-events");
-const assert_1 = __importDefault(require("assert"));
-const debug_1 = __importDefault(require("debug"));
-const putil_varhelpers_1 = require("putil-varhelpers");
-const putil_taskqueue_1 = __importDefault(require("putil-taskqueue"));
-const helpers_1 = require("./helpers");
-const Cursor_1 = require("./Cursor");
-const repository_class_1 = require("../orm/repository.class");
-const entity_model_1 = require("../orm/model/entity-model");
-const debug = (0, debug_1.default)('sqb:connection');
-class SqbConnection extends strict_typed_events_1.AsyncEventEmitter {
-    constructor(client, adapterConnection, options) {
-        super();
-        this.client = client;
-        this._tasks = new putil_taskqueue_1.default();
-        this._inTransaction = false;
-        this._refCount = 1;
-        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.emitAsync({ event: 'close', serial: true });
-        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 = entity_model_1.EntityModel.get(ctor);
-        if (!entityDef)
-            throw new Error(`You must provide an @Entity annotated constructor`);
-        return new repository_class_1.Repository(entityDef, this, opts?.schema);
-    }
-    async getSchema() {
-        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_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_1.default.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 = (0, helpers_1.wrapAdapterFields)(response.fields, request.fieldNaming);
-                result.rowType = response.rowType;
-                if (response.rows) {
-                    result.rows = request.objectRows ?
-                        (0, helpers_1.normalizeRowsToObjectRows)(result.fields, response.rowType, response.rows, request) :
-                        (0, helpers_1.normalizeRowsToArrayRows)(result.fields, response.rowType, response.rows, request);
-                    (0, helpers_1.callFetchHooks)(result.rows, request);
-                }
-                else if (response.cursor) {
-                    const cursor = result.cursor = new Cursor_1.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 :
-                (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 builder_1.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;
-    }
-}
-exports.SqbConnection = SqbConnection;

package/dist/client/extensions.d.ts

@@ -1,4 +0,0 @@
-import { Adapter } from './Adapter';
-export declare let adapters: Adapter[];
-export declare function registerAdapter(adapter: Adapter): void;
-export declare function unRegisterAdapter(...adapter: Adapter[]): void;

package/dist/client/extensions.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unRegisterAdapter = exports.registerAdapter = exports.adapters = void 0;
-exports.adapters = [];
-function registerAdapter(adapter) {
-    if (!adapter.driver)
-        throw new TypeError('A DatabaseAdapter must contain "driver" property');
-    exports.adapters.push(adapter);
-}
-exports.registerAdapter = registerAdapter;
-function unRegisterAdapter(...adapter) {
-    exports.adapters = exports.adapters.filter(x => !adapter.includes(x));
-}
-exports.unRegisterAdapter = unRegisterAdapter;

package/dist/client/helpers.d.ts

@@ -1,9 +0,0 @@
-import { Maybe } from 'ts-gems';
-import { ArrayRowset, FieldNaming, ObjectRowset, QueryRequest } from './types';
-import { FieldInfoMap } from './FieldInfoMap';
-import { Adapter } from './Adapter';
-export declare function applyNamingStrategy(value: string, namingStrategy?: FieldNaming): Maybe<string>;
-export declare function wrapAdapterFields(oldFields: Adapter.Field[], fieldNaming?: FieldNaming): FieldInfoMap;
-export declare function normalizeRowsToObjectRows(fields: FieldInfoMap, rowType: 'array' | 'object', oldRows: ObjectRowset | ArrayRowset, options?: Pick<QueryRequest, 'ignoreNulls' | 'transform'>): Record<string, any>[];
-export declare function normalizeRowsToArrayRows(fields: FieldInfoMap, rowType: 'array' | 'object', oldRows: ObjectRowset | ArrayRowset, options?: Pick<QueryRequest, 'ignoreNulls' | 'transform'>): any[][];
-export declare function callFetchHooks(rows: ObjectRowset | ArrayRowset, request: QueryRequest): void;

package/dist/client/helpers.js

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callFetchHooks = exports.normalizeRowsToArrayRows = exports.normalizeRowsToObjectRows = exports.wrapAdapterFields = exports.applyNamingStrategy = void 0;
-const putil_varhelpers_1 = require("putil-varhelpers");
-const FieldInfoMap_1 = require("./FieldInfoMap");
-function applyNamingStrategy(value, namingStrategy) {
-    if (typeof namingStrategy === 'string' && namingStrategy !== 'original') {
-        switch (namingStrategy.toLowerCase()) {
-            case 'lowercase':
-                return value.toLowerCase();
-            case 'uppercase':
-                return value.toUpperCase();
-            case 'camelcase':
-                if (!value.match(/[a-z]/))
-                    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 (0, putil_varhelpers_1.pascalCase)(value.toLowerCase());
-                return (0, putil_varhelpers_1.pascalCase)(value);
-        }
-    }
-    else if (typeof namingStrategy === 'function')
-        return namingStrategy(value);
-    return value;
-}
-exports.applyNamingStrategy = applyNamingStrategy;
-function wrapAdapterFields(oldFields, fieldNaming) {
-    const mapFieldInfo = (f, index) => {
-        const name = applyNamingStrategy(f.fieldName, fieldNaming);
-        if (name)
-            return { ...f, name, index };
-    };
-    const result = new FieldInfoMap_1.FieldInfoMap();
-    let i = 0;
-    oldFields.forEach(f => {
-        const x = mapFieldInfo(f, i);
-        if (x) {
-            i++;
-            result.add(x);
-        }
-    });
-    return result;
-}
-exports.wrapAdapterFields = wrapAdapterFields;
-function normalizeRowsToObjectRows(fields, rowType, oldRows, options) {
-    return normalizeRows(fields, rowType, oldRows, { ...options, objectRows: true });
-}
-exports.normalizeRowsToObjectRows = normalizeRowsToObjectRows;
-function normalizeRowsToArrayRows(fields, rowType, oldRows, options) {
-    return normalizeRows(fields, rowType, oldRows, { ...options, objectRows: false });
-}
-exports.normalizeRowsToArrayRows = normalizeRowsToArrayRows;
-function normalizeRows(fields, rowType, oldRows, options) {
-    const ignoreNulls = options.ignoreNulls && options.objectRows;
-    const transform = options.transform;
-    const coerceValue = (v, f) => {
-        if (v === undefined)
-            return;
-        if (transform)
-            v = transform(v, f);
-        if (v === null && ignoreNulls)
-            return;
-        return v;
-    };
-    if (options.objectRows) {
-        if (rowType === 'array') {
-            return oldRows.map((row) => {
-                const r = {};
-                for (const f of fields.values()) {
-                    const v = coerceValue(row[f.index], f);
-                    if (v !== undefined)
-                        r[f.name] = v;
-                }
-                return r;
-            });
-        }
-        let hasFieldNaming = false;
-        for (const f of fields.values()) {
-            if (f.name !== f.fieldName) {
-                hasFieldNaming = true;
-                break;
-            }
-        }
-        if (hasFieldNaming || transform) {
-            return oldRows.map((row) => {
-                const r = {};
-                for (const f of fields.values()) {
-                    const v = coerceValue(row[f.fieldName], f);
-                    if (v !== undefined)
-                        r[f.name] = v;
-                }
-                return r;
-            });
-        }
-        if (ignoreNulls) {
-            oldRows.forEach(row => {
-                for (const [k, v] of Object.entries(row)) {
-                    if (v === null)
-                        delete row[k];
-                }
-            });
-        }
-        return oldRows;
-    }
-    if (rowType === 'array') {
-        oldRows.forEach((row) => {
-            for (const [i, v] of row.entries()) {
-                row[i] = coerceValue(v, fields.get(i));
-            }
-        });
-        return oldRows;
-    }
-    return oldRows.map((row) => {
-        const r = [];
-        for (const f of fields.values()) {
-            r[f.index] = coerceValue(row[f.fieldName], f);
-        }
-        return r;
-    });
-}
-function callFetchHooks(rows, request) {
-    const fetchHooks = request.fetchHooks;
-    if (!fetchHooks)
-        return;
-    for (const row of rows) {
-        for (const fn of fetchHooks) {
-            fn(row, request);
-        }
-    }
-}
-exports.callFetchHooks = callFetchHooks;