@sqb/connect 4.14.0 → 4.15.0

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

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

@@ -1,10 +1,13 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-import { applyMixins } from '../util/apply-mixins.js';
-export function Entity(options) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = Entity;
+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 = EntityMetadata.define(target);
+        const entity = entity_metadata_js_1.EntityMetadata.define(target);
         entity.tableName = tableName || target.name;
         if (opts.schema)
             entity.schema = opts.schema;
@@ -13,92 +16,92 @@ export function Entity(options) {
     };
 }
 (function (Entity) {
-    Entity.getMetadata = EntityMetadata.get;
-    Entity.getOwnMetadata = EntityMetadata.getOwn;
+    Entity.getMetadata = entity_metadata_js_1.EntityMetadata.get;
+    Entity.getOwnMetadata = entity_metadata_js_1.EntityMetadata.getOwn;
     function getField(ctor, key) {
-        const model = EntityMetadata.get(ctor);
-        return model && EntityMetadata.getField(model, 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 = EntityMetadata.get(ctor);
-        return model && EntityMetadata.getColumnField(model, 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 = EntityMetadata.get(ctor);
-        return model && EntityMetadata.getEmbeddedField(model, 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 = EntityMetadata.get(ctor);
-        return model && EntityMetadata.getAssociationField(model, 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 = EntityMetadata.get(ctor);
-        return model && EntityMetadata.getColumnFieldByFieldName(model, 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 = EntityMetadata.get(ctor);
-        return model && EntityMetadata.findField(model, 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 = EntityMetadata.get(ctor);
-        return (model && EntityMetadata.getFieldNames(model, 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 = EntityMetadata.get(ctor);
-        return (model && EntityMetadata.getColumnFieldNames(model)) || [];
+        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 = EntityMetadata.get(ctor);
-        return (model && EntityMetadata.getEmbeddedFieldNames(model)) || [];
+        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 = EntityMetadata.get(ctor);
-        return (model && EntityMetadata.getAssociationFieldNames(model)) || [];
+        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 = EntityMetadata.get(ctor);
-        return (model && EntityMetadata.getNonAssociationFieldNames(model)) || [];
+        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 = EntityMetadata.get(ctor);
-        return (model && EntityMetadata.getInsertColumnNames(model)) || [];
+        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 = EntityMetadata.get(ctor);
-        return (model && EntityMetadata.getUpdateColumnNames(model)) || [];
+        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 = EntityMetadata.define(ctor);
-        return EntityMetadata.getPrimaryIndex(model);
+        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 = EntityMetadata.define(ctor);
-        return EntityMetadata.getPrimaryIndexColumns(model);
+        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;
-            applyMixins(derivedCtor, base);
-            const srcMeta = EntityMetadata.get(base);
+            (0, apply_mixins_js_1.applyMixins)(derivedCtor, base);
+            const srcMeta = entity_metadata_js_1.EntityMetadata.get(base);
             if (srcMeta) {
-                const trgMeta = EntityMetadata.define(derivedCtor);
-                EntityMetadata.mixin(trgMeta, srcMeta);
+                const trgMeta = entity_metadata_js_1.EntityMetadata.define(derivedCtor);
+                entity_metadata_js_1.EntityMetadata.mixin(trgMeta, srcMeta);
             }
         }
         return derivedCtor;
@@ -112,11 +115,11 @@ export function Entity(options) {
         };
         const pickKeys = keys.map(x => x.toLowerCase());
         const filter = k => pickKeys.includes(k.toLowerCase());
-        applyMixins(PickEntityClass, classRef, filter);
-        const srcMeta = EntityMetadata.get(classRef);
+        (0, apply_mixins_js_1.applyMixins)(PickEntityClass, classRef, filter);
+        const srcMeta = entity_metadata_js_1.EntityMetadata.get(classRef);
         if (srcMeta) {
-            const trgMeta = EntityMetadata.define(PickEntityClass);
-            EntityMetadata.mixin(trgMeta, srcMeta, filter);
+            const trgMeta = entity_metadata_js_1.EntityMetadata.define(PickEntityClass);
+            entity_metadata_js_1.EntityMetadata.mixin(trgMeta, srcMeta, filter);
         }
         return PickEntityClass;
     }
@@ -129,11 +132,11 @@ export function Entity(options) {
         };
         const omitKeys = keys.map(x => x.toLowerCase());
         const filter = k => !omitKeys.includes(k.toLowerCase());
-        applyMixins(OmitEntityClass, classRef, filter);
-        const srcMeta = EntityMetadata.get(classRef);
+        (0, apply_mixins_js_1.applyMixins)(OmitEntityClass, classRef, filter);
+        const srcMeta = entity_metadata_js_1.EntityMetadata.get(classRef);
         if (srcMeta) {
-            const trgMeta = EntityMetadata.define(OmitEntityClass);
-            EntityMetadata.mixin(trgMeta, srcMeta, filter);
+            const trgMeta = entity_metadata_js_1.EntityMetadata.define(OmitEntityClass);
+            entity_metadata_js_1.EntityMetadata.mixin(trgMeta, srcMeta, filter);
         }
         return OmitEntityClass;
     }
@@ -146,17 +149,17 @@ export function Entity(options) {
             }
         };
         for (const base of bases) {
-            applyMixins(UnionClass, base);
-            const srcMeta = EntityMetadata.get(base);
+            (0, apply_mixins_js_1.applyMixins)(UnionClass, base);
+            const srcMeta = entity_metadata_js_1.EntityMetadata.get(base);
             if (srcMeta) {
-                const trgMeta = EntityMetadata.define(UnionClass);
-                EntityMetadata.mixin(trgMeta, srcMeta);
+                const trgMeta = entity_metadata_js_1.EntityMetadata.define(UnionClass);
+                entity_metadata_js_1.EntityMetadata.mixin(trgMeta, srcMeta);
             }
         }
         return UnionClass;
     }
     Entity.Union = Union;
-})(Entity || (Entity = {}));
+})(Entity || (exports.Entity = Entity = {}));
 function applyConstructorProperties(target, sourceClass, constructorArgs, isPropertyInherited) {
     try {
         const tempInstance = new sourceClass(...constructorArgs);

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

@@ -1,55 +1,63 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-export function BeforeInsert() {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeforeInsert = BeforeInsert;
+exports.BeforeUpdate = BeforeUpdate;
+exports.BeforeDestroy = BeforeDestroy;
+exports.AfterInsert = AfterInsert;
+exports.AfterUpdate = AfterUpdate;
+exports.AfterDestroy = AfterDestroy;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+function BeforeInsert() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        EntityMetadata.addEventListener(model, 'before-insert', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'before-insert', fn);
     };
 }
-export function BeforeUpdate() {
+function BeforeUpdate() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        EntityMetadata.addEventListener(model, 'before-update', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'before-update', fn);
     };
 }
-export function BeforeDestroy() {
+function BeforeDestroy() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        EntityMetadata.addEventListener(model, 'before-destroy', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'before-destroy', fn);
     };
 }
-export function AfterInsert() {
+function AfterInsert() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        EntityMetadata.addEventListener(model, 'after-insert', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'after-insert', fn);
     };
 }
