@sqb/connect 4.0.7 → 4.0.10

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

@@ -1,20 +0,0 @@
-import type { EntityModel } from '../model/entity-model';
-import { SqbConnection } from '../../client/SqbConnection';
-export declare type CreateCommandArgs = {
-    entity: EntityModel;
-    connection: SqbConnection;
-    values: any;
-    returning?: boolean;
-};
-declare type CreateCommandContext = {
-    entity: EntityModel;
-    queryParams: any;
-    queryValues: any;
-    colCount: number;
-};
-export declare class CreateCommand {
-    protected constructor();
-    static execute(args: CreateCommandArgs): Promise<any>;
-    protected static _prepareParams(ctx: CreateCommandContext, entity: EntityModel, values: any, prefix?: string, suffix?: string): Promise<void>;
-}
-export {};

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

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateCommand = void 0;
-const builder_1 = require("@sqb/builder");
-const orm_helper_1 = require("../util/orm.helper");
-class CreateCommand {
-    // istanbul ignore next
-    constructor() {
-        throw new Error('This class is abstract');
-    }
-    static async execute(args) {
-        const { entity } = args;
-        const tableName = entity.tableName;
-        if (!tableName)
-            throw new Error(`${entity.ctor.name} is not decorated with @Entity decorator`);
-        // Create a context
-        const ctx = {
-            entity,
-            queryParams: {},
-            queryValues: {},
-            colCount: 0
-        };
-        // Prepare
-        await this._prepareParams(ctx, entity, args.values);
-        if (!ctx.colCount)
-            throw new Error('No element given to create new entity instance');
-        const query = (0, builder_1.Insert)(tableName, ctx.queryValues);
-        if (args.returning && entity.primaryIndex)
-            query.returning(...entity.getPrimaryIndexColumns().map(col => col.fieldName));
-        const qr = await args.connection.execute(query, {
-            params: ctx.queryParams,
-            objectRows: false,
-            cursor: false
-        });
-        if (args.returning && qr.fields && qr.rows?.length) {
-            const keyValues = {};
-            for (const f of qr.fields.values()) {
-                const el = entity.getColumnElementByFieldName(f.fieldName);
-                if (el)
-                    keyValues[el.name] = qr.rows[0][f.index];
-            }
-            return keyValues;
-        }
-    }
-    static async _prepareParams(ctx, entity, values, prefix, suffix) {
-        let v;
-        prefix = prefix || '';
-        suffix = suffix || '';
-        for (const col of entity.elements.values()) {
-            v = values[col.name];
-            if ((0, orm_helper_1.isColumnElement)(col)) {
-                if (col.noInsert)
-                    continue;
-                if (v == null && col.default !== undefined) {
-                    v = typeof col.default === 'function' ?
-                        col.default(values) : col.default;
-                }
-                if (typeof col.serialize === 'function')
-                    v = col.serialize(v, col.name);
-                if (v == null) {
-                    if (col.notNull && !col.autoGenerated)
-                        throw new Error(`${entity.name}.${col.name} is required and can't be null`);
-                    continue;
-                }
-                col.checkEnumValue(v);
-                const fieldName = prefix + col.fieldName + suffix;
-                const k = '$input_' + fieldName;
-                ctx.queryValues[fieldName] = (0, builder_1.Param)({
-                    name: k,
-                    dataType: col.dataType,
-                    isArray: col.isArray
-                });
-                ctx.queryParams[k] = v;
-                ctx.colCount++;
-            }
-            else if (v != null && (0, orm_helper_1.isObjectElement)(col)) {
-                const type = await col.resolveType();
-                await this._prepareParams(ctx, type, v, col.fieldNamePrefix, col.fieldNameSuffix);
-            }
-        }
-    }
-}
-exports.CreateCommand = CreateCommand;

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

@@ -1,11 +0,0 @@
-import { EntityModel } from '../model/entity-model';
-import { Repository } from '../repository.class';
-import { SqbConnection } from '../../client/SqbConnection';
-export declare type DestroyCommandArgs = {
-    entity: EntityModel;
-    connection: SqbConnection;
-} & Repository.DestroyOptions;
-export declare class DestroyCommand {
-    protected constructor();
-    static execute(args: DestroyCommandArgs): Promise<number>;
-}

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;
-}