@sqb/connect 4.0.15 → 4.1.2

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

@@ -1,13 +1,13 @@
-import { EntityModel } from '../model/entity-model';
-import { Repository } from '../repository.class';
 import { SqbConnection } from '../../client/SqbConnection';
+import { EntityMetadata } from '../model/entity-metadata';
+import { Repository } from '../repository.class';
 export declare type UpdateCommandArgs = {
-    entity: EntityModel;
+    entity: EntityMetadata;
     connection: SqbConnection;
     values: any;
 } & Repository.UpdateAllOptions;
 declare type UpdateCommandContext = {
-    entity: EntityModel;
+    entity: EntityMetadata;
     queryParams: any;
     queryValues: any;
     queryFilter: any[];
@@ -17,6 +17,6 @@ export declare class UpdateCommand {
     protected constructor();
     static execute(args: UpdateCommandArgs): Promise<number>;
     protected static _prepareFilter(ctx: UpdateCommandContext, filter: any): Promise<void>;
-    protected static _prepareParams(ctx: UpdateCommandContext, entity: EntityModel, values: any, prefix?: string, suffix?: string): Promise<void>;
+    protected static _prepareParams(ctx: UpdateCommandContext, entity: EntityMetadata, values: any, prefix?: string, suffix?: string): Promise<void>;
 }
 export {};

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

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateCommand = void 0;
 const builder_1 = require("@sqb/builder");
-const command_helper_1 = require("./command.helper");
+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");
 class UpdateCommand {
     // istanbul ignore next
     constructor() {
@@ -48,7 +50,7 @@ class UpdateCommand {
         let v;
         prefix = prefix || '';
         suffix = suffix || '';
-        for (const col of entity.elements.values()) {
+        for (const col of Object.values(entity.elements)) {
             v = values[col.name];
             if (v === undefined)
                 continue;
@@ -61,7 +63,7 @@ class UpdateCommand {
                     throw new Error(`${entity.name}.${col.name} is required and can't be null`);
                 if (v === undefined)
                     continue;
-                col.checkEnumValue(v);
+                column_element_metadata_1.ColumnElementMetadata.checkEnumValue(col, v);
                 const fieldName = prefix + col.fieldName + suffix;
                 const k = '$input_' + fieldName;
                 ctx.queryValues[fieldName] = (0, builder_1.Param)({
@@ -72,8 +74,8 @@ class UpdateCommand {
                 ctx.queryParams[k] = v;
                 ctx.colCount++;
             }
-            else if (v != null && (0, orm_helper_1.isObjectElement)(col)) {
-                const type = await col.resolveType();
+            else if (v != null && (0, orm_helper_1.isEmbeddedElement)(col)) {
+                const type = await embedded_element_metadata_1.EmbeddedElementMetadata.resolveType(col);
                 await this._prepareParams(ctx, type, v, col.fieldNamePrefix, col.fieldNameSuffix);
             }
         }

package/dist/orm/decorators/column.decorator.d.ts

@@ -1,4 +1,4 @@
 import { DataType } from '@sqb/builder';
-import { DataPropertyOptions } from '../orm.type';
+import { ColumnElementOptions } from '../model/column-element-metadata';
 export declare function Column(type?: DataType): PropertyDecorator;
-export declare function Column(options?: DataPropertyOptions): PropertyDecorator;
+export declare function Column(options?: ColumnElementOptions): PropertyDecorator;

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

@@ -1,14 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Column = void 0;
-const entity_model_1 = require("../model/entity-model");
+const entity_metadata_1 = require("../model/entity-metadata");
 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;
-        entity_model_1.EntityModel.attachTo(target.constructor)
-            .defineColumnElement(propertyKey, options);
+        const options = (typeof arg0 === 'string' ? { dataType: arg0 } : arg0) || {};
+        const entity = entity_metadata_1.EntityMetadata.inject(target.constructor);
+        if (!options.type) {
+            const typ = Reflect.getMetadata("design:type", entity.ctor.prototype, propertyKey);
+            if (typ === Array) {
+                options.type = String;
+                options.isArray = true;
+            }
+            else
+                options.type = typ;
+        }
+        entity_metadata_1.EntityMetadata.defineColumnElement(entity, propertyKey, options);
     };
 }
 exports.Column = Column;

package/dist/orm/decorators/embedded.decorator.d.ts

@@ -1,2 +1,3 @@
-import { EmbeddedTypeOptions, TypeThunk } from '../orm.type';
-export declare function Embedded(type?: TypeThunk, options?: EmbeddedTypeOptions): PropertyDecorator;
+import { EmbeddedElementOptions } from '../model/embedded-element-metadata';
+import { TypeThunk } from '../orm.type';
+export declare function Embedded(type?: TypeThunk, options?: EmbeddedElementOptions): PropertyDecorator;

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

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Embedded = void 0;
-const entity_model_1 = require("../model/entity-model");
+const entity_metadata_1 = require("../model/entity-metadata");
 function Embedded(type, options) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('Symbol properties are not accepted');
-        const el = entity_model_1.EntityModel.attachTo(target.constructor)
-            .defineObjectElement(propertyKey, type);
-        if (options?.fieldNamePrefix)
-            el.fieldNamePrefix = options.fieldNamePrefix;
-        if (options?.fieldNameSuffix)
-            el.fieldNameSuffix = options.fieldNameSuffix;
+        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.inject(target.constructor);
+        entity_metadata_1.EntityMetadata.defineEmbeddedElement(entity, propertyKey, type, options);
     };
 }
 exports.Embedded = Embedded;

package/dist/orm/decorators/entity.decorator.d.ts

@@ -1,6 +1,33 @@
-import { EntityModel } from '../model/entity-model';
-import { EntityConfig } from '../orm.type';
-export declare function Entity(options?: EntityConfig | string): ClassDecorator;
+import { Maybe, Type } from 'ts-gems';
+import { AssociationElementMetadata } from '../model/association-element-metadata';
+import { ColumnElementMetadata } from '../model/column-element-metadata';
+import { EmbeddedElementMetadata } from '../model/embedded-element-metadata';
+import { AnyElementMetadata, EntityMetadata, EntityOptions } from '../model/entity-metadata';
+import { IndexMetadata } from '../model/index-metadata';
+export declare function Entity(options?: EntityOptions | string): ClassDecorator;
 export declare namespace Entity {
-    function getMetadata(ctor: Function): EntityModel | undefined;
+    const getMetadata: typeof EntityMetadata.get;
+    const getOwnMetadata: typeof EntityMetadata.getOwn;
+    function getElement<T>(ctor: Type<T>, key: keyof T | string): Maybe<AnyElementMetadata>;
+    function getColumnElement<T>(ctor: Type<T>, key: keyof T | string): Maybe<ColumnElementMetadata>;
+    function getEmbeddedElement<T>(ctor: Type<T>, key: keyof T | string): Maybe<EmbeddedElementMetadata>;
+    function getAssociationElement<T>(ctor: Type<T>, key: keyof T | string): Maybe<AssociationElementMetadata>;
+    function getColumnElementByFieldName(ctor: Type, fieldName: string): Maybe<ColumnElementMetadata>;
+    function find(ctor: Type, predicate: (el: AnyElementMetadata) => boolean): Maybe<AnyElementMetadata>;
+    function getElementNames(ctor: Type, filter?: (el: AnyElementMetadata) => boolean): string[];
+    function getColumnNames(ctor: Type): string[];
+    function getEmbeddedElementNames(ctor: Type): string[];
+    function getAssociationElementNames(ctor: Type): string[];
+    function getNonAssociationElementNames(ctor: Type): string[];
+    function getInsertColumnNames(ctor: Type): string[];
+    function getUpdateColumnNames(ctor: Type): string[];
+    function getPrimaryIndex(ctor: Type): Maybe<IndexMetadata>;
+    function getPrimaryIndexColumns(ctor: Type): ColumnElementMetadata[];
+    function Pick<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Pick<T, typeof keys[number]>>;
+    function Omit<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Omit<T, typeof keys[number]>>;
+    function Union<A, B>(baseA: Type<A>, baseB: Type<B>): Type<A & B>;
+    function Union<A, B, C>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>): Type<A & B & C>;
+    function Union<A, B, C, D>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>): Type<A & B & C & D>;
+    function Union<A, B, C, D, E>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>): Type<A & B & C & D & E>;
+    function Union<A, B, C, D, E, F>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>, baseF: Type<F>): Type<A & B & C & D & E & F>;
 }

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

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entity = void 0;
-const entity_model_1 = require("../model/entity-model");
+const entity_metadata_1 = require("../model/entity-metadata");
+const apply_mixins_1 = require("../util/apply-mixins");
 function Entity(options) {
     return function (target) {
         const opts = typeof options === 'object' ? options : {};
         const tableName = typeof options === 'string' ? options : opts.tableName;
-        const entity = entity_model_1.EntityModel.attachTo(target);
+        const entity = entity_metadata_1.EntityMetadata.inject(target);
         entity.tableName = tableName || target.name;
         if (opts.schema)
             entity.schema = opts.schema;
@@ -16,8 +17,149 @@ function Entity(options) {
 }
 exports.Entity = Entity;
 (function (Entity) {
-    function getMetadata(ctor) {
-        return entity_model_1.EntityModel.get(ctor);
+    Entity.getMetadata = entity_metadata_1.EntityMetadata.get;
+    Entity.getOwnMetadata = entity_metadata_1.EntityMetadata.getOwn;
+    function getElement(ctor, key) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_1.EntityMetadata.getElement(model, key);
     }
-    Entity.getMetadata = getMetadata;
+    Entity.getElement = getElement;
+    function getColumnElement(ctor, key) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_1.EntityMetadata.getColumnElement(model, key);
+    }
+    Entity.getColumnElement = getColumnElement;
+    function getEmbeddedElement(ctor, key) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_1.EntityMetadata.getEmbeddedElement(model, key);
+    }
+    Entity.getEmbeddedElement = getEmbeddedElement;
+    function getAssociationElement(ctor, key) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_1.EntityMetadata.getAssociationElement(model, key);
+    }
+    Entity.getAssociationElement = getAssociationElement;
+    function getColumnElementByFieldName(ctor, fieldName) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_1.EntityMetadata.getColumnElementByFieldName(model, fieldName);
+    }
+    Entity.getColumnElementByFieldName = getColumnElementByFieldName;
+    function find(ctor, predicate) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return model && entity_metadata_1.EntityMetadata.findElement(model, predicate);
+    }
+    Entity.find = find;
+    function getElementNames(ctor, filter) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_1.EntityMetadata.getElementNames(model, filter)) || [];
+    }
+    Entity.getElementNames = getElementNames;
+    function getColumnNames(ctor) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_1.EntityMetadata.getColumnNames(model)) || [];
+    }
+    Entity.getColumnNames = getColumnNames;
+    function getEmbeddedElementNames(ctor) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_1.EntityMetadata.getEmbeddedElementNames(model)) || [];
+    }
+    Entity.getEmbeddedElementNames = getEmbeddedElementNames;
+    function getAssociationElementNames(ctor) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_1.EntityMetadata.getAssociationElementNames(model)) || [];
+    }
+    Entity.getAssociationElementNames = getAssociationElementNames;
+    function getNonAssociationElementNames(ctor) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_1.EntityMetadata.getNonAssociationElementNames(model)) || [];
+    }
+    Entity.getNonAssociationElementNames = getNonAssociationElementNames;
+    function getInsertColumnNames(ctor) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_1.EntityMetadata.getInsertColumnNames(model)) || [];
+    }
+    Entity.getInsertColumnNames = getInsertColumnNames;
+    function getUpdateColumnNames(ctor) {
+        const model = entity_metadata_1.EntityMetadata.get(ctor);
+        return (model && entity_metadata_1.EntityMetadata.getUpdateColumnNames(model)) || [];
+    }
+    Entity.getUpdateColumnNames = getUpdateColumnNames;
+    function getPrimaryIndex(ctor) {
+        const model = entity_metadata_1.EntityMetadata.inject(ctor);
+        return entity_metadata_1.EntityMetadata.getPrimaryIndex(model);
+    }
+    Entity.getPrimaryIndex = getPrimaryIndex;
+    function getPrimaryIndexColumns(ctor) {
+        const model = entity_metadata_1.EntityMetadata.inject(ctor);
+        return entity_metadata_1.EntityMetadata.getPrimaryIndexColumns(model);
+    }
+    Entity.getPrimaryIndexColumns = getPrimaryIndexColumns;
+    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_1.applyMixins)(PickEntityClass, classRef, filter);
+        const srcMeta = entity_metadata_1.EntityMetadata.get(classRef);
+        if (srcMeta) {
+            const trgMeta = entity_metadata_1.EntityMetadata.inject(PickEntityClass);
+            entity_metadata_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_1.applyMixins)(OmitEntityClass, classRef, filter);
+        const srcMeta = entity_metadata_1.EntityMetadata.get(classRef);
+        if (srcMeta) {
+            const trgMeta = entity_metadata_1.EntityMetadata.inject(OmitEntityClass);
+            entity_metadata_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_1.applyMixins)(UnionClass, base);
+            const srcMeta = entity_metadata_1.EntityMetadata.get(base);
+            if (srcMeta) {
+                const trgMeta = entity_metadata_1.EntityMetadata.inject(UnionClass);
+                entity_metadata_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 {
+        //
+    }
+}

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

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AfterDestroy = exports.AfterUpdate = exports.AfterInsert = exports.BeforeDestroy = exports.BeforeUpdate = exports.BeforeInsert = void 0;
-const entity_model_1 = require("../model/entity-model");
+const entity_metadata_1 = require("../model/entity-metadata");
 function BeforeInsert() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = entity_model_1.EntityModel.attachTo(target.constructor);