-export function AfterUpdate() {
+function AfterUpdate() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        EntityMetadata.addEventListener(model, 'after-update', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'after-update', fn);
     };
 }
-export function AfterDestroy() {
+function AfterDestroy() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        EntityMetadata.addEventListener(model, 'after-destroy', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'after-destroy', fn);
     };
 }

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

@@ -1,9 +1,12 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-export function ForeignKey(type, targetKey) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForeignKey = ForeignKey;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+function ForeignKey(type, targetKey) {
     return function (target, propertyKey) {
         if (typeof propertyKey !== 'string')
             throw new Error('Symbol properties are not accepted');
-        const entity = EntityMetadata.define(target.constructor);
-        EntityMetadata.addForeignKey(entity, propertyKey, type, targetKey);
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.addForeignKey(entity, propertyKey, type, targetKey);
     };
 }

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

@@ -1,17 +1,20 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-export function Index(arg0, arg1) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Index = Index;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+function Index(arg0, arg1) {
     return function (target, propertyKey) {
         if (typeof target === 'function') {
             if (!(typeof arg0 === 'string' || Array.isArray(arg0)))
                 throw new Error(`You must specify index column(s)`);
-            const model = EntityMetadata.define(target);
-            return EntityMetadata.addIndex(model, { ...arg1, columns: arg0 });
+            const model = entity_metadata_js_1.EntityMetadata.define(target);
+            return entity_metadata_js_1.EntityMetadata.addIndex(model, { ...arg1, columns: arg0 });
         }
         if (!target.constructor)
             throw new Error('Property decorators can be used for class properties only');
         if (typeof propertyKey !== 'string')
             throw new Error('Index() decorator can be used for string property keys only');
-        const model = EntityMetadata.define(target.constructor);
-        EntityMetadata.addIndex(model, { ...arg0, columns: [propertyKey] });
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.addIndex(model, { ...arg0, columns: [propertyKey] });
     };
 }

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

