@sqb/connect 4.0.7 → 4.0.8

package/dist/orm/commands/destroy.command.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DestroyCommand = void 0;
-const builder_1 = require("@sqb/builder");
-const command_helper_1 = require("./command.helper");
-class DestroyCommand {
-    // istanbul ignore next
-    constructor() {
-        throw new Error('This class is abstract');
-    }
-    static async execute(args) {
-        const { connection, entity, filter, params } = args;
-        let where;
-        if (filter) {
-            where = (0, builder_1.And)();
-            await (0, command_helper_1.prepareFilter)(entity, filter, where);
-        }
-        const query = (0, builder_1.Delete)(entity.tableName + ' T');
-        if (where)
-            query.where(...where._items);
-        // Execute query
-        const resp = await connection.execute(query, {
-            params,
-            objectRows: false,
-            cursor: false,
-        });
-        return (resp && resp.rowsAffected) || 0;
-    }
-}
-exports.DestroyCommand = DestroyCommand;

package/dist/orm/commands/find.command.d.ts

@@ -1,44 +0,0 @@
-import type { Repository } from '../repository.class';
-import type { EntityModel } from '../model/entity-model';
-import { RowConverter } from './row-converter';
-import { AssociationNode } from '../model/association-node';
-import { SqbConnection } from '../../client/SqbConnection';
-export declare type FindCommandArgs = {
-    entity: EntityModel;
-    connection: SqbConnection;
-} & Repository.FindAllOptions;
-export declare class FindCommand {
-    maxEagerFetch: number;
-    maxSubQueries: number;
-    readonly mainEntity: EntityModel;
-    readonly resultEntity: EntityModel;
-    readonly converter: RowConverter;
-    readonly mainAlias: string;
-    resultAlias: string;
-    private _joins;
-    private _selectColumns;
-    private _filter;
-    private _sort?;
-    protected constructor(selectEntity: EntityModel, outputEntity: EntityModel);
-    static create(source: EntityModel | AssociationNode, opts?: {
-        maxSubQueries?: number;
-        maxEagerFetch?: number;
-    }): Promise<FindCommand>;
-    static execute(args: FindCommandArgs): Promise<any[]>;
-    addElements(opts?: {
-        tableAlias?: string;
-        converter?: RowConverter;
-        entity?: EntityModel;
-        elements?: string[];
-        include?: string[];
-        exclude?: string[];
-        sort?: string[];
-        prefix?: string;
-        suffix?: string;
-    }): Promise<void>;
-    private _selectColumn;
-    filter(filter: any): Promise<void>;
-    sort(sortElements: string[]): Promise<void>;
-    execute(args: Pick<FindCommandArgs, 'connection' | 'distinct' | 'offset' | 'limit' | 'params' | 'onTransformRow'>): Promise<any[]>;
-    private _getEntityFromAlias;
-}

package/dist/orm/commands/find.command.js

