@sqb/connect 4.0.9 → 4.0.13

package/dist/client/Adapter.d.ts

@@ -0,0 +1,57 @@
+import { Maybe } from 'ts-gems';
+import { classes } from '@sqb/builder';
+import { ClientConfiguration, QueryRequest, RowType, DataType } from './types';
+export interface Adapter {
+    driver: string;
+    dialect: string;
+    features?: {
+        cursor?: boolean;
+        schema?: boolean;
+        fetchAsString?: DataType[];
+    };
+    connect: (config: ClientConfiguration) => Promise<Adapter.Connection>;
+}
+export declare namespace Adapter {
+    interface Connection {
+        sessionId: any;
+        execute: (request: QueryRequest) => Promise<Response>;
+        close: () => Promise<void>;
+        reset: () => Promise<void>;
+        test: () => Promise<void>;
+        startTransaction: () => Promise<void>;
+        setSavepoint?: (savepoint: string) => Promise<void>;
+        releaseSavepoint?: (savepoint: string) => Promise<void>;
+        rollbackSavepoint?: (savepoint: string) => Promise<void>;
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+        setSchema?: (schema: string) => Promise<void>;
+        getSchema?: () => Promise<string>;
+        onGenerateQuery?: (request: QueryRequest, query: classes.Query) => void;
+        getInTransaction?: () => boolean;
+    }
+    interface Cursor {
+        readonly isClosed: boolean;
+        readonly rowType: RowType;
+        close: () => Promise<void>;
+        fetch: (rows: number) => Promise<Maybe<any[]>>;
+    }
+    interface Response {
+        fields?: Field[];
+        rows?: Record<string, any>[] | any[][];
+        rowType?: RowType;
+        cursor?: Adapter.Cursor;
+        rowsAffected?: number;
+    }
+    interface Field {
+        fieldName: string;
+        dataType: string;
+        jsType: string;
+        isArray?: boolean;
+        elementDataType?: string;
+        nullable?: boolean;
+        fixedLength?: boolean;
+        size?: number;
+        precision?: number;
+        _inf: any;
+    }
+}

package/dist/client/Adapter.js

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

package/dist/client/Cursor.d.ts

@@ -0,0 +1,116 @@
+import { Adapter } from './Adapter';
+import { SqbConnection } from './SqbConnection';
+import { FieldInfoMap } from './FieldInfoMap';
+import { ObjectRow, QueryRequest } from './types';
+import { CursorStream, CursorStreamOptions } from './CursorStream';
+interface CursorEvents {
+    close: () => void;
+    error: (error: unknown) => void;
+    eof: () => void;
+    reset: () => void;
+    move: (row: any, rowNum: number) => void;
+    fetch: (row: any, rowNum: number) => void;
+}
+declare const Cursor_base: import("strict-typed-events").Type<import("strict-typed-events").TypedEventEmitter<any, CursorEvents, CursorEvents>>;
+export declare class Cursor extends Cursor_base {
+    private readonly _connection;
+    private readonly _fields;
+    private readonly _prefetchRows;
+    private readonly _request;
+    private _intlcur?;
+    private _taskQueue;
+    private _fetchCache;
+    private _rowNum;
+    private _fetchedAll;
+    private _fetchedRows;
+    private _row;
+    private _cache?;
+    constructor(connection: SqbConnection, fields: FieldInfoMap, adapterCursor: Adapter.Cursor, request: QueryRequest);
+    /**
+     * Returns the Connection instance
+     */
+    get connection(): SqbConnection;
+    /**
+     * Returns if cursor is before first record.
+     */
+    get isBof(): boolean;
+    /**
+     * Returns if cursor is closed.
+     */
+    get isClosed(): boolean;
+    /**
+     * Returns if cursor is after last record.
+     */
+    get isEof(): boolean;
+    /**
+     * Returns number of fetched record count from database.
+     */
+    get fetchedRows(): number;
+    /**
+     * Returns object instance which contains information about fields.
+     */
+    get fields(): FieldInfoMap;
+    /**
+     * Returns current row
+     */
+    get row(): any;
+    /**
+     * Returns current row number.
+     */
+    get rowNum(): number;
+    /**
+     * Enables cache
+     */
+    cached(): void;
+    /**
+     * Closes cursor
+     */
+    close(): Promise<void>;
+    /**
+     * If cache is enabled, this call fetches and keeps all records in the internal cache.
+     * Otherwise it throws error. Once all all records fetched,
+     * you can close Cursor safely and can continue to use it in memory.
+     * Returns number of fetched rows
+     */
+    fetchAll(): Promise<number>;
+    /**
+     * Moves cursor to given row number.
+     * cursor can move both forward and backward if cache enabled.
+     * Otherwise it throws error.
+     */
+    moveTo(rowNum: number): Promise<ObjectRow>;
+    /**
+     * Moves cursor forward by one row and returns that row.
+     * And also it allows iterating over rows easily.
+     */
+    next(): Promise<ObjectRow>;
+    /**
+     *  Moves cursor back by one row and returns that row.
+     *  And also it allows iterating over rows easily.
+     */
+    prev(): Promise<ObjectRow>;
+    /**
+     * Moves cursor before first row. (Required cache enabled)
+     */
+    reset(): void;
+    /**
+     * Moves cursor by given step. If caching is enabled,
+     * cursor can move both forward and backward. Otherwise it throws error.
+     */
+    seek(step: number): Promise<ObjectRow>;
+    /**
+     * Creates and returns a readable stream.
+     */
+    toStream(options?: CursorStreamOptions): CursorStream;
+    toString(): string;
+    inspect(): string;
+    /**
+     *
+     */
+    _seek(step: number, silent?: boolean): Promise<number>;
+    /**
+     *
+     */
+    _fetchRows(): Promise<void>;
+}
+export {};