+        const model = entity_metadata_1.EntityMetadata.inject(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.before('insert', fn);
+        entity_metadata_1.EntityMetadata.addEventListener(model, 'before-insert', fn);
     };
 }
 exports.BeforeInsert = BeforeInsert;
@@ -18,11 +16,9 @@ function BeforeUpdate() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = entity_model_1.EntityModel.attachTo(target.constructor);
+        const model = entity_metadata_1.EntityMetadata.inject(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.before('update', fn);
+        entity_metadata_1.EntityMetadata.addEventListener(model, 'before-update', fn);
     };
 }
 exports.BeforeUpdate = BeforeUpdate;
@@ -30,11 +26,9 @@ function BeforeDestroy() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = entity_model_1.EntityModel.attachTo(target.constructor);
+        const model = entity_metadata_1.EntityMetadata.inject(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.before('destroy', fn);
+        entity_metadata_1.EntityMetadata.addEventListener(model, 'before-destroy', fn);
     };
 }
 exports.BeforeDestroy = BeforeDestroy;
@@ -42,11 +36,9 @@ function AfterInsert() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = entity_model_1.EntityModel.attachTo(target.constructor);
+        const model = entity_metadata_1.EntityMetadata.inject(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.after('insert', fn);
+        entity_metadata_1.EntityMetadata.addEventListener(model, 'after-insert', fn);
     };
 }
 exports.AfterInsert = AfterInsert;