@@ -1,308 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FindCommand = void 0;
-const builder_1 = require("@sqb/builder");
-const row_converter_1 = require("./row-converter");
-const association_node_1 = require("../model/association-node");
-const orm_helper_1 = require("../util/orm.helper");
-const command_helper_1 = require("./command.helper");
-const base_entity_class_1 = require("../base-entity.class");
-const SORT_ORDER_PATTERN = /^([-+])?(.*)$/;
-class FindCommand {
-    constructor(selectEntity, outputEntity) {
-        this.maxEagerFetch = 100000;
-        this.maxSubQueries = 5;
-        this.mainAlias = 'T';
-        this.resultAlias = 'T';
-        this._joins = [];
-        this._selectColumns = {};
-        this._filter = (0, builder_1.And)();
-        this.mainEntity = selectEntity;
-        this.resultEntity = outputEntity;
-        this.converter = new row_converter_1.RowConverter(outputEntity.ctor);
-    }
-    static async create(source, opts = {}) {
-        let command;
-        let listingEntity;
-        if (source instanceof association_node_1.AssociationNode) {
-            const node = source;
-            listingEntity = await node.resolveTarget();
-            const resultEntity = await node.getLast().resolveTarget();
-            command = new FindCommand(listingEntity, resultEntity);
-            if (node.conditions)
-                await command.filter(node.conditions);
-            if (node.next) {
-                const join = await (0, command_helper_1.joinAssociationGetLast)(command._joins, node.next, command.mainAlias);
-                command.resultAlias = join.joinAlias;
-            }
-        }
-        else {
-            listingEntity = source;
-            command = new FindCommand(listingEntity, listingEntity);
-        }
-        if (!listingEntity.tableName)
-            throw new Error(`${listingEntity.ctor.name} is not decorated with @Entity decorator`);
-        if (typeof opts.maxSubQueries === 'number')
-            command.maxSubQueries = opts.maxSubQueries;
-        if (typeof opts.maxEagerFetch === 'number')
-            command.maxEagerFetch = opts.maxEagerFetch;
-        return command;
-    }
-    static async execute(args) {
-        const command = await FindCommand.create(args.entity, {
-            maxSubQueries: args.maxSubQueries,
-            maxEagerFetch: args.maxEagerFetch,
-        });
-        await command.addElements({
-            elements: args.elements,
-            include: args.include,
-            exclude: args.exclude,
-            sort: args.sort
-        });
-        if (args.filter)
-            await command.filter(args.filter);
-        if (args.sort)
-            await command.sort(args.sort);
-        return await command.execute(args);
-    }
-    async addElements(opts = {}) {
-        const tableAlias = opts.tableAlias || this.resultAlias;
-        const entity = opts.entity || this._getEntityFromAlias(tableAlias);
-        const converter = opts.converter || this.converter;
-        const _elements = opts.elements ?
-            opts.elements.map(x => x.toLowerCase()) : undefined;
-        const _include = opts.include ?
-            opts.include.map(x => x.toLowerCase()) : undefined;
-        const _exclude = opts.exclude ?
-            opts.exclude.map(x => x.toLowerCase()) : undefined;
-        const requestElements = _elements ? [..._elements] :
-            (0, base_entity_class_1.getNonAssociationElementNames)(entity.ctor)
-                .map(x => x.toLowerCase());
-        if (_include)
-            requestElements.push(..._include);
-        const sortElements = opts.sort && opts.sort.length ?
-            opts.sort.map(x => x.toLowerCase()) : undefined;
-        const prefix = opts.prefix || '';
-        const suffix = opts.suffix || '';
-        for (const key of entity.elementKeys) {
-            const col = entity.getElement(key);
-            if (!col)
-                continue;
-            const colNameLower = col.name.toLowerCase();
-            // Ignore element if in excluded list
-            if (_exclude && _exclude.includes(colNameLower))
-                continue;
-            // Check if element request list
-            if (!requestElements.find((x) => x === colNameLower || x.startsWith(colNameLower + '.')))
-                continue;
-            // Add field to select list if element is a column
-            if ((0, orm_helper_1.isColumnElement)(col)) {
-                const fieldAlias = this._selectColumn(tableAlias, col, prefix, suffix);
-                // Add column to converter
-                if (!col.hidden)
-                    converter.addValueProperty({
-                        name: col.name,
-                        fieldAlias,
-                        dataType: col.dataType,
-                        parse: col.parse
-                    });
-                continue;
-            }
-            if ((0, orm_helper_1.isObjectElement)(col)) {
-                const typ = await col.resolveType();
-                const subConverter = converter.addObjectProperty({
-                    name: col.name,
-                    type: typ.ctor
-                }).converter;
-                await this.addElements({
-                    tableAlias,
-                    converter: subConverter,
-                    entity: typ,
-                    prefix: col.fieldNamePrefix,
-                    suffix: col.fieldNameSuffix,
-                    elements: _elements?.includes(colNameLower) ? undefined :
-                        extractSubElements(colNameLower, _elements),
-                    include: extractSubElements(colNameLower, _include),
-                    exclude: extractSubElements(colNameLower, _exclude),
-                    sort: extractSubElements(colNameLower, sortElements),
-                });
-                continue;
-            }
-            if ((0, orm_helper_1.isAssociationElement)(col)) {
-                // OtO relation
-                if (!col.association.returnsMany()) {
-                    const joinInfo = await (0, command_helper_1.joinAssociationGetLast)(this._joins, col.association, tableAlias);
-                    const subConverter = converter.addObjectProperty({
-                        name: col.name,
-                        type: joinInfo.targetEntity.ctor
-                    }).converter;
-                    // Add join fields to select columns list
-                    await this.addElements({
-                        tableAlias: joinInfo.joinAlias,
-                        converter: subConverter,
-                        entity: joinInfo.targetEntity,
-                        elements: _elements?.includes(colNameLower) ? undefined :
-                            extractSubElements(colNameLower, _elements),
-                        include: extractSubElements(colNameLower, _include),
-                        exclude: extractSubElements(colNameLower, _exclude),
-                        sort: extractSubElements(colNameLower, sortElements),
-                    });
-                    continue;
-                }
-                // One-2-Many Eager relation
-                if (this.maxSubQueries > 0) {
-                    const targetCol = await col.association.resolveTargetProperty();
-                    const sourceCol = await col.association.resolveSourceProperty();
-                    // We need to know key value to filter sub query.
-                    // So add key field into select columns
-                    const parentField = this._selectColumn(tableAlias, sourceCol);
-                    const findCommand = await FindCommand.create(col.association, {
-                        maxSubQueries: this.maxSubQueries - 1,
-                        maxEagerFetch: this.maxEagerFetch
-                    });
-                    await findCommand.filter((0, builder_1.In)(targetCol.name, (0, builder_1.Param)(parentField)));
-                    const sort = sortElements && extractSubElements(colNameLower, sortElements);
-                    await findCommand.addElements({
-                        elements: _elements?.includes(colNameLower) ? undefined :
-                            extractSubElements(colNameLower, _elements),
-                        include: extractSubElements(colNameLower, _include),
-                        exclude: extractSubElements(colNameLower, _exclude),
-                        sort,
-                    });
-                    if (sort)
-                        await findCommand.sort(sort);
-                    const keyField = findCommand._selectColumn(findCommand.mainAlias, targetCol);
-                    const resultType = await col.association.getLast().resolveTarget();
-                    converter.addNestedProperty({
-                        name: col.name,
-                        type: resultType.ctor,
-                        findCommand,
-                        parentField,
-                        keyField,
-                        sort: extractSubElements(colNameLower, sortElements)
-                    });
-                }
-            }
-        }
-    }
-    _selectColumn(tableAlias, el, prefix, suffix) {
-        const fieldName = (prefix || '').toLowerCase() +
-            el.fieldName.toUpperCase() +
-            (suffix || '').toLowerCase();
-        const fieldAlias = tableAlias + '_' + fieldName;
-        this._selectColumns[fieldAlias] = {
-            element: el,
-            statement: tableAlias + '.' + fieldName + ' as ' + fieldAlias
-        };
-        return fieldAlias;
-    }
-    async filter(filter) {
-        await (0, command_helper_1.prepareFilter)(this.mainEntity, filter, this._filter);
-    }
-    async sort(sortElements) {
-        const orderColumns = [];
-        for (const item of sortElements) {
-            const m = item.match(SORT_ORDER_PATTERN);
-            if (!m)
-                throw new Error(`"${item}" is not a valid order expression`);
-            let elName = m[2];
-            let prefix = '';
-            let suffix = '';
-            let _entityDef = this.resultEntity;
-            let tableAlias = this.resultAlias;
-            if (elName.includes('.')) {
-                const a = elName.split('.');
-                while (a.length > 1) {
-                    const col = _entityDef.getElement(a.shift() || '');
-                    if ((0, orm_helper_1.isObjectElement)(col)) {
-                        _entityDef = await col.resolveType();
-                        if (col.fieldNamePrefix)
-                            prefix += col.fieldNamePrefix;
-                        if (col.fieldNameSuffix)
-                            suffix = col.fieldNameSuffix + suffix;
-                    }
-                    else if ((0, orm_helper_1.isAssociationElement)(col)) {
-                        if (col.association.returnsMany()) {
-                            elName = '';
-                            break;
-                        }
-                        const joinInfo = await (0, command_helper_1.joinAssociationGetLast)(this._joins, col.association, tableAlias);
-                        tableAlias = joinInfo.joinAlias;
-                        _entityDef = joinInfo.targetEntity;
-                    }
-                    else
-                        throw new Error(`Invalid column (${elName}) declared in sort property`);
-                }
-                if (!elName)
-                    continue;
-                elName = a.shift() || '';
-            }
-            const col = _entityDef.getElement(elName);
-            if (!col)
-                throw new Error(`Unknown element (${elName}) declared in sort property`);
-            if (!(0, orm_helper_1.isColumnElement)(col))
-                throw new Error(`Can not sort by "${elName}", because it is not a data column`);
-            const dir = m[1] || '+';
-            orderColumns.push((dir || '') + tableAlias + '.' + prefix + col.fieldName + suffix);
-        }
-        this._sort = orderColumns;
-    }
-    async execute(args) {
-        // Generate select query
-        const columnSqls = Object.keys(this._selectColumns)
-            .map(x => this._selectColumns[x].statement);
-        if (!columnSqls.length)
-            columnSqls.push('1');
-        const query = (0, builder_1.Select)(...columnSqls)
-            .from(this.mainEntity.tableName + ' as ' + this.mainAlias);
-        if (args.distinct)
-            query.distinct();
-        query.where(...this._filter._items);
-        if (this._sort) {
-            query.orderBy(...this._sort);
-        }
-        if (args.offset)
-            query.offset(args.offset);
-        // joins must be added last
-        if (this._joins)
-            for (const j of this._joins) {
-                query.join(j.join);
-            }
-        // Execute query
-        const resp = await args.connection.execute(query, {
-            params: args?.params,
-            fetchRows: args?.limit,
-            objectRows: false,
-            cursor: false
-        });
-        // Create objects
-        if (resp.rows && resp.fields) {
-            return this.converter.transform(args.connection, resp.fields, resp.rows, args.onTransformRow);
-        }
-        return [];
-    }
-    _getEntityFromAlias(tableAlias) {
-        if (tableAlias === this.mainAlias)
-            return this.mainEntity;
-        if (tableAlias === this.resultAlias)
-            return this.resultEntity;
-        if (this._joins) {
-            const join = this._joins.find(j => j.joinAlias === tableAlias);
-            if (join)
-                return join.targetEntity;
-        }
-        throw new Error(`Unknown table alias "${tableAlias}"`);
-    }
-}
-exports.FindCommand = FindCommand;
-function extractSubElements(colNameLower, elements) {
-    if (!(elements && elements.length))
-        return;
-    if (elements) {
-        return elements.reduce((trg, v) => {
-            if (v.startsWith(colNameLower + '.'))
-                trg.push(v.substring(colNameLower.length + 1).toLowerCase());
-            return trg;
-        }, []);
-    }
-}