package/dist/client/Cursor.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cursor = void 0;
+const tslib_1 = require("tslib");
+const strict_typed_events_1 = require("strict-typed-events");
+const doublylinked_1 = tslib_1.__importDefault(require("doublylinked"));
+const putil_taskqueue_1 = tslib_1.__importDefault(require("putil-taskqueue"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const helpers_1 = require("./helpers");
+const CursorStream_1 = require("./CursorStream");
+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 putil_taskqueue_1.default();
+        this._fetchCache = new doublylinked_1.default();
+        this._rowNum = 0;
+        this._fetchedAll = false;
+        this._fetchedRows = 0;
+        this._connection = connection;
+        this._intlcur = adapterCursor;
+        this._fields = fields;
+        this._request = request;
+        this._prefetchRows = request?.fetchRows || 100;
+    }
+    /**
+     * Returns the Connection instance
+     */
+    get connection() {
+        return this._connection;
+    }
+    /**
+     * Returns if cursor is before first record.
+     */
+    get isBof() {
+        return !this._rowNum;
+    }
+    /**
+     * Returns if cursor is closed.
+     */
+    get isClosed() {
+        return !this._intlcur;
+    }
+    /**
+     * Returns if cursor is after last record.
+     */
+    get isEof() {
+        return this._fetchedAll && this.rowNum > this._fetchedRows;
+    }
+    /**
+     * Returns number of fetched record count from database.
+     */
+    get fetchedRows() {
+        return this._fetchedRows;
+    }
+    /**
+     * Returns object instance which contains information about fields.
+     */
+    get fields() {
+        return this._fields;
+    }
+    /**
+     * Returns current row
+     */
+    get row() {
+        return this._row;
+    }
+    /**
+     * Returns current row number.
+     */
+    get rowNum() {
+        return this._rowNum;
+    }
+    /**
+     * Enables cache
+     */
+    cached() {
+        if (this.fetchedRows)
+            throw new Error('Cache can be enabled before fetching rows');
+        if (!this._cache)
+            this._cache = new doublylinked_1.default();
+    }
+    /**
+     * Closes cursor
+     */
+    async close() {
+        if (!this._intlcur)
+            return;
+        try {
+            await this._intlcur.close();
+            this._intlcur = undefined;
+            debug('close');
+            this.emit('close');
+        }
+        catch (err) {
+            debug('close-error:', err);
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    /**
+     * If cache is enabled, this call fetches and keeps all records in the internal cache.
+     * Otherwise it throws error. Once all all records fetched,
+     * you can close Cursor safely and can continue to use it in memory.
+     * Returns number of fetched rows
+     */
+    async fetchAll() {
+        if (!this._cache)
+            throw new Error('fetchAll() method needs cache to be enabled');
+        const n = this.rowNum;
+        const v = await this._seek(Number.MAX_SAFE_INTEGER, true);
+        await this._seek(n - this.rowNum, true);
+        return v;
+    }
+    /**
+     * Moves cursor to given row number.
+     * cursor can move both forward and backward if cache enabled.
+     * Otherwise it throws error.
+     */
+    async moveTo(rowNum) {
+        await this._seek(rowNum - this.rowNum);
+        return this.row;
+    }
+    /**
+     * Moves cursor forward by one row and returns that row.
+     * And also it allows iterating over rows easily.
+     */
+    async next() {
+        debug('next');
+        await this._seek(1);
+        return this.row;
+    }
+    /**
+     *  Moves cursor back by one row and returns that row.
+     *  And also it allows iterating over rows easily.
+     */
+    async prev() {
+        await this._seek(-1);
+        return this.row;
+    }
+    /**
+     * Moves cursor before first row. (Required cache enabled)
+     */
+    reset() {
+        if (!this._cache)
+            throw new Error('reset() method needs cache to be enabled');
+        this._cache.reset();
+        this._rowNum = 0;
+        this.emit('reset');
+    }
+    /**
+     * Moves cursor by given step. If caching is enabled,
+     * cursor can move both forward and backward. Otherwise it throws error.
+     */
+    async seek(step) {
+        await this._seek(step);
+        return this.row;
+    }
+    /**
+     * Creates and returns a readable stream.
+     */
+    toStream(options) {
+        return new CursorStream_1.CursorStream(this, options);
+    }
+    toString() {
+        return '[object ' + Object.getPrototypeOf(this).constructor.name + ']';
+    }
+    inspect() {
+        return this.toString();
+    }
+    /**
+     *
+     */
+    async _seek(step, silent) {
+        step = (0, putil_varhelpers_1.coerceToInt)(step, 0);
+        if (!step || (step > 0 && this.isClosed))
+            return this.rowNum;
+        if (step < 0 && !this._cache)
+            throw new Error('To move cursor back, it needs cache to be enabled');
+        const _this = this;
+        await this._taskQueue.enqueue(async function () {
+            /* If moving backward */
+            if (step < 0) {
+                /* Seek cache */
+                while (step < 0 && _this._cache?.cursor) {
+                    _this._row = _this._cache.prev();
+                    _this._rowNum--;
+                    step++;
+                }
+                return;
+            }
+            while (step > 0) {
+                if (_this.isEof)
+                    return;
+                /* Seek cache */
+                while (step > 0 && _this._cache && (_this._row = _this._cache.next())) {
+                    _this._rowNum++;
+                    step--;
+                }
+                /* Fetch from prefetch cache */
+                while (step > 0 && (_this._row = _this._fetchCache.shift())) {
+                    _this._rowNum++;
+                    step--;
+                }
+                if (_this._fetchedAll) {
+                    _this._rowNum++;
+                    _this.emit('eof');
+                    return;
+                }
+                if (!step || _this._fetchedAll)
+                    return;
+                await _this._fetchRows();
+            }
+        });
+        if (!silent)
+            this.emit('move', this.row, this._rowNum);
+        return this._rowNum;
+    }
+    /**
+     *
+     */
+    async _fetchRows() {
+        if (!this._intlcur)
+            throw new Error('Cursor is closed');
+        let rows = await this._intlcur.fetch(this._prefetchRows);
+        if (rows && rows.length) {
+            debug('Fetched %d rows from database', rows.length);
+            // Normalize rows
+            rows = this._request.objectRows ?
+                (0, helpers_1.normalizeRowsToObjectRows)(this._fields, this._intlcur.rowType, rows, this._request) :
+                (0, helpers_1.normalizeRowsToArrayRows)(this._fields, this._intlcur.rowType, rows, this._request);
+            (0, helpers_1.callFetchHooks)(rows, this._request);
+            for (const [idx, row] of rows.entries()) {
+                this.emit('fetch', row, (this._rowNum + idx + 1));
+            }
+            /* Add rows to cache */
+            if (this._cache) {
+                this._cache.push(...rows);
+            }
+            else
+                this._fetchCache.push(...rows);
+            this._fetchedRows += rows.length;
+            return;
+        }
+        this._fetchedAll = true;
+        return this.close();
+    }
+}
+exports.Cursor = Cursor;

package/dist/client/CursorStream.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { Cursor } from './Cursor';
+export interface CursorStreamOptions {
+    objectMode?: boolean;
+    limit?: number;
+}
+declare const inspect: unique symbol;
+export declare class CursorStream extends Readable {
+    private readonly _cursor;
+    private readonly _objectMode?;
+    private readonly _limit;
+    private _rowNum;
+    private _eof;
+    constructor(cursor: Cursor, options?: CursorStreamOptions);
+    /**
+     * Returns if stream is closed.
+     */
+    get isClosed(): boolean;
+    /**
+     * Closes stream and releases the cursor
+     */
+    close(): Promise<void>;
+    toString(): string;
+    [inspect](): string;
+    _read(): void;
+    emit(event: string | symbol, ...args: any[]): boolean;
+}
+export {};

package/dist/client/CursorStream.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorStream = void 0;
+const tslib_1 = require("tslib");
+const stream_1 = require("stream");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const debug = (0, debug_1.default)('sqb:cursorstream');
+class CursorStream extends stream_1.Readable {
+    constructor(cursor, options) {
+        super(options);
+        this._rowNum = -1;
+        this._eof = false;
+        this._cursor = cursor;
+        this._objectMode = options?.objectMode;
+        this._limit = options?.limit || Number.MAX_SAFE_INTEGER;
+        this.on('end', () => {
+            this.close().catch(() => false);
+        });
+        cursor.once('close', () => this.emit('close'));
+        cursor.on('error', (err) => this.emit('error', err));
+    }
+    /**
+     * Returns if stream is closed.
+     */
+    get isClosed() {
+        return this._cursor.isClosed;
+    }
+    /**
+     * Closes stream and releases the cursor
+     */
+    close() {
+        this.pause();
+        this.unpipe();
+        return this._cursor.close();
+    }
+    toString() {
+        return '[object ' + Object.getPrototypeOf(this).constructor.name + ']';
+    }
+    [inspect]() {
+        return this.toString();
+    }
+    _read() {
+        if (this._rowNum >= this._limit) {
+            this.pause();
+            this.unpipe();
+            this.emit('end');
+            return;
+        }
+        this._cursor.next().then(row => {
+            if (this._eof)
+                return this.push(null);
+            let buf = '';
+            if (this._rowNum < 0) {
+                this._rowNum = 0;
+                if (!this._objectMode)
+                    buf += '[';
+            }
+            if (!row) {
+                this._eof = true;
+                if (!this._objectMode) {
+                    buf += ']';
+                    this.push(buf);
+                }
+                else
+                    this.push(null);
+                return;
+            }
+            this._rowNum++;
+            if (this._objectMode)
+                this.push(row);
+            else {
+                if (this._rowNum > 1)
+                    buf += ',';
+                this.push(buf + JSON.stringify(row));
+            }
+        }).catch(err => {
+            /* istanbul ignore next */
+            if (typeof this.destroy == 'function')
+                this.destroy(err);
+            else
+                this.emit('error', err);
+            this.close().catch(() => 0);
+        });
+    }
+    emit(event, ...args) {
+        try {
+            if (event === 'error' && !this.listenerCount('error'))
+                return false;
+            return super.emit(event, ...args);
+        }
+        catch (ignored) {
+            debug('emit-error', ignored);
+            return false;
+        }
+    }
+}
+exports.CursorStream = CursorStream;

package/dist/client/FieldInfoMap.d.ts

@@ -0,0 +1,10 @@
+import { FieldInfo } from './types';
+export declare class FieldInfoMap {
+    private _obj;
+    private _arr;
+    add(field: FieldInfo): void;
+    get(k: string | number): FieldInfo;
+    entries(): [string, FieldInfo][];
+    keys(): string[];
+    values(): FieldInfo[];
+}

package/dist/client/FieldInfoMap.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldInfoMap = void 0;
+class FieldInfoMap {
+    constructor() {
+        this._obj = {};
+        this._arr = [];
+    }
+    add(field) {
+        const idx = field.index != null ? field.index : this._arr.length;
+        this._arr[idx] = field;
+        field.index = idx;
+        this._obj = this._arr.reduce((a, f) => {
+            a[f.name.toUpperCase()] = f;
+            return a;
+        }, {});
+    }
+    get(k) {
+        if (typeof k === 'number')
+            return this._arr[k];
+        return this._obj[k.toUpperCase()];
+    }
+    entries() {
+        return Object.entries(this._obj);
+    }
+    keys() {
+        return Object.keys(this._obj);
+    }
+    values() {
+        return [...this._arr];
+    }
+}
+exports.FieldInfoMap = FieldInfoMap;

package/dist/client/SqbClient.d.ts

@@ -0,0 +1,70 @@
+import { Pool as LightningPool } from 'lightning-pool';
+import { Maybe, Type } from 'ts-gems';
+import { classes } from '@sqb/builder';
+import { ClientConfiguration, QueryExecuteOptions, TransactionFunction, ClientDefaults, ConnectionOptions, QueryRequest, ObjectQueryResult, ArrayQueryResult } from './types';
+import { SqbConnection } from './SqbConnection';
+import { Repository } from '../orm/repository.class';
+declare const inspect: unique symbol;
+interface SqbClientEvents {
+    execute: (request: QueryRequest) => void;
+    error: (error: Error) => void;
+    closing: () => void;
+    close: () => void;
+    acquire: (connection: SqbConnection) => Promise<void>;
+    terminate: () => void;
+}
+declare const SqbClient_base: Type<import("strict-typed-events").TypedEventEmitter<any, SqbClientEvents, SqbClientEvents>>;
+export declare class SqbClient extends SqbClient_base {
+    private readonly _adapter;
+    private readonly _pool;
+    private readonly _defaults;
+    private readonly _entities;
+    constructor(config: ClientConfiguration);
+    get defaults(): ClientDefaults;
+    /**
+     * Returns dialect
+     */
+    get dialect(): string;
+    /**
+     * Returns database driver name
+     */
+    get driver(): string;
+    /**
+     * Returns true if pool is closed
+     */
+    get isClosed(): boolean;
+    get pool(): LightningPool;
+    /**
+     * Obtains a connection from the connection pool and executes the callback
+     */
+    acquire(fn: TransactionFunction, options?: ConnectionOptions): Promise<any>;
+    /**
+     * Obtains a connection from the connection pool.
+     */
+    acquire(options?: ConnectionOptions): Promise<SqbConnection>;
+    /**
+     * Shuts down the pool and destroys all resources.
+     */
+    close(terminateWait?: number): Promise<void>;
+    /**
+     * Executes a query or callback with a new acquired connection.
+     */
+    execute(query: string | classes.Query, options?: QueryExecuteOptions & {
+        objectRows: true;
+    }): Promise<ObjectQueryResult>;
+    execute(query: string | classes.Query, options?: QueryExecuteOptions & {
+        objectRows: false;
+    }): Promise<ArrayQueryResult>;
+    execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<ObjectQueryResult | ArrayQueryResult>;
+    /**
+     * Tests the pool
+     */
+    test(): Promise<void>;
+    getRepository<T>(entity: Type<T> | string, opts?: {
+        schema?: string;
+    }): Repository<T>;
+    getEntity<T>(name: string): Maybe<Type<T>>;
+    toString(): string;
+    [inspect](): string;
+}
+export {};