@sqb/connect 4.14.1 → 4.15.0

package/esm/orm/commands/command.helper.js

@@ -1,16 +1,22 @@
-import { And, Eq, Exists, Field, InnerJoin, isCompOperator, isLogicalOperator, LeftOuterJoin, op, OperatorType, Raw, Select, } from '@sqb/builder';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
-import { EntityMetadata } from '../model/entity-metadata.js';
-import { isAssociationField, isColumnField, isEmbeddedField } from '../util/orm.helper.js';
-export async function joinAssociationGetFirst(joinInfos, association, parentAlias, innerJoin) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinAssociationGetFirst = joinAssociationGetFirst;
+exports.joinAssociationGetLast = joinAssociationGetLast;
+exports.joinAssociation = joinAssociation;
+exports.prepareFilter = prepareFilter;
+const builder_1 = require("@sqb/builder");
+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");
+async function joinAssociationGetFirst(joinInfos, association, parentAlias, innerJoin) {
     const joins = await joinAssociation(joinInfos, association, parentAlias, innerJoin);
     return joins[0];
 }
-export async function joinAssociationGetLast(joinInfos, association, parentAlias, innerJoin) {
+async function joinAssociationGetLast(joinInfos, association, parentAlias, innerJoin) {
     const joins = await joinAssociation(joinInfos, association, parentAlias, innerJoin);
     return joins[joins.length - 1];
 }
-export async function joinAssociation(joinInfos, association, parentAlias, innerJoin) {
+async function joinAssociation(joinInfos, association, parentAlias, innerJoin) {
     let joinInfo;
     let node = association;
     const result = [];
@@ -23,9 +29,9 @@ export async function joinAssociation(joinInfos, association, parentAlias, inner
             const targetCol = await node.resolveTargetProperty();
             const joinAlias = 'J' + (joinInfos.length + 1);
             const join = innerJoin
-                ? InnerJoin(targetEntity.tableName + ' as ' + joinAlias)
-                : LeftOuterJoin(targetEntity.tableName + ' as ' + joinAlias);
-            join.on(Eq(Field(joinAlias + '.' + targetCol.fieldName, targetCol.dataType, targetCol.isArray), Field(parentAlias + '.' + keyCol.fieldName, keyCol.dataType, keyCol.isArray)));
+                ? (0, builder_1.InnerJoin)(targetEntity.tableName + ' as ' + joinAlias)
+                : (0, builder_1.LeftOuterJoin)(targetEntity.tableName + ' as ' + joinAlias);
+            join.on((0, builder_1.Eq)((0, builder_1.Field)(joinAlias + '.' + targetCol.fieldName, targetCol.dataType, targetCol.isArray), (0, builder_1.Field)(parentAlias + '.' + keyCol.fieldName, keyCol.dataType, keyCol.isArray)));
             if (node.conditions)
                 await prepareFilter(targetEntity, node.conditions, join._conditions, joinAlias);
             joinInfo = {
@@ -45,12 +51,12 @@ export async function joinAssociation(joinInfos, association, parentAlias, inner
     }
     return result;
 }
-export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T') {
+async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T') {
     let srcOp;
-    if (isLogicalOperator(filter) && filter._operatorType === trgOp._operatorType)
+    if ((0, builder_1.isLogicalOperator)(filter) && filter._operatorType === trgOp._operatorType)
         srcOp = filter;
     else {
-        srcOp = And();
+        srcOp = (0, builder_1.And)();
         if (Array.isArray(filter))
             srcOp.add(...filter);
         else
@@ -58,14 +64,14 @@ export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T')
     }
     const associationPathCache = {};
     for (const item of srcOp._items) {
-        if (isLogicalOperator(item)) {
+        if ((0, builder_1.isLogicalOperator)(item)) {
             const ctor = Object.getPrototypeOf(item).constructor;
             const logOp = new ctor();
             await prepareFilter(entityDef, item, logOp, tableAlias);
             trgOp.add(logOp);
             continue;
         }
-        if (isCompOperator(item)) {
+        if ((0, builder_1.isCompOperator)(item)) {
             if (typeof item._left === 'string') {
                 const itemPath = item._left.split('.');
                 const l = itemPath.length;
@@ -91,38 +97,38 @@ export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T')
                 }
                 for (i; i < l; i++) {
                     pt = itemPath[i];
-                    const col = EntityMetadata.getField(_curEntity, pt);
+                    const col = entity_metadata_js_1.EntityMetadata.getField(_curEntity, pt);
                     if (!col)
                         throw new Error(`Unknown property (${item._left}) defined in filter`);
                     /** if last item on path */
                     if (i === l - 1) {
-                        if (!isColumnField(col))
+                        if (!(0, orm_helper_js_1.isColumnField)(col))
                             throw new Error(`Invalid column expression (${item._left}) defined in filter`);
                         const ctor = Object.getPrototypeOf(item).constructor;
-                        currentOp.add(new ctor(Field(_curAlias + '.' + _curPrefix + col.fieldName + _curSuffix, col.dataType, col.isArray), item._right));
+                        currentOp.add(new ctor((0, builder_1.Field)(_curAlias + '.' + _curPrefix + col.fieldName + _curSuffix, col.dataType, col.isArray), item._right));
                     }
                     else {
                         /** if not last item on path */
-                        if (isColumnField(col))
+                        if ((0, orm_helper_js_1.isColumnField)(col))
                             throw new Error(`Invalid column (${item._left}) defined in filter`);
-                        if (isEmbeddedField(col)) {
-                            _curEntity = await EmbeddedFieldMetadata.resolveType(col);
+                        if ((0, orm_helper_js_1.isEmbeddedField)(col)) {
+                            _curEntity = await embedded_field_metadata_js_1.EmbeddedFieldMetadata.resolveType(col);
                             _curPrefix = _curPrefix + (col.fieldNamePrefix || '');
                             _curSuffix = (col.fieldNameSuffix || '') + _curSuffix;
                             continue;
                         }
-                        if (!isAssociationField(col))
+                        if (!(0, orm_helper_js_1.isAssociationField)(col))
                             throw new Error(`Invalid column (${item._left}) defined in filter`);
                         let node;
                         _curEntity = await col.association.resolveTarget();
                         if (!subSelect) {
                             const keyCol = await col.association.resolveSourceProperty();
                             const targetCol = await col.association.resolveTargetProperty();
-                            subSelect = Select(Raw('1')).from(_curEntity.tableName + ' K');
-                            subSelect.where(Eq(Field('K.' + targetCol.fieldName, targetCol.dataType, targetCol.isArray), Field(tableAlias + '.' + keyCol.fieldName, keyCol.dataType, keyCol.isArray)));
-                            currentOp.add(Exists(subSelect));
-                            if (currentOp._operatorType !== OperatorType.and) {
-                                currentOp = op.or();
+                            subSelect = (0, builder_1.Select)((0, builder_1.Raw)('1')).from(_curEntity.tableName + ' K');
+                            subSelect.where((0, builder_1.Eq)((0, builder_1.Field)('K.' + targetCol.fieldName, targetCol.dataType, targetCol.isArray), (0, builder_1.Field)(tableAlias + '.' + keyCol.fieldName, keyCol.dataType, keyCol.isArray)));
+                            currentOp.add((0, builder_1.Exists)(subSelect));
+                            if (currentOp._operatorType !== builder_1.OperatorType.and) {
+                                currentOp = builder_1.op.or();
                                 subSelect.where(currentOp);
                             }
                             else
@@ -140,7 +146,7 @@ export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T')
                             const sourceColumn = await node.resolveSourceProperty();
                             const targetColumn = await node.resolveTargetProperty();
                             const joinAlias = 'J' + ((subSelect?._joins?.length || 0) + 1);
-                            subSelect.join(InnerJoin(targetEntity.tableName + ' ' + joinAlias).on(Eq(Field(joinAlias + '.' + targetColumn.fieldName, targetColumn.dataType, targetColumn.isArray), Field(_curAlias + '.' + sourceColumn.fieldName, sourceColumn.dataType, sourceColumn.isArray))));
+                            subSelect.join((0, builder_1.InnerJoin)(targetEntity.tableName + ' ' + joinAlias).on((0, builder_1.Eq)((0, builder_1.Field)(joinAlias + '.' + targetColumn.fieldName, targetColumn.dataType, targetColumn.isArray), (0, builder_1.Field)(_curAlias + '.' + sourceColumn.fieldName, sourceColumn.dataType, sourceColumn.isArray))));
                             _curEntity = targetEntity;
                             _curAlias = joinAlias;
                             node = node.next;

package/esm/orm/commands/count.command.js

@@ -1,6 +1,9 @@
-import { And, Count, Select } from '@sqb/builder';
-import { prepareFilter } from './command.helper.js';
-export class CountCommand {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountCommand = void 0;
+const builder_1 = require("@sqb/builder");
+const command_helper_js_1 = require("./command.helper.js");
+class CountCommand {
     // istanbul ignore next
     constructor() {
         throw new Error('This class is abstract');
@@ -9,10 +12,10 @@ export class CountCommand {
         const { connection, entity, filter, params } = args;
         let where;
         if (filter) {
-            where = And();
-            await prepareFilter(entity, filter, where, 'T');
+            where = (0, builder_1.And)();
+            await (0, command_helper_js_1.prepareFilter)(entity, filter, where, 'T');
         }
-        const query = Select(Count()).from(entity.tableName + ' T');
+        const query = (0, builder_1.Select)((0, builder_1.Count)()).from(entity.tableName + ' T');
         if (where)
             query.where(where);
         // Execute query
@@ -24,3 +27,4 @@ export class CountCommand {
         return (resp && resp.rows && resp.rows[0][0]) || 0;
     }
 }
+exports.CountCommand = CountCommand;

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

@@ -1,9 +1,12 @@
-import { Insert, Param } from '@sqb/builder';
-import { ColumnFieldMetadata } from '../model/column-field-metadata.js';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
-import { EntityMetadata } from '../model/entity-metadata.js';
-import { isColumnField, isEmbeddedField } from '../util/orm.helper.js';
-export class CreateCommand {
+"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');
@@ -24,9 +27,9 @@ export class CreateCommand {
         await this._prepareParams(ctx, entity, args.values);
         if (!ctx.colCount)
             throw new Error('No field given to create new entity instance');
-        const query = Insert(tableName, ctx.queryValues);
+        const query = (0, builder_1.Insert)(tableName, ctx.queryValues);
         if (args.returning) {
-            const primaryIndexColumns = EntityMetadata.getPrimaryIndexColumns(entity);
+            const primaryIndexColumns = entity_metadata_js_1.EntityMetadata.getPrimaryIndexColumns(entity);
             if (primaryIndexColumns.length)
                 query.returning(...primaryIndexColumns.map(col => col.fieldName));
         }
@@ -38,7 +41,7 @@ export class CreateCommand {
         if (args.returning && qr.fields && qr.rows?.length) {
             const keyValues = {};
             for (const f of qr.fields.values()) {
-                const el = EntityMetadata.getColumnFieldByFieldName(entity, f.fieldName);
+                const el = entity_metadata_js_1.EntityMetadata.getColumnFieldByFieldName(entity, f.fieldName);
                 if (el)
                     keyValues[el.name] = qr.rows[0][f.index];
             }
@@ -51,7 +54,7 @@ export class CreateCommand {
         suffix = suffix || '';
         for (const col of Object.values(entity.fields)) {
             v = values[col.name];
-            if (isColumnField(col)) {
+            if ((0, orm_helper_js_1.isColumnField)(col)) {
                 if (col.noInsert)
                     continue;
                 if (v == null && col.default !== undefined) {
@@ -65,10 +68,10 @@ export class CreateCommand {
                     }
                     continue;
                 }
-                ColumnFieldMetadata.checkEnumValue(col, v);
+                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] = Param({
+                ctx.queryValues[fieldName] = (0, builder_1.Param)({
                     name: k,
                     dataType: col.dataType,
                     isArray: col.isArray,
@@ -76,10 +79,11 @@ export class CreateCommand {
                 ctx.queryParams[k] = v;
                 ctx.colCount++;
             }
-            else if (v != null && isEmbeddedField(col)) {
-                const type = await EmbeddedFieldMetadata.resolveType(col);
+            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/esm/orm/commands/delete.command.js

@@ -1,6 +1,9 @@
-import { And, Delete } from '@sqb/builder';
-import { prepareFilter } from './command.helper.js';
-export class DeleteCommand {
+"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');
@@ -9,10 +12,10 @@ export class DeleteCommand {
         const { connection, entity, filter, params } = args;
         let where;
         if (filter) {
-            where = And();
-            await prepareFilter(entity, filter, where);
+            where = (0, builder_1.And)();
+            await (0, command_helper_js_1.prepareFilter)(entity, filter, where);
         }
-        const query = Delete(entity.tableName + ' T');
+        const query = (0, builder_1.Delete)(entity.tableName + ' T');
         if (where)
             query.where(...where._items);
         // Execute query
@@ -24,3 +27,4 @@ export class DeleteCommand {
         return (resp && resp.rowsAffected) || 0;
     }
 }
+exports.DeleteCommand = DeleteCommand;

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

@@ -1,13 +1,16 @@
-import { And, In, Param, Select } from '@sqb/builder';
-import { AssociationNode } from '../model/association-node.js';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
-import { EntityMetadata } from '../model/entity-metadata.js';
-import { isAssociationField, isColumnField, isEmbeddedField } from '../util/orm.helper.js';
-import { parseFieldsProjection } from '../util/parse-fields-projection.js';
-import { joinAssociationGetLast, prepareFilter } from './command.helper.js';
-import { RowConverter } from './row-converter.js';
+"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 = /^([-+])?(.*)$/;
-export class FindCommand {
+class FindCommand {
     constructor(selectEntity, outputEntity) {
         this.maxEagerFetch = 100000;
         this.maxSubQueries = 5;
@@ -15,15 +18,15 @@ export class FindCommand {
         this.resultAlias = 'T';
         this._joins = [];
         this._selectColumns = {};
-        this._filter = And();
+        this._filter = (0, builder_1.And)();
         this.mainEntity = selectEntity;
         this.resultEntity = outputEntity;
-        this.converter = new RowConverter(outputEntity.ctor);
+        this.converter = new row_converter_js_1.RowConverter(outputEntity.ctor);
     }
     static async create(source, opts = {}) {
         let command;
         let listingEntity;
-        if (source instanceof AssociationNode) {
+        if (source instanceof association_node_js_1.AssociationNode) {
             const node = source;
             listingEntity = await node.resolveTarget();
             const resultEntity = await node.getLast().resolveTarget();
@@ -31,7 +34,7 @@ export class FindCommand {
             if (node.conditions)
                 await command.filter(node.conditions);
             if (node.next) {
-                const join = await joinAssociationGetLast(command._joins, node.next, command.mainAlias);
+                const join = await (0, command_helper_js_1.joinAssociationGetLast)(command._joins, node.next, command.mainAlias);
                 command.resultAlias = join.joinAlias;
             }
         }
@@ -67,14 +70,14 @@ export class FindCommand {
         const entity = opts.entity || this._getEntityFromAlias(tableAlias);
         const converter = opts.converter || this.converter;
         const projection = typeof opts.projection === 'string' || Array.isArray(opts.projection)
-            ? parseFieldsProjection(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 = EntityMetadata.getField(entity, key);
+            const col = entity_metadata_js_1.EntityMetadata.getField(entity, key);
             if (!col || col.hidden)
                 continue;
             const colNameLower = col.name.toLowerCase();
@@ -89,7 +92,7 @@ export class FindCommand {
                 continue;
             }
             // Add field to select list if field is a column
-            if (isColumnField(col)) {
+            if ((0, orm_helper_js_1.isColumnField)(col)) {
                 const fieldAlias = this._selectColumn(tableAlias, col, prefix, suffix);
                 // Add column to converter
                 converter.addValueProperty({
@@ -100,8 +103,8 @@ export class FindCommand {
                 });
                 continue;
             }
-            if (isEmbeddedField(col)) {
-                const typ = await EmbeddedFieldMetadata.resolveType(col);
+            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,
@@ -117,10 +120,10 @@ export class FindCommand {
                 });
                 continue;
             }
-            if (isAssociationField(col)) {
+            if ((0, orm_helper_js_1.isAssociationField)(col)) {
                 // OtO relation
                 if (!col.association.returnsMany()) {
-                    const joinInfo = await joinAssociationGetLast(this._joins, col.association, tableAlias);
+                    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,
@@ -147,7 +150,7 @@ export class FindCommand {
                         maxEagerFetch: this.maxEagerFetch,
                     });
                     findCommand.converter.parent = this.converter;
-                    await findCommand.filter(In(targetCol.name, Param(parentField)));
+                    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,
@@ -179,7 +182,7 @@ export class FindCommand {
         return fieldAlias;
     }
     async filter(filter) {
-        await prepareFilter(this.mainEntity, filter, this._filter);
+        await (0, command_helper_js_1.prepareFilter)(this.mainEntity, filter, this._filter);
     }
     async sort(sortFields) {
         const out = [];
@@ -195,20 +198,20 @@ export class FindCommand {
             if (elName.includes('.')) {
                 const a = elName.split('.');
                 while (a.length > 1) {
-                    const col = EntityMetadata.getField(_entityDef, a.shift() || '');
-                    if (isEmbeddedField(col)) {
-                        _entityDef = await EmbeddedFieldMetadata.resolveType(col);
+                    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 (isAssociationField(col)) {
+                    else if ((0, orm_helper_js_1.isAssociationField)(col)) {
                         if (col.association.returnsMany()) {
                             elName = '';
                             break;
                         }
-                        const joinInfo = await joinAssociationGetLast(this._joins, col.association, tableAlias);
+                        const joinInfo = await (0, command_helper_js_1.joinAssociationGetLast)(this._joins, col.association, tableAlias);
                         tableAlias = joinInfo.joinAlias;
                         _entityDef = joinInfo.targetEntity;
                     }
@@ -219,10 +222,10 @@ export class FindCommand {
                     continue;
                 elName = a.shift() || '';
             }
-            const col = EntityMetadata.getField(_entityDef, elName);
+            const col = entity_metadata_js_1.EntityMetadata.getField(_entityDef, elName);
             if (!col)
                 throw new Error(`Unknown field (${elName}) declared in sort property`);
-            if (!isColumnField(col))
+            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);
@@ -234,7 +237,7 @@ export class FindCommand {
         const columnSqls = Object.keys(this._selectColumns).map(x => this._selectColumns[x].statement);
         if (!columnSqls.length)
             columnSqls.push('1');
-        const query = Select(...columnSqls).from(this.mainEntity.tableName + ' as ' + this.mainAlias);
+        const query = (0, builder_1.Select)(...columnSqls).from(this.mainEntity.tableName + ' as ' + this.mainAlias);
         if (args.distinct)
             query.distinct();
         query.where(...this._filter._items);
@@ -276,6 +279,7 @@ export class FindCommand {
         throw new Error(`Unknown table alias "${tableAlias}"`);
     }
 }
+exports.FindCommand = FindCommand;
 function extractSubFields(colNameLower, fields) {
     if (!(fields && fields.length))
         return;

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

@@ -1,8 +1,11 @@
-import { DataType } from '@sqb/builder';
+"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;
-export class RowConverter {
+class RowConverter {
     constructor(resultType, parent) {
         this.resultType = resultType;
         this.parent = parent;
@@ -81,7 +84,7 @@ export class RowConverter {
                         v = prop.parse(v, elKey);
                     if (v != null) {
                         result = result || {};
-                        if (prop.dataType === DataType.JSON && typeof v === 'string')
+                        if (prop.dataType === builder_1.DataType.JSON && typeof v === 'string')
                             v = JSON.parse(v);
                         result[elKey] = v;
                     }
@@ -179,3 +182,4 @@ export class RowConverter {
             this.parent._checkCircularDep(t);
     }
 }
+exports.RowConverter = RowConverter;

package/esm/orm/commands/update.command.js

@@ -1,9 +1,12 @@
-import { And, Param, Update } from '@sqb/builder';
-import { ColumnFieldMetadata } from '../model/column-field-metadata.js';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
-import { isColumnField, isEmbeddedField } from '../util/orm.helper.js';
-import { prepareFilter } from './command.helper.js';
-export class UpdateCommand {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCommand = 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 orm_helper_js_1 = require("../util/orm.helper.js");
+const command_helper_js_1 = require("./command.helper.js");
+class UpdateCommand {
     // istanbul ignore next
     constructor() {
         throw new Error('This class is abstract');
@@ -27,7 +30,7 @@ export class UpdateCommand {
             return 0;
         if (args.filter)
             await this._prepareFilter(ctx, args.filter);
-        const query = Update(tableName + ' as T', ctx.queryValues).where(...ctx.queryFilter);
+        const query = (0, builder_1.Update)(tableName + ' as T', ctx.queryValues).where(...ctx.queryFilter);
         const qr = await args.connection.execute(query, {
             params: args.params ? [...args.params, ctx.queryParams] : ctx.queryParams,
             objectRows: false,
@@ -37,8 +40,8 @@ export class UpdateCommand {
     }
     static async _prepareFilter(ctx, filter) {
         if (filter) {
-            const where = And();
-            await prepareFilter(ctx.entity, filter, where);
+            const where = (0, builder_1.And)();
+            await (0, command_helper_js_1.prepareFilter)(ctx.entity, filter, where);
             ctx.queryFilter.push(...where._items);
         }
     }
@@ -50,7 +53,7 @@ export class UpdateCommand {
             v = values[col.name];
             if (v === undefined)
                 continue;
-            if (isColumnField(col)) {
+            if ((0, orm_helper_js_1.isColumnField)(col)) {
                 if (col.noUpdate)
                     continue;
                 if (typeof col.serialize === 'function')
@@ -59,10 +62,10 @@ export class UpdateCommand {
                     throw new Error(`${entity.name}.${col.name} is required and can't be null`);
                 if (v === undefined)
                     continue;
-                ColumnFieldMetadata.checkEnumValue(col, v);
+                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] = Param({
+                ctx.queryValues[fieldName] = (0, builder_1.Param)({
                     name: k,
                     dataType: col.dataType,
                     isArray: col.isArray,
@@ -70,10 +73,11 @@ export class UpdateCommand {
                 ctx.queryParams[k] = v;
                 ctx.colCount++;
             }
-            else if (v != null && isEmbeddedField(col)) {
-                const type = await EmbeddedFieldMetadata.resolveType(col);
+            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.UpdateCommand = UpdateCommand;

package/esm/orm/decorators/column.decorator.js

@@ -1,14 +1,17 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-import { DECORATOR_FACTORY } from '../orm.const.js';
-export function Column(arg0) {
-    return Column[DECORATOR_FACTORY](arg0);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Column = Column;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+const orm_const_js_1 = require("../orm.const.js");
+function Column(arg0) {
+    return Column[orm_const_js_1.DECORATOR_FACTORY](arg0);
 }
-Column[DECORATOR_FACTORY] = function (arg0) {
+Column[orm_const_js_1.DECORATOR_FACTORY] = function (arg0) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('Symbol properties are not accepted');
         const options = (typeof arg0 === 'string' ? { dataType: arg0 } : arg0) || {};
-        const entity = EntityMetadata.define(target.constructor);
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         if (!options.type) {
             const typ = Reflect.getMetadata('design:type', entity.ctor.prototype, propertyKey);
             if (typ === Array) {
@@ -18,6 +21,6 @@ Column[DECORATOR_FACTORY] = function (arg0) {
             else
                 options.type = typ;
         }
-        EntityMetadata.defineColumnField(entity, propertyKey, options);
+        entity_metadata_js_1.EntityMetadata.defineColumnField(entity, propertyKey, options);
     };
 };

package/esm/orm/decorators/embedded.decorator.js

@@ -1,12 +1,15 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-export function Embedded(type, options) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Embedded = Embedded;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+function Embedded(type, options) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('Symbol properties are not accepted');
         type = type || Reflect.getMetadata('design:type', target, propertyKey);
         if (typeof type !== 'function')
             throw new Error('"type" must be defined');
-        const entity = EntityMetadata.define(target.constructor);
-        EntityMetadata.defineEmbeddedField(entity, propertyKey, type, options);
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.defineEmbeddedField(entity, propertyKey, type, options);
     };
 }