package/dist/orm/commands/row-converter.d.ts

@@ -1,55 +0,0 @@
-import { Type } from 'ts-gems';
-import type { FieldInfoMap } from '../../client/FieldInfoMap';
-import type { FindCommand } from './find.command';
-import type { Repository } from '../repository.class';
-import { ColumnTransformFunction } from '../orm.type';
-import { SqbConnection } from '../../client/SqbConnection';
-import { DataType } from '@sqb/builder';
-export interface ValueProperty {
-    fieldAlias: string;
-    dataType?: DataType;
-    parse?: ColumnTransformFunction;
-}
-export interface ObjectProperty {
-    converter: RowConverter;
-    type: Type;
-}
-export interface NestedProperty {
-    converter: RowConverter;
-    type: Type;
-    parentField: string;
-    keyField: string;
-    findCommand: FindCommand;
-    sort?: string[];
-    paramValues: any[];
-}
-export declare class RowConverter {
-    resultType: Type;
-    parent?: RowConverter | undefined;
-    private _properties;
-    private _propertyKeys?;
-    constructor(resultType: Type, parent?: RowConverter | undefined);
-    addValueProperty(args: {
-        name: string;
-        fieldAlias: string;
-        dataType?: DataType;
-        parse?: ColumnTransformFunction;
-    }): ValueProperty;
-    addObjectProperty(args: {
-        name: string;
-        type: Type;
-    }): ObjectProperty;
-    addNestedProperty(args: {
-        name: string;
-        type: Type;
-        findCommand: FindCommand;
-        parentField: string;
-        keyField: string;
-        sort?: string[];
-    }): NestedProperty;
-    get keys(): string[];
-    transform(connection: SqbConnection, fields: FieldInfoMap, rows: any, onTransform?: Repository.TransformRowFunction): Promise<any[]>;
-    private _rowToObject;
-    private _iterateForNested;
-    private _checkCircularDep;
-}