@@ -54,11 +46,9 @@ function AfterUpdate() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = entity_model_1.EntityModel.attachTo(target.constructor);
+        const model = entity_metadata_1.EntityMetadata.inject(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.after('update', fn);
+        entity_metadata_1.EntityMetadata.addEventListener(model, 'after-update', fn);
     };
 }
 exports.AfterUpdate = AfterUpdate;
@@ -66,11 +56,9 @@ function AfterDestroy() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = entity_model_1.EntityModel.attachTo(target.constructor);
+        const model = entity_metadata_1.EntityMetadata.inject(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.after('destroy', fn);
+        entity_metadata_1.EntityMetadata.addEventListener(model, 'after-destroy', fn);
     };
 }
 exports.AfterDestroy = AfterDestroy;

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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForeignKey = void 0;
-const entity_model_1 = require("../model/entity-model");
+const entity_metadata_1 = require("../model/entity-metadata");
 function ForeignKey(type, targetKey) {
     return function (target, propertyKey) {
         if (typeof propertyKey !== 'string')
             throw new Error('Symbol properties are not accepted');
-        entity_model_1.EntityModel.attachTo(target.constructor)
-            .addForeignKey(propertyKey, type, targetKey);
+        const entity = entity_metadata_1.EntityMetadata.inject(target.constructor);
+        entity_metadata_1.EntityMetadata.addForeignKey(entity, propertyKey, type, targetKey);
     };
 }
 exports.ForeignKey = ForeignKey;

