@sqb/connect 4.20.7 → 4.21.0

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

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateCommand = void 0;
-const builder_1 = require("@sqb/builder");
-const column_field_metadata_js_1 = require("../model/column-field-metadata.js");
-const embedded_field_metadata_js_1 = require("../model/embedded-field-metadata.js");
-const entity_metadata_js_1 = require("../model/entity-metadata.js");
-const orm_helper_js_1 = require("../util/orm.helper.js");
-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 field given to create new entity instance');
-        const query = (0, builder_1.Insert)(tableName, ctx.queryValues);
-        if (args.returning) {
-            const primaryIndexColumns = entity_metadata_js_1.EntityMetadata.getPrimaryIndexColumns(entity);
-            if (primaryIndexColumns.length)
-                query.returning(...primaryIndexColumns.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_metadata_js_1.EntityMetadata.getColumnFieldByFieldName(entity, 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 Object.values(entity.fields)) {
-            v = values[col.name];
-            if ((0, orm_helper_js_1.isColumnField)(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;
-                }
-                column_field_metadata_js_1.ColumnFieldMetadata.checkEnumValue(col, v);
-                const fieldName = prefix + col.fieldName + suffix;
-                const k = ('I$_' + fieldName).substring(0, 30);
-                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_js_1.isEmbeddedField)(col)) {
-                const type = await embedded_field_metadata_js_1.EmbeddedFieldMetadata.resolveType(col);
-                await this._prepareParams(ctx, type, v, col.fieldNamePrefix, col.fieldNameSuffix);
-            }
-        }
-    }
-}
-exports.CreateCommand = CreateCommand;