package/dist/orm/commands/row-converter.js

@@ -1,187 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RowConverter = void 0;
-const builder_1 = require("@sqb/builder");
-const isValueProperty = (prop) => {
-    return prop.fieldAlias && !prop.converter;
-};
-const isObjectProperty = (prop) => {
-    return prop.converter && !prop.findCommand;
-};
-const isNestedProperty = (prop) => {
-    return prop.converter && prop.findCommand;
-};
-class RowConverter {
-    constructor(resultType, parent) {
-        this.resultType = resultType;
-        this.parent = parent;
-        this._properties = {};
-    }
-    addValueProperty(args) {
-        this._propertyKeys = undefined;
-        const item = {
-            fieldAlias: args.fieldAlias,
-            dataType: args.dataType,
-            parse: args.parse
-        };
-        this._properties[args.name] = item;
-        return item;
-    }
-    addObjectProperty(args) {
-        this._checkCircularDep(args.type);
-        this._propertyKeys = undefined;
-        const converter = new RowConverter(args.type, this);
-        const item = {
-            converter,
-            type: args.type
-        };
-        this._properties[args.name] = item;
-        return item;
-    }
-    addNestedProperty(args) {
-        this._checkCircularDep(args.type);
-        const converter = new RowConverter(args.type, this);
-        const item = {
-            converter,
-            type: args.type,
-            parentField: args.parentField,
-            keyField: args.keyField,
-            findCommand: args.findCommand,
-            sort: args.sort,
-            paramValues: []
-        };
-        this._properties[args.name] = item;
-        return item;
-    }
-    get keys() {
-        if (!this._propertyKeys)
-            this._propertyKeys = Object.keys(this._properties);
-        return this._propertyKeys;
-    }
-    async transform(connection, fields, rows, onTransform) {
-        const rowLen = rows.length;
-        const result = [];
-        for (let rowIdx = 0; rowIdx < rowLen; rowIdx++) {
-            const row = rows[rowIdx];
-            const o = (await this._rowToObject(connection, fields, row)) || {};
-            if (onTransform)
-                onTransform(fields, row, o);
-            result.push(o);
-        }
-        if (!this.keys)
-            return result;
-        await this._iterateForNested(this, connection, fields, rows, result);
-        // Return only non empty objects
-        return result.filter(x => !!x);
-    }
-    _rowToObject(executor, fields, row) {
-        // Cache keys for better performance
-        const elementKeys = this.keys;
-        const elementLen = elementKeys.length;
-        let result;
-        for (let elIdx = 0; elIdx < elementLen; elIdx++) {
-            const elKey = elementKeys[elIdx];
-            const prop = this._properties[elKey];
-            if (isValueProperty(prop)) {
-                const field = fields.get(prop.fieldAlias);
-                if (field) {
-                    let v = row[field.index];
-                    if (typeof prop.parse === 'function')
-                        v = prop.parse(v, elKey);
-                    if (v != null) {
-                        result = result || {};
-                        if (prop.dataType === builder_1.DataType.JSON && typeof v === 'string')
-                            v = JSON.parse(v);
-                        result[elKey] = v;
-                    }
-                }
-            }
-            else if (isNestedProperty(prop)) {
-                // One2Many Eager element
-                // Keep a list of key field/value pairs to fetch rows for eager relation
-                const _params = prop.paramValues;
-                const f = fields.get(prop.parentField);
-                const v = f && row[f.index];
-                if (v != null && !_params.includes(v))
-                    _params.push(v);
-            }
-            else if (isObjectProperty(prop)) {
-                const v = prop.converter._rowToObject(executor, fields, row);
-                if (v != null) {
-                    result = result || {};
-                    result[elKey] = v;
-                }
-            }
-        }
-        if (result)
-            Object.setPrototypeOf(result, this.resultType.prototype);
-        return result;
-    }
-    async _iterateForNested(node, connection, fields, rows, result) {
-        // Fetch one-2-many related rows and merge with result rows
-        const keys = node.keys;
-        const propertyLen = keys.length;
-        const promises = [];
-        for (let propIdx = 0; propIdx < propertyLen; propIdx++) {
-            const propKey = keys[propIdx];
-            const prop = node._properties[propKey];
-            if (isNestedProperty(prop)) {
-                if (!(prop.paramValues && prop.paramValues.length))
-                    continue;
-                const resultType = this.resultType;
-                const promise = async function (p) {
-                    const findCommand = p.findCommand;
-                    let fld;
-                    const map = new Map();
-                    const r = await findCommand.execute({
-                        connection,
-                        limit: findCommand.maxEagerFetch + 1,
-                        params: { [p.parentField]: p.paramValues },
-                        onTransformRow: (_fields, row, obj) => {
-                            fld = fld || _fields.get('' + p.keyField);
-                            const keyValue = fld && row[fld.index];
-                            if (keyValue != null) {
-                                let arr = map.get(keyValue);
-                                if (!arr) {
-                                    arr = [];
-                                    map.set(keyValue, arr);
-                                }
-                                arr.push(obj);
-                            }
-                        }
-                    });
-                    if (r.length > findCommand.maxEagerFetch)
-                        throw new Error(`Number of returning rows for "${propKey}" exceeds maxEagerFetch limit`);
-                    for (let i = 0; i < result.length; i++) {
-                        const row = rows[i];
-                        let obj = result[i];
-                        if (!obj) {
-                            obj = {};
-                            Object.setPrototypeOf(result, resultType.prototype);
-                        }
-                        const f = fields.get('' + p.parentField);
-                        const keyValue = f && row[f.index];
-                        if (keyValue != null) {
-                            const arr = map.get(keyValue);
-                            if (arr) {
-                                obj[propKey] = arr;
-                            }
-                        }
-                    }
-                }(prop);
-                promises.push(promise);
-            }
-            else if (isObjectProperty(prop)) {
-                promises.push(this._iterateForNested(prop.converter, connection, fields, rows, result));
-            }
-        }
-        await Promise.all(promises);
-    }
-    _checkCircularDep(t) {
-        if (this.resultType === t)
-            throw new Error('Circular elements requested');
-        if (this.parent)
-            this.parent._checkCircularDep(t);
-    }
-}
-exports.RowConverter = RowConverter;

package/dist/orm/commands/update.command.d.ts

@@ -1,22 +0,0 @@
-import { EntityModel } from '../model/entity-model';
-import { Repository } from '../repository.class';
-import { SqbConnection } from '../../client/SqbConnection';
-export declare type UpdateCommandArgs = {
-    entity: EntityModel;
-    connection: SqbConnection;
-    values: any;
-} & Repository.UpdateAllOptions;
-declare type UpdateCommandContext = {
-    entity: EntityModel;
-    queryParams: any;
-    queryValues: any;
-    queryFilter: any[];
-    colCount: number;
-};
-export declare class UpdateCommand {
-    protected constructor();
-    static execute(args: UpdateCommandArgs): Promise<number>;
-    protected static _prepareFilter(ctx: UpdateCommandContext, filter: any): Promise<void>;
-    protected static _prepareParams(ctx: UpdateCommandContext, entity: EntityModel, values: any, prefix?: string, suffix?: string): Promise<void>;
-}
-export {};