@sqb/connect 4.0.13 → 4.1.0

package/dist/orm/model/association.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Association = void 0;
 const putil_varhelpers_1 = require("putil-varhelpers");
 const orm_helper_1 = require("../util/orm.helper");
+const entity_metadata_1 = require("./entity-metadata");
 class Association {
     constructor(name, args) {
         this.name = name;
@@ -59,7 +60,7 @@ class Association {
         let targetKey = this.targetKey;
         if (!(sourceKey && targetKey)) {
             // Try to determine key fields from foreign key from source to target
-            let foreign = await source.getForeignKeyFor(target);
+            let foreign = await entity_metadata_1.EntityMetadata.getForeignKeyFor(source, target);
             if (foreign && foreign !== this) {
                 await foreign._resolveKeys();
                 this._sourceKey = foreign._sourceKey;
@@ -70,7 +71,7 @@ class Association {
             }
             else {
                 // Try to determine key fields from foreign key from target to source
-                foreign = await target.getForeignKeyFor(source);
+                foreign = await entity_metadata_1.EntityMetadata.getForeignKeyFor(target, source);
                 if (foreign && foreign !== this) {
                     await foreign._resolveKeys();
                     this._sourceKey = foreign._targetKey;
@@ -97,14 +98,14 @@ class Association {
                 masterKey = sourceKey || '';
             }
             if (!detailKey) {
-                const primaryIndex = detail.primaryIndex;
-                detailKey = primaryIndex && primaryIndex.columns.length === 1 ?
-                    primaryIndex.columns[0] : 'id';
+                const primaryIndexColumns = entity_metadata_1.EntityMetadata.getPrimaryIndexColumns(detail);
+                detailKey = primaryIndexColumns && primaryIndexColumns.length === 1 ?
+                    primaryIndexColumns[0].name : 'id';
             }
             if (!masterKey) {
                 // snake-case
                 masterKey = detail.name[0].toLowerCase() + detail.name.substring(1) + '_' + detailKey;
-                if (!master.getColumnElement(masterKey))
+                if (!entity_metadata_1.EntityMetadata.getColumnElement(master, masterKey))
                     masterKey = (0, putil_varhelpers_1.camelCase)(masterKey);
             }
             if (this.sourceBelongsToTarget) {
@@ -116,10 +117,10 @@ class Association {
                 sourceKey = masterKey;
             }
         }
-        this._targetProperty = target.getColumnElement(targetKey);
+        this._targetProperty = entity_metadata_1.EntityMetadata.getColumnElement(target, targetKey);
         if (!this._targetProperty)
             throw new Error(`Can't determine target key of ${this.name}`);
-        this._sourceProperty = source.getColumnElement(sourceKey);
+        this._sourceProperty = entity_metadata_1.EntityMetadata.getColumnElement(source, sourceKey);
         if (!this._sourceProperty)
             throw new Error(`Can't determine source key of ${this.name}`);
         this._targetKey = targetKey;

package/dist/orm/model/{entity-column-element.d.ts → column-element-metadata.d.ts}

@@ -1,13 +1,22 @@
-import 'reflect-metadata';
 import { DataType } from '@sqb/builder';
-import type { EntityModel } from './entity-model';
-import { ElementKind, ColumnAutoGenerationStrategy, ColumnTransformFunction, DataPropertyOptions, EnumValue, FieldValue, DefaultValueGetter } from '../orm.type';
-import { AbstractEntityelement } from './abstract-entityelement';
-export declare class EntityColumnElement extends AbstractEntityelement {
-    readonly kind: ElementKind;
+import type { ColumnAutoGenerationStrategy, ColumnTransformFunction, DefaultValueGetter, EnumValue, FieldValue } from '../orm.type';
+import { ElementMetadata } from './element-metadata';
+import type { EntityMetadata } from './entity-metadata';
+export declare type ColumnElementOptions = Partial<Omit<ColumnElementMetadata, 'entity' | 'name' | 'kind'>>;
+export interface ColumnElementMetadata extends ElementMetadata {
+    readonly kind: 'column';
+    /**
+     Name of table field
+     */
     fieldName: string;
-    dataType?: DataType;
+    /**
+     JS type. String, Boolean, Person etc
+    */
     type?: Function;
+    /**
+     * Column data type
+     */
+    dataType?: DataType;
     /**
      * Field comment
      */
@@ -62,7 +71,9 @@ export declare class EntityColumnElement extends AbstractEntityelement {
     noInsert?: boolean;
     parse?: ColumnTransformFunction;
     serialize?: ColumnTransformFunction;
-    constructor(entity: EntityModel, name: string, options?: DataPropertyOptions);
-    assign(options: DataPropertyOptions): void;
-    checkEnumValue(v: FieldValue): void;
+}
+export declare namespace ColumnElementMetadata {
+    function create(entity: EntityMetadata, name: string, options?: ColumnElementOptions): ColumnElementMetadata;
+    function assign(target: ColumnElementMetadata, options: ColumnElementOptions): void;
+    function checkEnumValue(col: ColumnElementMetadata, v: FieldValue): void;
 }

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnElementMetadata = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+var ColumnElementMetadata;
+(function (ColumnElementMetadata) {
+    function create(entity, name, options = {}) {
+        const result = {
+            kind: 'column',
+            entity,
+            name,
+            fieldName: name
+        };
+        if (options)
+            ColumnElementMetadata.assign(result, options);
+        return result;
+    }
+    ColumnElementMetadata.create = create;
+    function assign(target, options) {
+        Object.assign(target, lodash_1.default.omit(options, ['entity', 'name', 'kind']));
+    }
+    ColumnElementMetadata.assign = assign;
+    function checkEnumValue(col, v) {
+        if (v === undefined || !col.enum || (v == null && !col.notNull))
+            return;
+        const enumKeys = Array.isArray(col.enum) ? col.enum : Object.keys(col.enum);
+        if (!enumKeys.includes(v))
+            throw new Error(`${col.entity.name}.${col.name} value must be one of (${enumKeys})`);
+    }
+    ColumnElementMetadata.checkEnumValue = checkEnumValue;
+})(ColumnElementMetadata = exports.ColumnElementMetadata || (exports.ColumnElementMetadata = {}));

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

@@ -0,0 +1,7 @@
+import type { ElementKind } from '../orm.type';
+import type { EntityMetadata } from './entity-metadata';
+export interface ElementMetadata {
+    readonly entity: EntityMetadata;
+    readonly name: string;
+    readonly kind: ElementKind;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,14 @@
+import { TypeThunk } from '../orm.type';
+import { ElementMetadata } from './element-metadata';
+import type { EntityMetadata } from './entity-metadata';
+export declare type EmbeddedElementOptions = Partial<Omit<EmbeddedElementMetadata, 'entity' | 'name' | 'kind' | 'type'>>;
+export interface EmbeddedElementMetadata extends ElementMetadata {
+    readonly kind: 'object';
+    type: TypeThunk;
+    fieldNamePrefix?: string;
+    fieldNameSuffix?: string;
+}
+export declare namespace EmbeddedElementMetadata {
+    function create(entity: EntityMetadata, name: string, type: TypeThunk, options?: EmbeddedElementOptions): EmbeddedElementMetadata;
+    function resolveType(meta: EmbeddedElementMetadata): Promise<EntityMetadata>;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddedElementMetadata = void 0;
+const orm_helper_1 = require("../util/orm.helper");
+var EmbeddedElementMetadata;
+(function (EmbeddedElementMetadata) {
+    function create(entity, name, type, options) {
+        const result = {
+            kind: 'object',
+            entity,
+            name,
+            type
+        };
+        if (options?.fieldNamePrefix)
+            result.fieldNamePrefix = options.fieldNamePrefix;
+        if (options?.fieldNameSuffix)
+            result.fieldNameSuffix = options.fieldNameSuffix;
+        return result;
+    }
+    EmbeddedElementMetadata.create = create;
+    async function resolveType(meta) {
+        const typ = await (0, orm_helper_1.resolveEntityMeta)(meta.type);
+        if (typ)
+            return typ;
+        throw new Error(`Can't resolve type of ${meta.entity.name}.${meta.name}`);
+    }
+    EmbeddedElementMetadata.resolveType = resolveType;
+})(EmbeddedElementMetadata = exports.EmbeddedElementMetadata || (exports.EmbeddedElementMetadata = {}));

package/dist/orm/model/entity-metadata.d.ts

@@ -0,0 +1,49 @@
+import { Maybe, Type } from 'ts-gems';
+import { Ctor, TypeThunk } from '../orm.type';
+import { Association } from './association';
+import { AssociationElementMetadata } from './association-element-metadata';
+import { AssociationNode } from './association-node';
+import { ColumnElementMetadata, ColumnElementOptions } from './column-element-metadata';
+import { EmbeddedElementMetadata, EmbeddedElementOptions } from './embedded-element-metadata';
+import { IndexMetadata } from './index-metadata';
+export declare type AnyElementMetadata = ColumnElementMetadata | EmbeddedElementMetadata | AssociationElementMetadata;
+export declare type EntityOptions = Partial<Pick<EntityMetadata, 'name' | 'schema' | 'comment' | 'tableName'>>;
+export interface EntityMetadata {
+    readonly ctor: Type;
+    readonly name: string;
+    tableName?: string;
+    schema?: string;
+    comment?: string;
+    elements: Record<string, AnyElementMetadata>;
+    indexes: IndexMetadata[];
+    foreignKeys: Association[];
+    eventListeners: Record<string, Function[]>;
+}
+export declare namespace EntityMetadata {
+    function inject(ctor: Ctor): EntityMetadata;
+    function get(ctor: Ctor): Maybe<EntityMetadata>;
+    function getOwn(ctor: Ctor): Maybe<EntityMetadata>;
+    function getElement(entity: EntityMetadata, elementName: string): Maybe<AnyElementMetadata>;
+    function getColumnElement(entity: EntityMetadata, elementName: string): Maybe<ColumnElementMetadata>;
+    function getEmbeddedElement(entity: EntityMetadata, elementName: string): Maybe<EmbeddedElementMetadata>;
+    function getAssociationElement(entity: EntityMetadata, elementName: string): Maybe<AssociationElementMetadata>;
+    function getColumnElementByFieldName(entity: EntityMetadata, fieldName: string): Maybe<ColumnElementMetadata>;
+    function getElementNames(entity: EntityMetadata, filter?: (el: AnyElementMetadata) => boolean): string[];
+    function getColumnNames(entity: EntityMetadata): string[];
+    function getEmbeddedElementNames(entity: EntityMetadata): string[];
+    function getAssociationElementNames(entity: EntityMetadata): string[];
+    function getNonAssociationElementNames(entity: EntityMetadata): string[];
+    function getInsertColumnNames(entity: EntityMetadata): string[];
+    function getUpdateColumnNames(entity: EntityMetadata): string[];
+    function getPrimaryIndex(entity: EntityMetadata): Maybe<IndexMetadata>;
+    function getPrimaryIndexColumns(entity: EntityMetadata): ColumnElementMetadata[];
+    function getForeignKeyFor(src: EntityMetadata, trg: EntityMetadata): Promise<Maybe<Association>>;
+    function addIndex(entity: EntityMetadata, index: IndexMetadata): void;
+    function addForeignKey(entity: EntityMetadata, propertyKey: string, target: TypeThunk, targetKey?: string): void;
+    function addEventListener(entity: EntityMetadata, event: string, fn: Function): void;
+    function defineColumnElement(entity: EntityMetadata, name: string, options?: ColumnElementOptions): ColumnElementMetadata;
+    function defineEmbeddedElement(entity: EntityMetadata, name: string, type: TypeThunk, options?: EmbeddedElementOptions): EmbeddedElementMetadata;
+    function defineAssociationElement(entity: EntityMetadata, propertyKey: string, association: AssociationNode): AssociationElementMetadata;
+    function setPrimaryKeys(entity: EntityMetadata, column: string | string[], options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): void;
+    function mixin(derived: EntityMetadata, base: EntityMetadata, elements?: string[]): void;
+}

package/dist/orm/model/entity-metadata.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityMetadata = void 0;
+const builder_1 = require("@sqb/builder");
+const orm_const_1 = require("../orm.const");
+const orm_helper_1 = require("../util/orm.helper");
+const serialize_element_1 = require("../util/serialize-element");
+const association_1 = require("./association");
+const association_element_metadata_1 = require("./association-element-metadata");
+const column_element_metadata_1 = require("./column-element-metadata");
+const embedded_element_metadata_1 = require("./embedded-element-metadata");
+var EntityMetadata;
+(function (EntityMetadata) {
+    function inject(ctor) {
+        const own = getOwn(ctor);
+        if (own)
+            return own;
+        const baseMeta = get(ctor);
+        const meta = {
+            ctor: ctor,
+            name: ctor.name,
+            elements: {},
+            indexes: [],
+            foreignKeys: [],
+            eventListeners: {}
+        };
+        Reflect.defineMetadata(orm_const_1.ENTITY_METADATA_KEY, meta, ctor);
+        // Merge base entity columns into this one
+        if (baseMeta) {
+            EntityMetadata.mixin(meta, baseMeta);
+        }
+        ctor.prototype.toJSON = function () {
+            const obj = {};
+            const elementKeys = Object.keys(meta.elements);
+            const l = elementKeys.length;
+            let key;
+            let v;
+            for (let i = 0; i < l; i++) {
+                key = elementKeys[i];
+                const col = EntityMetadata.getElement(meta, key);
+                if (col) {
+                    v = this[col.name];
+                    if (v !== undefined)
+                        obj[col.name] = (0, serialize_element_1.serializeColumn)(col, v);
+                }
+            }
+            return obj;
+        };
+        return meta;
+    }
+    EntityMetadata.inject = inject;
+    function get(ctor) {
+        return Reflect.getMetadata(orm_const_1.ENTITY_METADATA_KEY, ctor);
+    }
+    EntityMetadata.get = get;
+    function getOwn(ctor) {
+        return Reflect.getOwnMetadata(orm_const_1.ENTITY_METADATA_KEY, ctor);
+    }
+    EntityMetadata.getOwn = getOwn;
+    function getElement(entity, elementName) {
+        return elementName ? entity.elements[elementName.toLowerCase()] : undefined;
+    }
+    EntityMetadata.getElement = getElement;
+    function getColumnElement(entity, elementName) {
+        const el = getElement(entity, elementName);
+        return (0, orm_helper_1.isColumnElement)(el) ? el : undefined;
+    }
+    EntityMetadata.getColumnElement = getColumnElement;
+    function getEmbeddedElement(entity, elementName) {
+        const el = getElement(entity, elementName);
+        return (0, orm_helper_1.isEmbeddedElement)(el) ? el : undefined;
+    }
+    EntityMetadata.getEmbeddedElement = getEmbeddedElement;
+    function getAssociationElement(entity, elementName) {
+        const el = getElement(entity, elementName);
+        return (0, orm_helper_1.isAssociationElement)(el) ? el : undefined;
+    }
+    EntityMetadata.getAssociationElement = getAssociationElement;
+    function getColumnElementByFieldName(entity, fieldName) {
+        if (!fieldName)
+            return;
+        fieldName = fieldName.toLowerCase();
+        for (const prop of Object.values(entity.elements)) {
+            if ((0, orm_helper_1.isColumnElement)(prop) && prop.fieldName.toLowerCase() === fieldName)
+                return prop;
+        }
+    }
+    EntityMetadata.getColumnElementByFieldName = getColumnElementByFieldName;
+    function getElementNames(entity, filter) {
+        if (filter) {
+            const out = [];
+            for (const el of Object.values(entity.elements)) {
+                if (el && (!filter || filter(el)))
+                    out.push(el.name);
+            }
+            return out;
+        }
+        // Create a cached name array
+        if (!Object.prototype.hasOwnProperty.call(entity, '_elementNames'))
+            Object.defineProperty(entity, '_elementNames', {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: Object.values(entity.elements).map(m => m.name)
+            });
+        return entity._elementNames;
+    }
+    EntityMetadata.getElementNames = getElementNames;
+    function getColumnNames(entity) {
+        return getElementNames(entity, orm_helper_1.isColumnElement);
+    }
+    EntityMetadata.getColumnNames = getColumnNames;
+    function getEmbeddedElementNames(entity) {
+        return getElementNames(entity, orm_helper_1.isEmbeddedElement);
+    }
+    EntityMetadata.getEmbeddedElementNames = getEmbeddedElementNames;
+    function getAssociationElementNames(entity) {
+        return getElementNames(entity, orm_helper_1.isAssociationElement);
+    }
+    EntityMetadata.getAssociationElementNames = getAssociationElementNames;
+    function getNonAssociationElementNames(entity) {
+        return getElementNames(entity, x => !(0, orm_helper_1.isAssociationElement)(x));
+    }
+    EntityMetadata.getNonAssociationElementNames = getNonAssociationElementNames;
+    function getInsertColumnNames(entity) {
+        return getElementNames(entity, x => (0, orm_helper_1.isColumnElement)(x) && !x.noInsert);
+    }
+    EntityMetadata.getInsertColumnNames = getInsertColumnNames;
+    function getUpdateColumnNames(entity) {
+        return getElementNames(entity, x => (0, orm_helper_1.isColumnElement)(x) && !x.noUpdate);
+    }
+    EntityMetadata.getUpdateColumnNames = getUpdateColumnNames;
+    function getPrimaryIndex(entity) {
+        return entity.indexes.find(idx => idx.primary);
+    }
+    EntityMetadata.getPrimaryIndex = getPrimaryIndex;
+    function getPrimaryIndexColumns(entity) {
+        const idx = getPrimaryIndex(entity);
+        const out = [];
+        if (idx) {
+            for (const k of idx.columns) {
+                const col = getColumnElement(entity, k);
+                if (!col)
+                    throw new Error(`Data column "${k}" in primary index of ${entity.name} does not exists`);
+                out.push(col);
+            }
+        }
+        return out;
+    }
+    EntityMetadata.getPrimaryIndexColumns = getPrimaryIndexColumns;
+    async function getForeignKeyFor(src, trg) {
+        for (const f of src.foreignKeys) {
+            if (await f.resolveTarget() === trg)
+                return f;
+        }
+    }
+    EntityMetadata.getForeignKeyFor = getForeignKeyFor;
+    function addIndex(entity, index) {
+        entity.indexes = entity.indexes || [];
+        index = {
+            ...index,
+            columns: Array.isArray(index.columns) ? index.columns : [index.columns]
+        };
+        if (index.primary)
+            entity.indexes.forEach(idx => delete idx.primary);
+        entity.indexes.push(index);
+    }
+    EntityMetadata.addIndex = addIndex;
+    function addForeignKey(entity, propertyKey, target, targetKey) {
+        entity.foreignKeys = entity.foreignKeys || [];
+        const fk = new association_1.Association(entity.name + '.' + propertyKey, {
+            source: entity.ctor,
+            sourceKey: propertyKey,
+            target,
+            targetKey
+        });
+        entity.foreignKeys.push(fk);
+    }
+    EntityMetadata.addForeignKey = addForeignKey;
+    function addEventListener(entity, event, fn) {
+        if (typeof fn !== 'function')
+            throw new Error('Property must be a function');
+        entity.eventListeners = entity.eventListeners || {};
+        entity.eventListeners[event] = entity.eventListeners[event] || [];
+        entity.eventListeners[event].push(fn);
+    }
+    EntityMetadata.addEventListener = addEventListener;
+    function defineColumnElement(entity, name, options = {}) {
+        delete entity._elementNames;
+        let prop = EntityMetadata.getElement(entity, name);
+        if ((0, orm_helper_1.isColumnElement)(prop))
+            options = { ...prop, ...options };
+        if (!options.type) {
+            switch (options.dataType) {
+                case builder_1.DataType.BOOL:
+                    options.type = Boolean;
+                    break;
+                case builder_1.DataType.VARCHAR:
+                case builder_1.DataType.CHAR:
+                case builder_1.DataType.TEXT:
+                    options.type = String;
+                    break;
+                case builder_1.DataType.NUMBER:
+                case builder_1.DataType.DOUBLE:
+                case builder_1.DataType.FLOAT:
+                case builder_1.DataType.INTEGER:
+                case builder_1.DataType.SMALLINT:
+                    options.type = Number;
+                    break;
+                case builder_1.DataType.TIMESTAMP:
+                case builder_1.DataType.TIMESTAMPTZ:
+                    options.type = Date;
+                    break;
+                case builder_1.DataType.BINARY:
+                    options.type = Buffer;
+                    break;
+                default:
+                    options.type = String;
+            }
+        }
+        if (!options.dataType) {
+            switch (options.type) {
+                case Boolean:
+                    options.dataType = builder_1.DataType.BOOL;
+                    break;
+                case Number:
+                    options.dataType = builder_1.DataType.NUMBER;
+                    break;
+                case Date:
+                    options.dataType = builder_1.DataType.TIMESTAMP;
+                    break;
+                case Array:
+                    options.dataType = builder_1.DataType.VARCHAR;
+                    options.isArray = true;
+                    break;
+                case Buffer:
+                    options.dataType = builder_1.DataType.BINARY;
+                    break;
+                default:
+                    options.dataType = builder_1.DataType.VARCHAR;
+            }
+        }
+        prop = column_element_metadata_1.ColumnElementMetadata.create(entity, name, options);
+        entity.elements[name.toLowerCase()] = prop;
+        return prop;
+    }
+    EntityMetadata.defineColumnElement = defineColumnElement;
+    function defineEmbeddedElement(entity, name, type, options) {
+        delete entity._elementNames;
+        let prop = EntityMetadata.getElement(entity, name);
+        if ((0, orm_helper_1.isEmbeddedElement)(prop))
+            options = { ...prop, ...options };
+        prop = embedded_element_metadata_1.EmbeddedElementMetadata.create(entity, name, type, options);
+        entity.elements[name.toLowerCase()] = prop;
+        return prop;
+    }
+    EntityMetadata.defineEmbeddedElement = defineEmbeddedElement;
+    function defineAssociationElement(entity, propertyKey, association) {
+        delete entity._elementNames;
+        const prop = association_element_metadata_1.AssociationElementMetadata.create(entity, propertyKey, association);
+        let l = association;
+        let i = 1;
+        while (l) {
+            l.name = entity.name + '.' + propertyKey + '#' + (i++);
+            l = l.next;
+        }
+        entity.elements[propertyKey.toLowerCase()] = prop;
+        return prop;
+    }
+    EntityMetadata.defineAssociationElement = defineAssociationElement;
+    function setPrimaryKeys(entity, column, options) {
+        addIndex(entity, {
+            ...options,
+            columns: Array.isArray(column) ? column : [column],
+            unique: true,
+            primary: true
+        });
+    }
+    EntityMetadata.setPrimaryKeys = setPrimaryKeys;
+    function mixin(derived, base, elements) {
+        const elementKeys = elements && elements.map(x => x.toLowerCase());
+        const hasElement = (k) => !(elementKeys && !elementKeys.includes(k.toLowerCase()));
+        // applyMixins(derived, baseCtor, hasElement);
+        delete derived._elementNames;
+        if (!derived.tableName) {
+            derived.tableName = base.tableName;
+            derived.schema = base.schema;
+            derived.comment = base.comment;
+        }
+        // Copy indexes
+        if (base.indexes && base.indexes.length) {
+            const hasPrimaryIndex = !!getPrimaryIndex(derived);
+            for (const idx of base.indexes) {
+                if (!idx.columns.find(x => !hasElement(x))) {
+                    if (hasPrimaryIndex)
+                        addIndex(derived, { ...idx, primary: undefined });
+                    else
+                        addIndex(derived, idx);
+                }
+            }
+        }
+        // Copy foreign indexes
+        if (base.foreignKeys && base.foreignKeys.length) {
+            derived.foreignKeys = derived.foreignKeys || [];
+            for (const fk of base.foreignKeys) {
+                if (!fk.sourceKey || hasElement(fk.sourceKey)) {
+                    const newFk = new association_1.Association(fk.name, { ...fk, source: derived.ctor });
+                    derived.foreignKeys.push(newFk);
+                }
+            }
+        }
+        // Copy event listeners
+        if (base.eventListeners) {
+            for (const [event, arr] of Object.entries(base.eventListeners)) {
+                arr.forEach(fn => EntityMetadata.addEventListener(derived, event, fn));
+            }
+        }
+        // Copy elements
+        for (const [n, p] of Object.entries(base.elements)) {
+            if (!hasElement(n))
+                continue;
+            const o = Object.assign({}, p);
+            o.entity = derived;
+            Object.setPrototypeOf(o, Object.getPrototypeOf(p));
+            derived.elements[n] = o;
+        }
+    }
+    EntityMetadata.mixin = mixin;
+})(EntityMetadata = exports.EntityMetadata || (exports.EntityMetadata = {}));

package/dist/orm/model/index-metadata.d.ts

@@ -0,0 +1,18 @@
+export interface IndexMetadata {
+    /**
+     *  Columns of the index
+     */
+    columns: string[];
+    /**
+     *  Name of the index
+     */
+    name?: string;
+    /**
+     * Specifies if index is unique
+     */
+    unique?: boolean;
+    /**
+     * Specifies if index is primary
+     */
+    primary?: boolean;
+}

package/dist/orm/model/index-metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/orm/orm.const.d.ts

@@ -1,2 +1,2 @@
-export declare const ENTITY_DEFINITION_KEY: unique symbol;
+export declare const ENTITY_METADATA_KEY: unique symbol;
 export declare const REPOSITORY_KEY: unique symbol;

package/dist/orm/orm.const.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REPOSITORY_KEY = exports.ENTITY_DEFINITION_KEY = void 0;
-exports.ENTITY_DEFINITION_KEY = Symbol.for('sqb.entity-definition');
-exports.REPOSITORY_KEY = Symbol.for('sqb.entity.repository');
+exports.REPOSITORY_KEY = exports.ENTITY_METADATA_KEY = void 0;
+exports.ENTITY_METADATA_KEY = Symbol.for('SQB_ENTITY_METADATA');
+exports.REPOSITORY_KEY = Symbol.for('SQB_REPOSITORY');