package/cjs/orm/commands/delete.command.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteCommand = void 0;
-const builder_1 = require("@sqb/builder");
-const command_helper_js_1 = require("./command.helper.js");
-class DeleteCommand {
-    // 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_js_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.DeleteCommand = DeleteCommand;

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

@@ -1,301 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FindCommand = void 0;
-const builder_1 = require("@sqb/builder");
-const association_node_js_1 = require("../model/association-node.js");
-const embedded_field_metadata_js_1 = require("../model/embedded-field-metadata.js");
-const entity_metadata_js_1 = require("../model/entity-metadata.js");
-const orm_helper_js_1 = require("../util/orm.helper.js");
-const parse_fields_projection_js_1 = require("../util/parse-fields-projection.js");
-const command_helper_js_1 = require("./command.helper.js");
-const row_converter_js_1 = require("./row-converter.js");
-const SORT_ORDER_PATTERN = /^([-+])?(.*)$/;
-class FindCommand {
-    maxEagerFetch = 100000;
-    maxSubQueries = 5;
-    mainEntity;
-    resultEntity;
-    converter;
-    mainAlias = 'T';
-    resultAlias = 'T';
-    _joins = [];
-    _selectColumns = {};
-    _filter = (0, builder_1.And)();
-    _sort;
-    constructor(selectEntity, outputEntity) {
-        this.mainEntity = selectEntity;
-        this.resultEntity = outputEntity;
-        this.converter = new row_converter_js_1.RowConverter(outputEntity.ctor);
-    }
-    static async create(source, opts = {}) {
-        let command;
-        let listingEntity;
-        if (source instanceof association_node_js_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_js_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.addFields({
-            projection: args.projection,
-            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 addFields(opts = {}) {
-        const tableAlias = opts.tableAlias || this.resultAlias;
-        const entity = opts.entity || this._getEntityFromAlias(tableAlias);
-        const converter = opts.converter || this.converter;
-        const projection = typeof opts.projection === 'string' || Array.isArray(opts.projection)
-            ? (0, parse_fields_projection_js_1.parseFieldsProjection)(opts.projection)
-            : opts.projection;
-        const defaultFields = !projection || !Object.values(projection).find(p => !p.sign);
-        const sortFields = opts.sort && opts.sort.length
-            ? opts.sort.map(x => x.toLowerCase())
-            : undefined;
-        const prefix = opts.prefix || '';
-        const suffix = opts.suffix || '';
-        for (const key of Object.keys(entity.fields)) {
-            const col = entity_metadata_js_1.EntityMetadata.getField(entity, key);
-            if (!col || col.hidden)
-                continue;
-            const colNameLower = col.name.toLowerCase();
-            const p = projection?.[colNameLower];
-            if (
-            /** Ignore if field is omitted */
-            p?.sign === '-' ||
-                /** Ignore if default fields and field is not in projection */
-                (!defaultFields && !p) ||
-                /** Ignore if default fields enabled and fields is exclusive */
-                (defaultFields && col.exclusive && !p)) {
-                continue;
-            }
-            // Add field to select list if field is a column
-            if ((0, orm_helper_js_1.isColumnField)(col)) {
-                const fieldAlias = this._selectColumn(tableAlias, col, prefix, suffix);
-                // Add column to converter
-                converter.addValueProperty({
-                    name: col.name,
-                    fieldAlias,
-                    dataType: col.dataType,
-                    parse: col.parse,
-                });
-                continue;
-            }
-            if ((0, orm_helper_js_1.isEmbeddedField)(col)) {
-                const typ = await embedded_field_metadata_js_1.EmbeddedFieldMetadata.resolveType(col);
-                const subConverter = converter.addObjectProperty({
-                    name: col.name,
-                    type: typ.ctor,
-                }).converter;
-                await this.addFields({
-                    tableAlias,
-                    converter: subConverter,
-                    entity: typ,
-                    prefix: col.fieldNamePrefix,
-                    suffix: col.fieldNameSuffix,
-                    projection: p?.projection,
-                    sort: extractSubFields(colNameLower, sortFields),
-                });
-                continue;
-            }
-            if ((0, orm_helper_js_1.isAssociationField)(col)) {
-                // OtO relation
-                if (!col.association.returnsMany()) {
-                    const joinInfo = await (0, command_helper_js_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.addFields({
-                        tableAlias: joinInfo.joinAlias,
-                        converter: subConverter,
-                        entity: joinInfo.targetEntity,
-                        projection: p?.projection,
-                        sort: extractSubFields(colNameLower, sortFields),
-                    });
-                    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,
-                    });
-                    findCommand.converter.parent = this.converter;
-                    await findCommand.filter((0, builder_1.In)(targetCol.name, (0, builder_1.Param)(parentField)));
-                    const sort = sortFields && extractSubFields(colNameLower, sortFields);
-                    await findCommand.addFields({
-                        projection: p?.projection,
-                        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: extractSubFields(colNameLower, sortFields),
-                    });
-                }
-            }
-        }
-    }
-    _selectColumn(tableAlias, el, prefix, suffix) {
-        const fieldName = (prefix || '').toLowerCase() +
-            el.fieldName.toUpperCase() +
-            (suffix || '').toLowerCase();
-        const fieldAlias = (tableAlias + '_' + fieldName).substring(0, 30);
-        this._selectColumns[fieldAlias] = {
-            field: el,
-            statement: tableAlias + '.' + fieldName + ' as ' + fieldAlias,
-        };
-        return fieldAlias;
-    }
-    async filter(filter) {
-        await (0, command_helper_js_1.prepareFilter)(this.mainEntity, filter, this._filter);
-    }
-    async sort(sortFields) {
-        const out = [];
-        for (const item of sortFields) {
-            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 = entity_metadata_js_1.EntityMetadata.getField(_entityDef, a.shift() || '');
-                    if ((0, orm_helper_js_1.isEmbeddedField)(col)) {
-                        _entityDef = await embedded_field_metadata_js_1.EmbeddedFieldMetadata.resolveType(col);
-                        if (col.fieldNamePrefix)
-                            prefix += col.fieldNamePrefix;
-                        if (col.fieldNameSuffix)
-                            suffix = col.fieldNameSuffix + suffix;
-                    }
-                    else if ((0, orm_helper_js_1.isAssociationField)(col)) {
-                        if (col.association.returnsMany()) {
-                            elName = '';
-                            break;
-                        }
-                        const joinInfo = await (0, command_helper_js_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 = entity_metadata_js_1.EntityMetadata.getField(_entityDef, elName);
-            if (!col)
-                throw new Error(`Unknown field (${elName}) declared in sort property`);
-            if (!(0, orm_helper_js_1.isColumnField)(col))
-                throw new Error(`Can not sort by "${elName}", because it is not a data column`);
-            const dir = m[1] || '+';
-            out.push((dir || '') + tableAlias + '.' + prefix + col.fieldName + suffix);
-        }
-        this._sort = out;
-    }
-    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,
-            prettyPrint: args.prettyPrint,
-        });
-        // 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 extractSubFields(colNameLower, fields) {
-    if (!(fields && fields.length))
-        return;
-    if (fields) {
-        return fields.reduce((trg, v) => {
-            if (v.startsWith(colNameLower + '.'))
-                trg.push(v.substring(colNameLower.length + 1).toLowerCase());
-            return trg;
-        }, []);
-    }
-}

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

@@ -1,190 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RowConverter = void 0;
-const builder_1 = require("@sqb/builder");
-const isValueProperty = (prop) => prop.fieldAlias && !prop.converter;
-const isObjectProperty = (prop) => prop.converter && !prop.findCommand;
-const isNestedProperty = (prop) => prop.converter && prop.findCommand;
-class RowConverter {
-    resultType;
-    parent;
-    _properties = {};
-    _propertyKeys;
-    constructor(resultType, parent) {
-        this.resultType = resultType;
-        this.parent = parent;
-    }
-    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 fieldKeys = this.keys;
-        const fieldsLen = fieldKeys.length;
-        let result;
-        for (let elIdx = 0; elIdx < fieldsLen; elIdx++) {
-            const elKey = fieldKeys[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 field
-                // 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) {
-                                const keyValues = Array.isArray(keyValue)
-                                    ? keyValue
-                                    : [keyValue];
-                                keyValues.forEach(k => {
-                                    let arr = map.get(k);
-                                    if (!arr) {
-                                        arr = [];
-                                        map.set(k, 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 fields requested');
-        if (this.parent)
-            this.parent._checkCircularDep(t);
-    }
-}
-exports.RowConverter = RowConverter;