@@ -1,6 +1,9 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-import { LinkChain } from '../model/link-chain.js';
-export function Link(options) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Link = Link;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+const link_chain_js_1 = require("../model/link-chain.js");
+function Link(options) {
     let root;
     let chain;
     const fn = (target, propertyKey) => {
@@ -11,7 +14,7 @@ export function Link(options) {
             if (reflectType === Array) {
                 throw new TypeError(`Can't get type information while it is an array. Please define entity type`);
             }
-            if (!EntityMetadata.get(reflectType))
+            if (!entity_metadata_js_1.EntityMetadata.get(reflectType))
                 throw new TypeError(`No entity metadata found for type "${reflectType}"`);
             fn.toOne(reflectType);
         }
@@ -21,11 +24,11 @@ export function Link(options) {
         if (reflectType === Array && !root.first.returnsMany()) {
             throw new TypeError(`Link returns array of instances however property type is not an array`);
         }
-        const entity = EntityMetadata.define(target.constructor);
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         // @ts-ignore
         // noinspection JSConstantReassignment
         root.first.source = entity.ctor;
-        EntityMetadata.defineAssociationField(entity, propertyKey, root.first, options);
+        entity_metadata_js_1.EntityMetadata.defineAssociationField(entity, propertyKey, root.first, options);
     };
     fn.toOne = (type, args) => {
         if (chain) {
@@ -59,11 +62,11 @@ export function Link(options) {
  * Crates an Link Chain object
  */
 function linkToOne(type, targetKey, sourceKey) {
-    return new LinkChain(type, targetKey, sourceKey);
+    return new link_chain_js_1.LinkChain(type, targetKey, sourceKey);
 }
 /**
  * Crates an Link Chain object
  */
 function linkToMany(type, targetKey, sourceKey) {
-    return new LinkChain(type, targetKey, sourceKey, true);
+    return new link_chain_js_1.LinkChain(type, targetKey, sourceKey, true);
 }

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

@@ -1,21 +1,24 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-import { Column } from './column.decorator.js';
-export function PrimaryKey(arg0, arg1) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimaryKey = PrimaryKey;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+const column_decorator_js_1 = require("./column.decorator.js");
+function PrimaryKey(arg0, arg1) {
     return function (target, propertyKey) {
         if (arguments.length === 1) {
             if (!(typeof arg0 === 'string' || Array.isArray(arg0))) {
                 throw new Error(`You must specify primary index column(s)`);
             }
-            const meta = EntityMetadata.define(target);
-            EntityMetadata.setPrimaryKeys(meta, arg0, arg1);
+            const meta = entity_metadata_js_1.EntityMetadata.define(target);
+            entity_metadata_js_1.EntityMetadata.setPrimaryKeys(meta, arg0, arg1);
             return;
         }
         if (!target.constructor)
             throw new Error('Property decorators can be used for class properties only');
         if (typeof propertyKey !== 'string')
             throw new Error('Index() decorator can be used for string property keys only');
-        const meta = EntityMetadata.define(target.constructor);
-        Column({ notNull: true })(target, propertyKey);
-        EntityMetadata.setPrimaryKeys(meta, propertyKey, arg0);
+        const meta = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        (0, column_decorator_js_1.Column)({ notNull: true })(target, propertyKey);
+        entity_metadata_js_1.EntityMetadata.setPrimaryKeys(meta, propertyKey, arg0);
     };
 }

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

@@ -1,17 +1,21 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-export function Parse(fn) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parse = Parse;
+exports.Serialize = Serialize;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+function Parse(fn) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = EntityMetadata.define(target.constructor);
-        EntityMetadata.defineColumnField(entity, propertyKey).parse = fn;
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.defineColumnField(entity, propertyKey).parse = fn;
     };
 }
-export function Serialize(fn) {
+function Serialize(fn) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = EntityMetadata.define(target.constructor);
-        EntityMetadata.defineColumnField(entity, propertyKey).serialize = fn;
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.defineColumnField(entity, propertyKey).serialize = fn;
     };
 }

package/esm/orm/model/association-field-metadata.js

@@ -1,5 +1,9 @@
-import _ from 'lodash';
-export var AssociationFieldMetadata;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssociationFieldMetadata = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+var AssociationFieldMetadata;
 (function (AssociationFieldMetadata) {
     function create(entity, name, association, options = {}) {
         const result = {
@@ -14,7 +18,7 @@ export var AssociationFieldMetadata;
     }
     AssociationFieldMetadata.create = create;
     function assign(target, options) {
-        Object.assign(target, _.omit(options, ['entity', 'name', 'kind', 'association']));
+        Object.assign(target, lodash_1.default.omit(options, ['entity', 'name', 'kind', 'association']));
     }
     AssociationFieldMetadata.assign = assign;
-})(AssociationFieldMetadata || (AssociationFieldMetadata = {}));
+})(AssociationFieldMetadata || (exports.AssociationFieldMetadata = AssociationFieldMetadata = {}));

package/esm/orm/model/association-node.js

@@ -1,5 +1,8 @@
-import { Association } from './association.js';
-export class AssociationNode extends Association {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssociationNode = void 0;
+const association_js_1 = require("./association.js");
+class AssociationNode extends association_js_1.Association {
     getFirst() {
         let l = this;
         while (l.prior)
@@ -19,3 +22,4 @@ export class AssociationNode extends Association {
         return !!(this.next && this.next.returnsMany());
     }
 }
+exports.AssociationNode = AssociationNode;