package/dist/orm/decorators/index.decorator.d.ts

@@ -1,3 +1,3 @@
-import { IndexOptions } from '../orm.type';
-export declare function Index(fields: string | string[], options?: IndexOptions): ClassDecorator;
-export declare function Index(options?: IndexOptions): PropertyDecorator;
+import { IndexMetadata } from '../model/index-metadata';
+export declare function Index(fields: string | string[], options?: Omit<IndexMetadata, 'columns'>): ClassDecorator;
+export declare function Index(options?: Omit<IndexMetadata, 'columns'>): PropertyDecorator;

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

@@ -1,22 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Index = void 0;
-const entity_model_1 = require("../model/entity-model");
+const entity_metadata_1 = require("../model/entity-metadata");
 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 entity = entity_model_1.EntityModel.attachTo(target);
-            entity.addIndex(arg0, arg1);
-            return;
+            const model = entity_metadata_1.EntityMetadata.inject(target);
+            return entity_metadata_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 entity = entity_model_1.EntityModel.attachTo(target.constructor);
-        entity.addIndex(propertyKey, arg0);
+        const model = entity_metadata_1.EntityMetadata.inject(target.constructor);
+        entity_metadata_1.EntityMetadata.addIndex(model, { ...arg0, columns: [propertyKey] });
     };
 }
 exports.Index = Index;

