@sqb/connect 4.2.1 → 4.5.0

package/{dist → cjs}/orm/commands/find.command.js

@@ -2,31 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FindCommand = void 0;
 const builder_1 = require("@sqb/builder");
-const entity_decorator_1 = require("../decorators/entity.decorator");
-const association_node_1 = require("../model/association-node");
-const embedded_element_metadata_1 = require("../model/embedded-element-metadata");
-const entity_metadata_1 = require("../model/entity-metadata");
-const orm_helper_1 = require("../util/orm.helper");
-const command_helper_1 = require("./command.helper");
-const row_converter_1 = require("./row-converter");
+const entity_decorator_js_1 = require("../decorators/entity.decorator.js");
+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 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.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);
+        this.converter = new row_converter_js_1.RowConverter(outputEntity.ctor);
     }
     static async create(source, opts = {}) {
         let command;
         let listingEntity;
-        if (source instanceof association_node_1.AssociationNode) {
+        if (source instanceof association_node_js_1.AssociationNode) {
             const node = source;
             listingEntity = await node.resolveTarget();
             const resultEntity = await node.getLast().resolveTarget();
@@ -34,7 +38,7 @@ class FindCommand {
             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);
+                const join = await (0, command_helper_js_1.joinAssociationGetLast)(command._joins, node.next, command.mainAlias);
                 command.resultAlias = join.joinAlias;
             }
         }
@@ -55,10 +59,10 @@ class FindCommand {
             maxSubQueries: args.maxSubQueries,
             maxEagerFetch: args.maxEagerFetch,
         });
-        await command.addElements({
-            elements: args.elements,
+        await command.addFields({
+            pick: args.pick,
             include: args.include,
-            exclude: args.exclude,
+            omit: args.omit,
             sort: args.sort
         });
         if (args.filter)
@@ -67,87 +71,94 @@ class FindCommand {
             await command.sort(args.sort);
         return await command.execute(args);
     }
-    async addElements(opts = {}) {
+    async addFields(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 _pick = opts.pick ?
+            opts.pick.map(x => x.toLowerCase()) : undefined;
+        const _omit = opts.omit ?
+            opts.omit.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] :
-            entity_decorator_1.Entity.getNonAssociationElementNames(entity.ctor)
-                .map(x => x.toLowerCase());
+        let requestedFields;
+        if (_pick)
+            requestedFields = [..._pick];
+        else {
+            requestedFields = entity_decorator_js_1.Entity.getFieldNames(entity.ctor).reduce((a, x) => {
+                const f = entity_decorator_js_1.Entity.getField(entity.ctor, x);
+                if (f && !f.exclusive)
+                    a.push(x.toLowerCase());
+                return a;
+            }, []);
+        }
         if (_include)
-            requestElements.push(..._include);
-        const sortElements = opts.sort && opts.sort.length ?
+            requestedFields.push(..._include);
+        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.elements)) {
-            const col = entity_metadata_1.EntityMetadata.getElement(entity, key);
-            if (!col)
+        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();
-            // Ignore element if in excluded list
-            if (_exclude && _exclude.includes(colNameLower))
+            // Ignore field if in excluded list
+            if (_omit && _omit.includes(colNameLower))
                 continue;
-            // Check if element request list
-            if (!requestElements.find((x) => x === colNameLower || x.startsWith(colNameLower + '.')))
+            // Check if field request list
+            if (!requestedFields.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)) {
+            // 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
-                if (!col.hidden)
-                    converter.addValueProperty({
-                        name: col.name,
-                        fieldAlias,
-                        dataType: col.dataType,
-                        parse: col.parse
-                    });
+                converter.addValueProperty({
+                    name: col.name,
+                    fieldAlias,
+                    dataType: col.dataType,
+                    parse: col.parse
+                });
                 continue;
             }
-            if ((0, orm_helper_1.isEmbeddedElement)(col)) {
-                const typ = await embedded_element_metadata_1.EmbeddedElementMetadata.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
                 }).converter;
-                await this.addElements({
+                await this.addFields({
                     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),
+                    pick: _pick?.includes(colNameLower) ? undefined :
+                        extractSubFields(colNameLower, _pick),
+                    include: extractSubFields(colNameLower, _include),
+                    omit: extractSubFields(colNameLower, _omit),
+                    sort: extractSubFields(colNameLower, sortFields),
                 });
                 continue;
             }
