@sqb/connect 4.0.9 → 4.0.13

package/dist/orm/model/association.js

@@ -0,0 +1,129 @@
+"use strict";
+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");
+class Association {
+    constructor(name, args) {
+        this.name = name;
+        this.source = args.source;
+        this.target = args.target;
+        this.sourceKey = args.sourceKey;
+        this.targetKey = args.targetKey;
+        this.kind = args.kind;
+    }
+    async resolveSource() {
+        this._source = await (0, orm_helper_1.resolveEntityMeta)(this.source);
+        if (!this._source)
+            throw new Error(`Can't resolve source entity of association "${this.name}"`);
+        return this._source;
+    }
+    async resolveTarget() {
+        this._target = await (0, orm_helper_1.resolveEntityMeta)(this.target);
+        if (!this._target)
+            throw new Error(`Can't resolve target entity of association "${this.name}"`);
+        return this._target;
+    }
+    async resolveSourceKey() {
+        await this._resolveKeys();
+        // @ts-ignore
+        return this._sourceKey;
+    }
+    async resolveSourceProperty() {
+        await this._resolveKeys();
+        // @ts-ignore
+        return this._sourceProperty;
+    }
+    async resolveTargetKey() {
+        await this._resolveKeys();
+        // @ts-ignore
+        return this._targetKey;
+    }
+    async resolveTargetProperty() {
+        await this._resolveKeys();
+        // @ts-ignore
+        return this._targetProperty;
+    }
+    get sourceBelongsToTarget() {
+        return this.kind === 'from' || this.kind === 'from-many';
+    }
+    returnsMany() {
+        return this.kind === 'to-many' || this.kind === 'from-many';
+    }
+    async _resolveKeys() {
+        if (this._resolved)
+            return;
+        const source = await this.resolveSource();
+        const target = await this.resolveTarget();
+        let sourceKey = this.sourceKey;
+        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);
+            if (foreign && foreign !== this) {
+                await foreign._resolveKeys();
+                this._sourceKey = foreign._sourceKey;
+                this._sourceProperty = foreign._sourceProperty;
+                this._targetKey = foreign._targetKey;
+                this._targetProperty = foreign._targetProperty;
+                return;
+            }
+            else {
+                // Try to determine key fields from foreign key from target to source
+                foreign = await target.getForeignKeyFor(source);
+                if (foreign && foreign !== this) {
+                    await foreign._resolveKeys();
+                    this._sourceKey = foreign._targetKey;
+                    this._sourceProperty = foreign._targetProperty;
+                    this._targetKey = foreign._sourceKey;
+                    this._targetProperty = foreign._sourceProperty;
+                    return;
+                }
+            }
+            let master;
+            let detail;
+            let masterKey;
+            let detailKey;
+            if (this.sourceBelongsToTarget) {
+                master = target;
+                detail = source;
+                masterKey = targetKey || '';
+                detailKey = sourceKey || '';
+            }
+            else {
+                master = source;
+                detail = target;
+                detailKey = targetKey || '';
+                masterKey = sourceKey || '';
+            }
+            if (!detailKey) {
+                const primaryIndex = detail.primaryIndex;
+                detailKey = primaryIndex && primaryIndex.columns.length === 1 ?
+                    primaryIndex.columns[0] : 'id';
+            }
+            if (!masterKey) {
+                // snake-case
+                masterKey = detail.name[0].toLowerCase() + detail.name.substring(1) + '_' + detailKey;
+                if (!master.getColumnElement(masterKey))
+                    masterKey = (0, putil_varhelpers_1.camelCase)(masterKey);
+            }
+            if (this.sourceBelongsToTarget) {
+                targetKey = masterKey;
+                sourceKey = detailKey;
+            }
+            else {
+                targetKey = detailKey;
+                sourceKey = masterKey;
+            }
+        }
+        this._targetProperty = target.getColumnElement(targetKey);
+        if (!this._targetProperty)
+            throw new Error(`Can't determine target key of ${this.name}`);
+        this._sourceProperty = source.getColumnElement(sourceKey);
+        if (!this._sourceProperty)
+            throw new Error(`Can't determine source key of ${this.name}`);
+        this._targetKey = targetKey;
+        this._sourceKey = sourceKey;
+    }
+}
+exports.Association = Association;

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