package/dist/orm/decorators/link.decorator.d.ts

@@ -1,5 +1,5 @@
-import { TypeThunk } from '../orm.type';
 import { LinkChain } from '../model/link-chain';
+import { TypeThunk } from '../orm.type';
 export declare function Link(chain: LinkChain<any>): PropertyDecorator;
 export declare function LinkToOne(type?: TypeThunk, targetKey?: string, sourceKey?: string): PropertyDecorator;
 export declare function LinkToMany(type: TypeThunk, targetKey?: string, sourceKey?: string): PropertyDecorator;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.linkFromMany = exports.linkFromOne = exports.linkToMany = exports.linkToOne = exports.LinkFromMany = exports.LinkFromOne = exports.LinkToMany = exports.LinkToOne = exports.Link = void 0;
-const entity_model_1 = require("../model/entity-model");
+const entity_metadata_1 = require("../model/entity-metadata");
 const link_chain_1 = require("../model/link-chain");
 function Link(chain) {
     return (target, propertyKey) => {
@@ -10,11 +10,11 @@ function Link(chain) {
         if (chain.first.returnsMany() &&
             Reflect.getMetadata("design:type", target, propertyKey) !== Array)
             throw new Error(`Returning type of property (${propertyKey}) must be an array`);
-        const entity = entity_model_1.EntityModel.attachTo(target.constructor);
+        const entity = entity_metadata_1.EntityMetadata.inject(target.constructor);
         // @ts-ignore
         // noinspection JSConstantReassignment
         chain.first.source = entity.ctor;
-        entity.defineAssociationElement(propertyKey, chain.first);
+        entity_metadata_1.EntityMetadata.defineAssociationElement(entity, propertyKey, chain.first);
     };
 }
 exports.Link = Link;

package/dist/orm/decorators/primarykey.decorator.d.ts

@@ -1,3 +1,3 @@
-import { IndexOptions } from '../orm.type';
-export declare function PrimaryKey(fields: string | string[], options?: IndexOptions): ClassDecorator;
-export declare function PrimaryKey(options?: IndexOptions): PropertyDecorator;
+import { IndexMetadata } from '../model/index-metadata';
+export declare function PrimaryKey(fields: string | string[], options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): ClassDecorator;
+export declare function PrimaryKey(options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): PropertyDecorator;

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

@@ -1,23 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrimaryKey = void 0;
-const entity_model_1 = require("../model/entity-model");
+const entity_metadata_1 = require("../model/entity-metadata");
+const column_decorator_1 = require("./column.decorator");
 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 entity = entity_model_1.EntityModel.attachTo(target);
-            entity.setPrimaryIndex(arg0, arg1);
+            const meta = entity_metadata_1.EntityMetadata.inject(target);
+            entity_metadata_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 entity = entity_model_1.EntityModel.attachTo(target.constructor);
-        entity.defineColumnElement(propertyKey, { notNull: true });
-        entity.setPrimaryIndex(propertyKey, arg0);
+        const meta = entity_metadata_1.EntityMetadata.inject(target.constructor);
+        (0, column_decorator_1.Column)({ notNull: true })(target, propertyKey);
+        entity_metadata_1.EntityMetadata.setPrimaryKeys(meta, propertyKey, arg0);
     };
 }
 exports.PrimaryKey = PrimaryKey;

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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Serialize = exports.Parse = void 0;
-const entity_model_1 = require("../model/entity-model");
+const entity_metadata_1 = require("../model/entity-metadata");
 function Parse(fn) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        entity_model_1.EntityModel.attachTo(target.constructor)
