@sqb/connect 4.2.1 → 4.5.0

package/{dist/client/CursorStream.d.ts → esm/client/cursor-stream.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Readable } from 'stream';
-import { Cursor } from './Cursor';
+import { Cursor } from './cursor.js';
 export interface CursorStreamOptions {
     objectMode?: boolean;
     limit?: number;

package/esm/client/cursor-stream.js

@@ -0,0 +1,96 @@
+import _debug from 'debug';
+import { Readable } from 'stream';
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const debug = _debug('sqb:cursorstream');
+export class CursorStream extends Readable {
+    _cursor;
+    _objectMode;
+    _limit;
+    _rowNum = -1;
+    _eof = false;
+    constructor(cursor, options) {
+        super(options);
+        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;
+        }
+    }
+}

package/{dist/client/Cursor.d.ts → esm/client/cursor.d.ts}

@@ -1,8 +1,8 @@
-import { Adapter } from './Adapter';
-import { CursorStream, CursorStreamOptions } from './CursorStream';
-import { FieldInfoMap } from './FieldInfoMap';
-import { SqbConnection } from './SqbConnection';
-import { ObjectRow, QueryRequest } from './types';
+import { Adapter } from './adapter.js';
+import { CursorStream, CursorStreamOptions } from './cursor-stream.js';
+import { FieldInfoMap } from './field-info-map.js';
+import { SqbConnection } from './sqb-connection.js';
+import { ObjectRow, QueryRequest } from './types.js';
 interface CursorEvents {
     close: () => void;
     error: (error: unknown) => void;

package/esm/client/cursor.js

@@ -0,0 +1,252 @@
+import _debug from 'debug';
+import DoublyLinked from 'doublylinked';
+import TaskQueue from 'putil-taskqueue';
+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) {
+    _connection;
+    _fields;
+    _prefetchRows;
+    _request;
+    _intlcur;
+    _taskQueue = new TaskQueue();
+    _fetchCache = new DoublyLinked();
+    _rowNum = 0;
+    _fetchedAll = false;
+    _fetchedRows = 0;
+    _row;
+    _cache;
+    constructor(connection, fields, adapterCursor, request) {
+        super();
+        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();
+    }
+    /**
+     * 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(this, options);
+    }
+    toString() {
+        return '[object ' + Object.getPrototypeOf(this).constructor.name + ']';
+    }
+    inspect() {
+        return this.toString();
+    }
+    /**
+     *
+     */
+    async _seek(step, silent) {
+        step = 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 ?
+                normalizeRowsToObjectRows(this._fields, this._intlcur.rowType, rows, this._request) :
+                normalizeRowsToArrayRows(this._fields, this._intlcur.rowType, rows, this._request);
+            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();
+    }
+}

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

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

package/esm/client/extensions.js

@@ -0,0 +1,9 @@
+export let adapters = [];
+export function registerAdapter(adapter) {
+    if (!adapter.driver)
+        throw new TypeError('A DatabaseAdapter must contain "driver" property');
+    adapters.push(adapter);
+}
+export function unRegisterAdapter(...adapter) {
+    adapters = adapters.filter(x => !adapter.includes(x));
+}

package/{dist/client/FieldInfoMap.d.ts → esm/client/field-info-map.d.ts}

@@ -1,4 +1,4 @@
-import { FieldInfo } from './types';
+import { FieldInfo } from './types.js';
 export declare class FieldInfoMap {
     private _obj;
     private _arr;

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

@@ -0,0 +1,50 @@
+export class FieldInfoMap {
+    _obj;
+    _arr;
+    constructor() {
+        Object.defineProperty(this, '_obj', {
+            enumerable: false,
+            configurable: false,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, '_arr', {
+            enumerable: false,
+            configurable: false,
+            writable: true,
+            value: []
+        });
+    }
+    add(field) {
+        const idx = field.index != null ? field.index : this._arr.length;
+        this._arr[idx] = field;
+        field.index = idx;
+        const _obj = this._arr.reduce((a, f) => {
+            a[f.name.toUpperCase()] = f;
+            return a;
+        }, {});
+        Object.defineProperty(this, '_obj', {
+            enumerable: false,
+            configurable: false,
+            writable: true,
+            value: _obj
+        });
+    }
+    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];
+    }
+    toJSON() {
+        return { ...this._obj };
+    }
+}

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

@@ -1,7 +1,7 @@
 import { Maybe } from 'ts-gems';
-import { Adapter } from './Adapter';
-import { FieldInfoMap } from './FieldInfoMap';
-import { ArrayRowset, FieldNaming, ObjectRowset, QueryRequest } from './types';
+import { Adapter } from './adapter.js';
+import { FieldInfoMap } from './field-info-map.js';
+import { ArrayRowset, FieldNaming, ObjectRowset, QueryRequest } from './types.js';
 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>[];

package/esm/client/helpers.js

@@ -0,0 +1,125 @@
+import { camelCase, pascalCase } from "putil-varhelpers";
+import { FieldInfoMap } from './field-info-map.js';
+export 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 camelCase(value.toLowerCase());
+                value = camelCase(value);
+                return value[0].toLowerCase() + value.substring(1);
+            case 'pascalcase':
+                if (!value.match(/[a-z]/))
+                    return pascalCase(value.toLowerCase());
+                return pascalCase(value);
+        }
+    }
+    else if (typeof namingStrategy === 'function')
+        return namingStrategy(value);
+    return value;
+}
+export function wrapAdapterFields(oldFields, fieldNaming) {
+    const mapFieldInfo = (f, index) => {
+        const name = applyNamingStrategy(f.fieldName, fieldNaming);
+        if (name)
+            return { ...f, name, index };
+    };
+    const result = new FieldInfoMap();
+    let i = 0;
+    oldFields.forEach(f => {
+        const x = mapFieldInfo(f, i);
+        if (x) {
+            i++;
+            result.add(x);
+        }
+    });
+    return result;
+}
+export function normalizeRowsToObjectRows(fields, rowType, oldRows, options) {
+    return normalizeRows(fields, rowType, oldRows, { ...options, objectRows: true });
+}
+export function normalizeRowsToArrayRows(fields, rowType, oldRows, options) {
+    return normalizeRows(fields, rowType, oldRows, { ...options, objectRows: false });
+}
+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;
+    });
+}
+export function callFetchHooks(rows, request) {
+    const fetchHooks = request.fetchHooks;
+    if (!fetchHooks)
+        return;
+    for (const row of rows) {
+        for (const fn of fetchHooks) {
+            fn(row, request);
+        }
+    }
+}

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

@@ -1,9 +1,9 @@
 import { Pool as LightningPool } from 'lightning-pool';
 import { Maybe, Type } from 'ts-gems';
 import { classes } from '@sqb/builder';
-import { Repository } from '../orm/repository.class';
-import { SqbConnection } from './SqbConnection';
-import { ArrayQueryResult, ClientConfiguration, ClientDefaults, ConnectionOptions, ObjectQueryResult, QueryExecuteOptions, QueryRequest, TransactionFunction } from './types';
+import { Repository } from '../orm/repository.class.js';
+import { SqbConnection } from './sqb-connection.js';
+import { ClientConfiguration, ClientDefaults, ConnectionOptions, QueryExecuteOptions, QueryRequest, QueryResult, TransactionFunction } from './types.js';
 declare const inspect: unique symbol;
 interface SqbClientEvents {
     execute: (request: QueryRequest) => void;
@@ -49,13 +49,7 @@ export declare class SqbClient extends SqbClient_base {
     /**
      * 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>;
+    execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<QueryResult>;
     /**
      * Tests the pool
      */