-            if ((0, orm_helper_1.isAssociationElement)(col)) {
+            if ((0, orm_helper_js_1.isAssociationField)(col)) {
                 // OtO relation
                 if (!col.association.returnsMany()) {
-                    const joinInfo = await (0, command_helper_1.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
                     }).converter;
                     // Add join fields to select columns list
-                    await this.addElements({
+                    await this.addFields({
                         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),
+                        pick: _pick?.includes(colNameLower) ? undefined :
+                            extractSubFields(colNameLower, _pick),
+                        include: extractSubFields(colNameLower, _include),
+                        omit: extractSubFields(colNameLower, _omit),
+                        sort: extractSubFields(colNameLower, sortFields),
                     });
                     continue;
                 }
@@ -162,13 +173,14 @@ class FindCommand {
                         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 = sortElements && extractSubElements(colNameLower, sortElements);
-                    await findCommand.addElements({
-                        elements: _elements?.includes(colNameLower) ? undefined :
-                            extractSubElements(colNameLower, _elements),
-                        include: extractSubElements(colNameLower, _include),
-                        exclude: extractSubElements(colNameLower, _exclude),
+                    const sort = sortFields && extractSubFields(colNameLower, sortFields);
+                    await findCommand.addFields({
+                        pick: _pick?.includes(colNameLower) ? undefined :
+                            extractSubFields(colNameLower, _pick),
+                        include: extractSubFields(colNameLower, _include),
+                        omit: extractSubFields(colNameLower, _omit),
                         sort,
                     });
                     if (sort)
@@ -181,7 +193,7 @@ class FindCommand {
                         findCommand,
                         parentField,
                         keyField,
-                        sort: extractSubElements(colNameLower, sortElements)
+                        sort: extractSubFields(colNameLower, sortFields)
                     });
                 }
             }
@@ -193,17 +205,17 @@ class FindCommand {
             (suffix || '').toLowerCase();
         const fieldAlias = tableAlias + '_' + fieldName;
         this._selectColumns[fieldAlias] = {
-            element: el,
+            field: el,
             statement: tableAlias + '.' + fieldName + ' as ' + fieldAlias
         };
         return fieldAlias;
     }
     async filter(filter) {
-        await (0, command_helper_1.prepareFilter)(this.mainEntity, filter, this._filter);
+        await (0, command_helper_js_1.prepareFilter)(this.mainEntity, filter, this._filter);
     }
-    async sort(sortElements) {
-        const orderColumns = [];
-        for (const item of sortElements) {
+    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`);
@@ -215,20 +227,20 @@ class FindCommand {
             if (elName.includes('.')) {
                 const a = elName.split('.');
                 while (a.length > 1) {
-                    const col = entity_metadata_1.EntityMetadata.getElement(_entityDef, a.shift() || '');
-                    if ((0, orm_helper_1.isEmbeddedElement)(col)) {
-                        _entityDef = await embedded_element_metadata_1.EmbeddedElementMetadata.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 ((0, orm_helper_1.isAssociationElement)(col)) {
+                    else if ((0, orm_helper_js_1.isAssociationField)(col)) {
                         if (col.association.returnsMany()) {
                             elName = '';
                             break;
                         }
-                        const joinInfo = await (0, command_helper_1.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;
                     }
@@ -239,15 +251,15 @@ class FindCommand {
                     continue;
                 elName = a.shift() || '';
             }
-            const col = entity_metadata_1.EntityMetadata.getElement(_entityDef, elName);
+            const col = entity_metadata_js_1.EntityMetadata.getField(_entityDef, elName);
             if (!col)
-                throw new Error(`Unknown element (${elName}) declared in sort property`);
-            if (!(0, orm_helper_1.isColumnElement)(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] || '+';
-            orderColumns.push((dir || '') + tableAlias + '.' + prefix + col.fieldName + suffix);
+            out.push((dir || '') + tableAlias + '.' + prefix + col.fieldName + suffix);
         }
-        this._sort = orderColumns;
+        this._sort = out;
     }
     async execute(args) {
         // Generate select query
@@ -297,11 +309,11 @@ class FindCommand {
     }
 }
 exports.FindCommand = FindCommand;
-function extractSubElements(colNameLower, elements) {
-    if (!(elements && elements.length))
+function extractSubFields(colNameLower, fields) {
+    if (!(fields && fields.length))
         return;
-    if (elements) {
-        return elements.reduce((trg, v) => {
+    if (fields) {
+        return fields.reduce((trg, v) => {
             if (v.startsWith(colNameLower + '.'))
                 trg.push(v.substring(colNameLower.length + 1).toLowerCase());
             return trg;

package/{dist → cjs}/orm/commands/row-converter.js

@@ -12,10 +12,13 @@ const isNestedProperty = (prop) => {
     return prop.converter && prop.findCommand;
 };
 class RowConverter {
+    resultType;
+    parent;
+    _properties = {};
+    _propertyKeys;
     constructor(resultType, parent) {
         this.resultType = resultType;
         this.parent = parent;
-        this._properties = {};
     }
     addValueProperty(args) {
         this._propertyKeys = undefined;
@@ -76,11 +79,11 @@ class RowConverter {
     }
     _rowToObject(executor, fields, row) {
         // Cache keys for better performance
-        const elementKeys = this.keys;
-        const elementLen = elementKeys.length;
+        const fieldKeys = this.keys;
+        const fieldsLen = fieldKeys.length;
         let result;
-        for (let elIdx = 0; elIdx < elementLen; elIdx++) {
-            const elKey = elementKeys[elIdx];
+        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);
@@ -97,7 +100,7 @@ class RowConverter {
                 }
             }
             else if (isNestedProperty(prop)) {
-                // One2Many Eager element
+                // 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);
@@ -179,7 +182,7 @@ class RowConverter {
     }
     _checkCircularDep(t) {
         if (this.resultType === t)
-            throw new Error('Circular elements requested');
+            throw new Error('Circular fields requested');
         if (this.parent)
             this.parent._checkCircularDep(t);
     }

package/{dist → cjs}/orm/commands/update.command.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateCommand = void 0;
 const builder_1 = require("@sqb/builder");
-const column_element_metadata_1 = require("../model/column-element-metadata");
-const embedded_element_metadata_1 = require("../model/embedded-element-metadata");
-const orm_helper_1 = require("../util/orm.helper");
-const command_helper_1 = require("./command.helper");
+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() {
@@ -42,7 +42,7 @@ class UpdateCommand {
     static async _prepareFilter(ctx, filter) {
         if (filter) {
             const where = (0, builder_1.And)();
-            await (0, command_helper_1.prepareFilter)(ctx.entity, filter, where);
+            await (0, command_helper_js_1.prepareFilter)(ctx.entity, filter, where);
             ctx.queryFilter.push(...where._items);
         }
     }
@@ -50,11 +50,11 @@ class UpdateCommand {
         let v;
         prefix = prefix || '';
         suffix = suffix || '';
-        for (const col of Object.values(entity.elements)) {
+        for (const col of Object.values(entity.fields)) {
             v = values[col.name];
             if (v === undefined)
                 continue;
-            if ((0, orm_helper_1.isColumnElement)(col)) {
+            if ((0, orm_helper_js_1.isColumnField)(col)) {
                 if (col.noUpdate)
                     continue;
                 if (typeof col.serialize === 'function')
@@ -63,7 +63,7 @@ class UpdateCommand {
                     throw new Error(`${entity.name}.${col.name} is required and can't be null`);
                 if (v === undefined)
                     continue;
-                column_element_metadata_1.ColumnElementMetadata.checkEnumValue(col, v);
+                column_field_metadata_js_1.ColumnFieldMetadata.checkEnumValue(col, v);
                 const fieldName = prefix + col.fieldName + suffix;
                 const k = '$input_' + fieldName;
                 ctx.queryValues[fieldName] = (0, builder_1.Param)({
@@ -74,8 +74,8 @@ class UpdateCommand {
                 ctx.queryParams[k] = v;
                 ctx.colCount++;
             }
-            else if (v != null && (0, orm_helper_1.isEmbeddedElement)(col)) {
-                const type = await embedded_element_metadata_1.EmbeddedElementMetadata.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);
             }
         }

package/{dist → cjs}/orm/decorators/column.decorator.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Column = void 0;
-const entity_metadata_1 = require("../model/entity-metadata");
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function Column(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 = entity_metadata_1.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) {
@@ -17,7 +17,7 @@ function Column(arg0) {
             else
                 options.type = typ;
         }
-        entity_metadata_1.EntityMetadata.defineColumnElement(entity, propertyKey, options);
+        entity_metadata_js_1.EntityMetadata.defineColumnField(entity, propertyKey, options);
     };
 }
 exports.Column = Column;

package/{dist → cjs}/orm/decorators/embedded.decorator.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Embedded = void 0;
-const entity_metadata_1 = require("../model/entity-metadata");
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function Embedded(type, options) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
@@ -9,8 +9,8 @@ function Embedded(type, options) {
         type = type || Reflect.getMetadata("design:type", target, propertyKey);
         if (typeof type !== 'function')
             throw new Error('"type" must be defined');
-        const entity = entity_metadata_1.EntityMetadata.define(target.constructor);
-        entity_metadata_1.EntityMetadata.defineEmbeddedElement(entity, propertyKey, type, options);
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.defineEmbeddedField(entity, propertyKey, type, options);
     };
 }
 exports.Embedded = Embedded;

package/cjs/orm/decorators/entity.decorator.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+const apply_mixins_js_1 = require("../util/apply-mixins.js");
+function Entity(options) {
+    return function (target) {
+        const opts = typeof options === 'object' ? options : {};
+        const tableName = typeof options === 'string' ? options : opts.tableName;
+        const entity = entity_metadata_js_1.EntityMetadata.define(target);
+        entity.tableName = tableName || target.name;
+        if (opts.schema)
+            entity.schema = opts.schema;
+        if (opts.comment)
+            entity.comment = opts.comment;
+    };
+}
+exports.Entity = Entity;
+(function (Entity) {
+    Entity.getMetadata = entity_metadata_js_1.EntityMetadata.get;
+    Entity.getOwnMetadata = entity_metadata_js_1.EntityMetadata.getOwn;
+    function getField(ctor, key) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_js_1.EntityMetadata.getField(model, key);
+    }
+    Entity.getField = getField;
+    function getColumnField(ctor, key) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_js_1.EntityMetadata.getColumnField(model, key);
+    }
+    Entity.getColumnField = getColumnField;
+    function getEmbeddedField(ctor, key) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_js_1.EntityMetadata.getEmbeddedField(model, key);
+    }
+    Entity.getEmbeddedField = getEmbeddedField;
+    function getAssociationField(ctor, key) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_js_1.EntityMetadata.getAssociationField(model, key);
+    }
+    Entity.getAssociationField = getAssociationField;
+    function getColumnFieldByFieldName(ctor, fieldName) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_js_1.EntityMetadata.getColumnFieldByFieldName(model, fieldName);
+    }
+    Entity.getColumnFieldByFieldName = getColumnFieldByFieldName;
+    function find(ctor, predicate) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_js_1.EntityMetadata.findField(model, predicate);
+    }
+    Entity.find = find;
+    function getFieldNames(ctor, filter) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_js_1.EntityMetadata.getFieldNames(model, filter)) || [];
+    }
+    Entity.getFieldNames = getFieldNames;
+    function getColumnFieldNames(ctor) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_js_1.EntityMetadata.getColumnFieldNames(model)) || [];
+    }
+    Entity.getColumnFieldNames = getColumnFieldNames;
+    function getEmbeddedFieldNames(ctor) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_js_1.EntityMetadata.getEmbeddedFieldNames(model)) || [];
+    }
+    Entity.getEmbeddedFieldNames = getEmbeddedFieldNames;
+    function getAssociationFieldNames(ctor) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_js_1.EntityMetadata.getAssociationFieldNames(model)) || [];
+    }
+    Entity.getAssociationFieldNames = getAssociationFieldNames;
+    function getNonAssociationFieldNames(ctor) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_js_1.EntityMetadata.getNonAssociationFieldNames(model)) || [];
+    }
+    Entity.getNonAssociationFieldNames = getNonAssociationFieldNames;
+    function getInsertColumnNames(ctor) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_js_1.EntityMetadata.getInsertColumnNames(model)) || [];
+    }
+    Entity.getInsertColumnNames = getInsertColumnNames;
+    function getUpdateColumnNames(ctor) {
+        const model = entity_metadata_js_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_js_1.EntityMetadata.getUpdateColumnNames(model)) || [];
+    }
+    Entity.getUpdateColumnNames = getUpdateColumnNames;
+    function getPrimaryIndex(ctor) {
+        const model = entity_metadata_js_1.EntityMetadata.define(ctor);
+        return entity_metadata_js_1.EntityMetadata.getPrimaryIndex(model);
+    }
+    Entity.getPrimaryIndex = getPrimaryIndex;
+    function getPrimaryIndexColumns(ctor) {
+        const model = entity_metadata_js_1.EntityMetadata.define(ctor);
+        return entity_metadata_js_1.EntityMetadata.getPrimaryIndexColumns(model);
+    }
+    Entity.getPrimaryIndexColumns = getPrimaryIndexColumns;
+    function mixin(derivedCtor, ...bases) {
+        for (const base of bases) {
+            if (!base)
+                continue;
+            (0, apply_mixins_js_1.applyMixins)(derivedCtor, base);
+            const srcMeta = entity_metadata_js_1.EntityMetadata.get(base);
+            if (srcMeta) {
+                const trgMeta = entity_metadata_js_1.EntityMetadata.define(derivedCtor);
+                entity_metadata_js_1.EntityMetadata.mixin(trgMeta, srcMeta);
+            }
+        }
+        return derivedCtor;
+    }
+    Entity.mixin = mixin;
+    function Pick(classRef, keys) {
+        const PickEntityClass = class {
+            constructor(...args) {
+                applyConstructorProperties(this, classRef, args);
+            }
+        };
+        const pickKeys = keys.map(x => x.toLowerCase());
+        const filter = (k) => pickKeys.includes(k.toLowerCase());
+        (0, apply_mixins_js_1.applyMixins)(PickEntityClass, classRef, filter);
+        const srcMeta = entity_metadata_js_1.EntityMetadata.get(classRef);
+        if (srcMeta) {
+            const trgMeta = entity_metadata_js_1.EntityMetadata.define(PickEntityClass);
+            entity_metadata_js_1.EntityMetadata.mixin(trgMeta, srcMeta, filter);
+        }
+        return PickEntityClass;
+    }
+    Entity.Pick = Pick;
+    function Omit(classRef, keys) {
+        const OmitEntityClass = class {
+            constructor(...args) {
+                applyConstructorProperties(this, classRef, args);
+            }
+        };
+        const omitKeys = keys.map(x => x.toLowerCase());
+        const filter = (k) => !omitKeys.includes(k.toLowerCase());
+        (0, apply_mixins_js_1.applyMixins)(OmitEntityClass, classRef, filter);
+        const srcMeta = entity_metadata_js_1.EntityMetadata.get(classRef);
+        if (srcMeta) {
+            const trgMeta = entity_metadata_js_1.EntityMetadata.define(OmitEntityClass);
+            entity_metadata_js_1.EntityMetadata.mixin(trgMeta, srcMeta, filter);
+        }
+        return OmitEntityClass;
+    }
+    Entity.Omit = Omit;
+    function Union(...bases) {
+        const UnionClass = class {
+            constructor(...args) {
+                for (const c of bases)
+                    applyConstructorProperties(this, c, args);
+            }
+        };
+        for (const base of bases) {
+            (0, apply_mixins_js_1.applyMixins)(UnionClass, base);
+            const srcMeta = entity_metadata_js_1.EntityMetadata.get(base);
+            if (srcMeta) {
+                const trgMeta = entity_metadata_js_1.EntityMetadata.define(UnionClass);
+                entity_metadata_js_1.EntityMetadata.mixin(trgMeta, srcMeta);
+            }
+        }
+        return UnionClass;
+    }
+    Entity.Union = Union;
+})(Entity = exports.Entity || (exports.Entity = {}));
+function applyConstructorProperties(target, sourceClass, constructorArgs, isPropertyInherited) {
+    try {
+        const tempInstance = new sourceClass(...constructorArgs);
+        const keys = Object.getOwnPropertyNames(tempInstance);
+        for (const key of keys) {
+            const srcDesc = Object.getOwnPropertyDescriptor(tempInstance, key);
+            const trgDesc = Object.getOwnPropertyDescriptor(target, key);
+            if (!srcDesc || trgDesc || (isPropertyInherited && !isPropertyInherited(key)))
+                continue;
+            Object.defineProperty(target, key, srcDesc);
+        }
+    }
+    catch {
+        //
+    }
+}