@@ -0,0 +1,9 @@
+import type { EntityModel } from './entity-model';
+import { ElementKind } from '../orm.type';
+import { AbstractEntityelement } from './abstract-entityelement';
+import type { AssociationNode } from './association-node';
+export declare class EntityAssociationElement extends AbstractEntityelement {
+    readonly association: AssociationNode;
+    readonly kind: ElementKind;
+    constructor(entity: EntityModel, name: string, association: AssociationNode);
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityAssociationElement = void 0;
+const abstract_entityelement_1 = require("./abstract-entityelement");
+class EntityAssociationElement extends abstract_entityelement_1.AbstractEntityelement {
+    constructor(entity, name, association) {
+        super(entity, name);
+        this.association = association;
+        this.kind = 'association';
+        this.association.name = this.entity.name + '.' + name;
+    }
+}
+exports.EntityAssociationElement = EntityAssociationElement;

package/dist/orm/model/entity-column-element.d.ts

@@ -0,0 +1,68 @@
+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;
+    fieldName: string;
+    dataType?: DataType;
+    type?: Function;
+    /**
+     * Field comment
+     */
+    comment?: string;
+    /**
+     * Column's default value
+     */
+    default?: FieldValue | DefaultValueGetter;
+    /**
+     * Indicates if column data is an array
+     */
+    isArray?: boolean;
+    /**
+     * Indicates enum values
+     */
+    enum?: EnumValue;
+    /**
+     * Character or byte length of column
+     */
+    length?: number;
+    /**
+     * The precision for a decimal field
+     */
+    precision?: number;
+    /**
+     * The scale for a decimal field
+     */
+    scale?: number;
+    /**
+     * Fields's collation.
+     */
+    collation?: string;
+    /**
+     * Indicates auto generation strategy
+     */
+    autoGenerated?: ColumnAutoGenerationStrategy;
+    /**
+     * Indicates if column value can be null
+     */
+    notNull?: boolean;
+    /**
+     * Indicates whether or not to hide this column by default when making queries.
+     */
+    hidden?: boolean;
+    /**
+     * Indicates if column value is used in update queries
+     */
+    noUpdate?: boolean;
+    /**
+     * Indicates if column value is used in insert queries
+     */
+    noInsert?: boolean;
+    parse?: ColumnTransformFunction;
+    serialize?: ColumnTransformFunction;
+    constructor(entity: EntityModel, name: string, options?: DataPropertyOptions);
+    assign(options: DataPropertyOptions): void;
+    checkEnumValue(v: FieldValue): void;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityColumnElement = void 0;
+const tslib_1 = require("tslib");
+require("reflect-metadata");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const abstract_entityelement_1 = require("./abstract-entityelement");
+class EntityColumnElement extends abstract_entityelement_1.AbstractEntityelement {
+    constructor(entity, name, options = {}) {
+        super(entity, name);
+        this.kind = 'column';
+        this.fieldName = name;
+        if (options)
+            this.assign(options);
+    }
+    assign(options) {
+        Object.assign(this, lodash_1.default.omit(options, ['entity', 'name', 'kind']));
+    }
+    checkEnumValue(v) {
+        if (v === undefined || !this.enum || (v == null && !this.notNull))
+            return;
+        const enumKeys = Array.isArray(this.enum) ? this.enum : Object.keys(this.enum);
+        if (!enumKeys.includes(v))
+            throw new Error(`${this.entity.name}.${this.name} value must be one of (${enumKeys})`);
+    }
+}
+exports.EntityColumnElement = EntityColumnElement;

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

@@ -0,0 +1,59 @@
+import { Type, Maybe } from 'ts-gems';
+import { IndexOptions, TypeThunk, DataPropertyOptions } from '../orm.type';
+import { IndexMeta } from './index-meta';
+import { Association } from './association';
+import { EntityColumnElement } from './entity-column-element';
+import { EntityObjectElement } from './entity-object-element';
+import { EntityAssociationElement } from './entity-association-element';
+import { AssociationNode } from './association-node';
+export declare type EntityElement = EntityColumnElement | EntityObjectElement | EntityAssociationElement;
+export declare class EntityModel {
+    readonly ctor: Type;
+    private _elementKeys?;
+    readonly name: string;
+    tableName?: string;
+    schema?: string;
+    comment?: string;
+    primaryIndex?: IndexMeta;
+    elements: Map<string, EntityElement>;
+    indexes: IndexMeta[];
+    foreignKeys: Association[];
+    eventListeners: {
+        event: string;
+        fn: Function;
+    }[];
+    constructor(ctor: Type);
+    get elementKeys(): string[];
+    getElement(name: string): Maybe<EntityElement>;
+    getColumnElement(name: string): Maybe<EntityColumnElement>;
+    getColumnElementByFieldName(fieldName: string): Maybe<EntityColumnElement>;
+    getObjectElement(name: string): Maybe<EntityObjectElement>;
+    getAssociationElement(name: string): Maybe<EntityAssociationElement>;
+    defineColumnElement(propertyKey: string, options?: DataPropertyOptions): EntityColumnElement;
+    defineAssociationElement(propertyKey: string, association: AssociationNode): EntityAssociationElement;
+    defineObjectElement(propertyKey: string, type?: TypeThunk): EntityObjectElement;
+    setPrimaryIndex(column: string | string[], options?: IndexOptions): void;
+    addIndex(column: string | string[], options?: IndexOptions): void;
+    addForeignKey(propertyKey: string, target: TypeThunk, targetKey?: string): void;
+    before(event: 'insert' | 'update' | 'destroy', fn: Type): void;
+    after(event: 'insert' | 'update' | 'destroy', fn: Type): void;
+    getPrimaryIndexColumns(): EntityColumnElement[];
+    getElementNames(fn: (el: EntityElement) => boolean): string[];
+    getColumnNames(): string[];
+    getObjectElementNames(): string[];
+    getAssociationElementNames(): string[];
+    getNonAssociationElementNames(): string[];
+    getInsertColumnNames(): string[];
+    getUpdateColumnNames(): string[];
+    getForeignKeyFor(t: EntityModel): Promise<Maybe<Association>>;
+    static get(ctor: Function): Maybe<EntityModel>;
+    static hasOwn(ctor: Function): boolean;
+    static attachTo(ctor: Function): EntityModel;
+    static getElementNames<T extends Function, K extends keyof T>(ctor: T): K[] | undefined;
+    static getColumnNames<T extends Function, K extends keyof T>(ctor: T): K[] | undefined;
+    static getAssociationElementNames<T extends Function, K extends keyof T>(ctor: T): K[] | undefined;
+    static getNonAssociationElementNames<T extends Function, K extends keyof T>(ctor: T): K[] | undefined;
+    static getObjectElementNames<T extends Function, K extends keyof T>(ctor: T): K[] | undefined;
+    static getInsertColumnNames<T extends Function, K extends keyof T>(ctor: T): K[] | undefined;
+    static getUpdateColumnNames<T extends Function, K extends keyof T>(ctor: T): K[] | undefined;
+}

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

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityModel = void 0;
+const builder_1 = require("@sqb/builder");
+const orm_const_1 = require("../orm.const");
+const index_meta_1 = require("./index-meta");
+const association_1 = require("./association");
+const entity_column_element_1 = require("./entity-column-element");
+const entity_object_element_1 = require("./entity-object-element");
+const entity_association_element_1 = require("./entity-association-element");
+const serialize_element_1 = require("../util/serialize-element");
+const orm_helper_1 = require("../util/orm.helper");
+class EntityModel {
+    constructor(ctor) {
+        this.ctor = ctor;
+        this.elements = new Map();
+        this.indexes = [];
+        this.foreignKeys = [];
+        this.eventListeners = [];
+        this.name = ctor.name;
+    }
+    get elementKeys() {
+        if (!(this._elementKeys && this.hasOwnProperty('_elementKeys')))
+            this._elementKeys = Array.from(this.elements.keys());
+        return this._elementKeys;
+    }
+    getElement(name) {
+        if (!name)
+            return;
+        return this.elements.get(name.toLowerCase());
+    }
+    getColumnElement(name) {
+        if (!name)
+            return;
+        const prop = this.elements.get(name.toLowerCase());
+        return (0, orm_helper_1.isColumnElement)(prop) ? prop : undefined;
+    }
+    getColumnElementByFieldName(fieldName) {
+        if (!fieldName)
+            return;
+        fieldName = fieldName.toLowerCase();
+        for (const prop of this.elements.values()) {
+            if ((0, orm_helper_1.isColumnElement)(prop) && prop.fieldName.toLowerCase() === fieldName)
+                return prop;
+        }
+    }
+    getObjectElement(name) {
+        if (!name)
+            return;
+        const col = this.elements.get(name.toLowerCase());
+        return (0, orm_helper_1.isObjectElement)(col) ? col : undefined;
+    }
+    getAssociationElement(name) {
+        if (!name)
+            return;
+        const col = this.elements.get(name.toLowerCase());
+        return (0, orm_helper_1.isAssociationElement)(col) ? col : undefined;
+    }
+    defineColumnElement(propertyKey, options) {
+        let prop = this.getElement(propertyKey);
+        if (!prop || !(0, orm_helper_1.isColumnElement)(prop)) {
+            prop = new entity_column_element_1.EntityColumnElement(this, propertyKey, options);
+            if (!prop.type) {
+                const typ = Reflect.getMetadata("design:type", this.ctor.prototype, propertyKey);
+                if (typ === Array) {
+                    prop.type = String;
+                    prop.isArray = true;
+                }
+                else
+                    prop.type = typ;
+            }
+            if (!prop.dataType) {
+                if (prop.type === Boolean)
+                    prop.dataType = builder_1.DataType.BOOL;
+                else if (prop.type === String)
+                    prop.dataType = builder_1.DataType.VARCHAR;
+                else if (prop.type === Number)
+                    prop.dataType = builder_1.DataType.NUMBER;
+                else if (prop.type === Date)
+                    prop.dataType = builder_1.DataType.TIMESTAMP;
+                else if (prop.type === Array) {
+                    prop.dataType = builder_1.DataType.VARCHAR;
+                    prop.isArray = true;
+                }
+                else if (prop.type === Buffer)
+                    prop.dataType = builder_1.DataType.BINARY;
+            }
+            if (options?.isArray)
+                prop.isArray = true;
+            if (!this.elements.has(propertyKey.toLowerCase()))
+                this.elementKeys.push(propertyKey);
+            this.elements.set(propertyKey.toLowerCase(), prop);
+        }
+        else if (options)
+            prop.assign(options);
+        return prop;
+    }
+    defineAssociationElement(propertyKey, association) {
+        const prop = new entity_association_element_1.EntityAssociationElement(this, propertyKey, association);
+        let l = association;
+        let i = 1;
+        while (l) {
+            l.name = this.name + '.' + propertyKey + '#' + (i++);
+            l = l.next;
+        }
+        if (!this.elements.has(propertyKey.toLowerCase()))
+            this.elementKeys.push(propertyKey);
+        this.elements.set(propertyKey.toLowerCase(), prop);
+        return prop;
+    }
+    defineObjectElement(propertyKey, type) {
+        type = type || Reflect.getMetadata("design:type", this.ctor.prototype, propertyKey);
+        if (typeof type !== 'function')
+            throw new Error('"type" must be defined');
+        let prop = this.getElement(propertyKey);
+        if (!prop || !(0, orm_helper_1.isObjectElement)(prop)) {
+            prop = new entity_object_element_1.EntityObjectElement(this, propertyKey, type);
+            if (!this.elements.has(propertyKey.toLowerCase()))
+                this.elementKeys.push(propertyKey);
+            this.elements.set(propertyKey.toLowerCase(), prop);
+        }
+        return prop;
+    }
+    setPrimaryIndex(column, options) {
+        this.primaryIndex = new index_meta_1.IndexMeta(this, column, options);
+        this.primaryIndex.unique = true;
+    }
+    addIndex(column, options) {
+        this.indexes.push(new index_meta_1.IndexMeta(this, column, options));
+    }
+    addForeignKey(propertyKey, target, targetKey) {
+        const fk = new association_1.Association(this.name + '.' + propertyKey, {
+            source: this.ctor,
+            sourceKey: propertyKey,
+            target,
+            targetKey
+        });
+        this.foreignKeys.push(fk);
+    }
+    before(event, fn) {
+        this.eventListeners.push({ event: 'before-' + event, fn });
+    }
+    after(event, fn) {
+        this.eventListeners.push({ event: 'after-' + event, fn });
+    }
+    getPrimaryIndexColumns() {
+        const out = [];
+        if (this.primaryIndex) {
+            for (const k of this.primaryIndex.columns) {
+                const col = this.getColumnElement(k);
+                if (!col)
+                    throw new Error(`Data column "${k}" in primary index of ${this.name} does not exists`);
+                out.push(col);
+            }
+        }
+        return out;
+    }
+    getElementNames(fn) {
+        const out = [];
+        for (const k of this.elementKeys) {
+            const el = this.getElement(k);
+            if (el && (!fn || fn(el)))
+                out.push(k);
+        }
+        return out;
+    }
+    getColumnNames() {
+        return this.getElementNames(orm_helper_1.isColumnElement);
+    }
+    getObjectElementNames() {
+        return this.getElementNames(orm_helper_1.isObjectElement);
+    }
+    getAssociationElementNames() {
+        return this.getElementNames(orm_helper_1.isAssociationElement);
+    }
+    getNonAssociationElementNames() {
+        return this.getElementNames(x => !(0, orm_helper_1.isAssociationElement)(x));
+    }
+    getInsertColumnNames() {
+        const out = [];
+        for (const k of this.elementKeys) {
+            const col = this.getElement(k);
+            if ((0, orm_helper_1.isColumnElement)(col) && !col.noInsert)
+                out.push(k);
+        }
+        return out;
+    }
+    getUpdateColumnNames() {
+        const out = [];
+        for (const k of this.elementKeys) {
+            const col = this.getElement(k);
+            if ((0, orm_helper_1.isColumnElement)(col) && !col.noUpdate)
+                out.push(k);
+        }
+        return out;
+    }
+    async getForeignKeyFor(t) {
+        for (const f of this.foreignKeys) {
+            if (await f.resolveTarget() === t)
+                return f;
+        }
+    }
+    static get(ctor) {
+        return ctor[orm_const_1.ENTITY_DEFINITION_KEY];
+    }
+    static hasOwn(ctor) {
+        return ctor.hasOwnProperty(orm_const_1.ENTITY_DEFINITION_KEY);
+    }
+    static attachTo(ctor) {
+        const own = this.hasOwn(ctor) ? this.get(ctor) : undefined;
+        if (own)
+            return own;
+        const current = this.get(ctor);
+        const entity = new EntityModel(ctor);
+        Object.defineProperty(ctor, orm_const_1.ENTITY_DEFINITION_KEY, {
+            value: entity,
+            enumerable: false
+        });
+        // Merge base entity columns into this one
+        if (current) {
+            entity.tableName = current.tableName;
+            for (const k of current.elementKeys) {
+                const col = current.elements.get(k.toLowerCase());
+                if (col) {
+                    entity.elementKeys.push(k);
+                    entity.elements.set(k.toLowerCase(), col);
+                }
+            }
+            for (const fk of current.foreignKeys) {
+                const newFk = new association_1.Association(fk.name, { ...fk, source: ctor });
+                entity.foreignKeys.push(newFk);
+            }
+            for (const idx of current.indexes) {
+                const newIdx = new index_meta_1.IndexMeta(entity, idx.columns, idx);
+                entity.indexes.push(newIdx);
+            }
+            entity.eventListeners.push(...current.eventListeners);
+            if (current.primaryIndex)
+                entity.setPrimaryIndex([...current.primaryIndex.columns]);
+        }
+        ctor.prototype.toJSON = function () {
+            const obj = {};
+            const elementKeys = entity.elementKeys;
+            const l = elementKeys.length;
+            let key;
+            let v;
+            for (let i = 0; i < l; i++) {
+                key = elementKeys[i];
+                v = this[key];
+                if (v === undefined)
+                    continue;
+                const col = entity.getElement(key);
+                if (col)
+                    obj[key] = (0, serialize_element_1.serializeColumn)(col, v);
+            }
+            return obj;
+        };
+        return entity;
+    }
+    static getElementNames(ctor) {
+        const meta = this.get(ctor);
+        return meta && [...meta.elementKeys];
+    }
+    static getColumnNames(ctor) {
+        const meta = this.get(ctor);
+        if (meta)
+            return meta.getColumnNames();
+    }
+    static getAssociationElementNames(ctor) {
+        const meta = this.get(ctor);
+        if (meta)
+            return meta.getAssociationElementNames();
+    }
+    static getNonAssociationElementNames(ctor) {
+        const meta = this.get(ctor);
+        if (meta)
+            return meta.getNonAssociationElementNames();
+    }
+    static getObjectElementNames(ctor) {
+        const meta = this.get(ctor);
+        if (meta)
+            return meta.getObjectElementNames();
+    }
+    static getInsertColumnNames(ctor) {
+        const meta = this.get(ctor);
+        if (meta)
+            return meta.getInsertColumnNames();
+    }
+    static getUpdateColumnNames(ctor) {
+        const meta = this.get(ctor);
+        if (meta)
+            return meta.getUpdateColumnNames();
+    }
+}
+exports.EntityModel = EntityModel;

package/dist/orm/model/entity-object-element.d.ts

@@ -0,0 +1,12 @@
+import { ElementKind, TypeThunk, DataPropertyOptions } from '../orm.type';
+import { AbstractEntityelement } from './abstract-entityelement';
+import { EntityModel } from './entity-model';
+export declare class EntityObjectElement extends AbstractEntityelement {
+    kind: ElementKind;
+    type: TypeThunk;
+    fieldNamePrefix?: string;
+    fieldNameSuffix?: string;
+    constructor(entity: EntityModel, name: string, type: TypeThunk);
+    resolveType(): Promise<EntityModel>;
+    assign(options: DataPropertyOptions): void;
+}

package/dist/orm/model/entity-object-element.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityObjectElement = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const abstract_entityelement_1 = require("./abstract-entityelement");
+const orm_helper_1 = require("../util/orm.helper");
+class EntityObjectElement extends abstract_entityelement_1.AbstractEntityelement {
+    constructor(entity, name, type) {
+        super(entity, name);
+        this.kind = 'object';
+        this.type = type;
+    }
+    async resolveType() {
+        const typ = await (0, orm_helper_1.resolveEntityMeta)(this.type);
+        if (typ)
+            return typ;
+        throw new Error(`Can't resolve type of ${this.entity.name}.${this.name}`);
+    }
+    assign(options) {
+        Object.assign(this, lodash_1.default.omit(options, ['entity', 'name', 'kind']));
+    }
+}
+exports.EntityObjectElement = EntityObjectElement;

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

@@ -0,0 +1,9 @@
+import { EntityModel } from './entity-model';
+import { IndexOptions } from '../orm.type';
+export declare class IndexMeta {
+    entity: EntityModel;
+    columns: string[];
+    name?: string;
+    unique?: boolean;
+    constructor(entity: EntityModel, column: string | string[], options?: IndexOptions);
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexMeta = void 0;
+class IndexMeta {
+    constructor(entity, column, options) {
+        this.entity = entity;
+        this.columns = Array.isArray(column) ? column : [column];
+        if (options) {
+            if (options.name)
+                this.name = options.name;
+            if (options.unique)
+                this.unique = options.unique;
+        }
+    }
+}
+exports.IndexMeta = IndexMeta;