-            .defineColumnElement(propertyKey)
+        const entity = entity_metadata_1.EntityMetadata.inject(target.constructor);
+        entity_metadata_1.EntityMetadata.defineColumnElement(entity, propertyKey)
             .parse = fn;
     };
 }
@@ -16,8 +16,8 @@ function Serialize(fn) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        entity_model_1.EntityModel.attachTo(target.constructor)
-            .defineColumnElement(propertyKey)
+        const entity = entity_metadata_1.EntityMetadata.inject(target.constructor);
+        entity_metadata_1.EntityMetadata.defineColumnElement(entity, propertyKey)
             .serialize = fn;
     };
 }

package/dist/orm/model/association-element-metadata.d.ts

@@ -0,0 +1,10 @@
+import { AssociationNode } from './association-node';
+import { ElementMetadata } from './element-metadata';
+import type { EntityMetadata } from './entity-metadata';
+export interface AssociationElementMetadata extends ElementMetadata {
+    readonly kind: 'association';
+    readonly association: AssociationNode;
+}
+export declare namespace AssociationElementMetadata {
+    function create(entity: EntityMetadata, name: string, association: AssociationNode): AssociationElementMetadata;
+}

package/dist/orm/model/association-element-metadata.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssociationElementMetadata = void 0;
+var AssociationElementMetadata;
+(function (AssociationElementMetadata) {
+    function create(entity, name, association) {
+        return {
+            kind: 'association',
+            entity,
+            name,
+            association
+        };
+    }
+    AssociationElementMetadata.create = create;
+})(AssociationElementMetadata = exports.AssociationElementMetadata || (exports.AssociationElementMetadata = {}));