@sqb/connect 4.2.1 → 4.5.1

package/{dist → esm}/orm/commands/row-converter.d.ts

@@ -1,10 +1,10 @@
 import { Type } from 'ts-gems';
 import { DataType } from '@sqb/builder';
-import type { FieldInfoMap } from '../../client/FieldInfoMap';
-import { SqbConnection } from '../../client/SqbConnection';
-import { ColumnTransformFunction } from '../orm.type';
-import type { Repository } from '../repository.class';
-import type { FindCommand } from './find.command';
+import type { FieldInfoMap } from '../../client/field-info-map';
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { ColumnTransformFunction } from '../orm.type.js';
+import type { Repository } from '../repository.class.js';
+import type { FindCommand } from './find.command.js';
 export interface ValueProperty {
     fieldAlias: string;
     dataType?: DataType;

package/esm/orm/commands/row-converter.js

@@ -0,0 +1,186 @@
+import { DataType } from '@sqb/builder';
+const isValueProperty = (prop) => {
+    return prop.fieldAlias && !prop.converter;
+};
+const isObjectProperty = (prop) => {
+    return prop.converter && !prop.findCommand;
+};
+const isNestedProperty = (prop) => {
+    return prop.converter && prop.findCommand;
+};
+export class RowConverter {
+    resultType;
+    parent;
+    _properties = {};
+    _propertyKeys;
+    constructor(resultType, parent) {
+        this.resultType = resultType;
+        this.parent = parent;
+    }
+    addValueProperty(args) {
+        this._propertyKeys = undefined;
+        const item = {
+            fieldAlias: args.fieldAlias,
+            dataType: args.dataType,
+            parse: args.parse
+        };
+        this._properties[args.name] = item;
+        return item;
+    }
+    addObjectProperty(args) {
+        this._checkCircularDep(args.type);
+        this._propertyKeys = undefined;
+        const converter = new RowConverter(args.type, this);
+        const item = {
+            converter,
+            type: args.type
+        };
+        this._properties[args.name] = item;
+        return item;
+    }
+    addNestedProperty(args) {
+        this._checkCircularDep(args.type);
+        const converter = new RowConverter(args.type, this);
+        const item = {
+            converter,
+            type: args.type,
+            parentField: args.parentField,
+            keyField: args.keyField,
+            findCommand: args.findCommand,
+            sort: args.sort,
+            paramValues: []
+        };
+        this._properties[args.name] = item;
+        return item;
+    }
+    get keys() {
+        if (!this._propertyKeys)
+            this._propertyKeys = Object.keys(this._properties);
+        return this._propertyKeys;
+    }
+    async transform(connection, fields, rows, onTransform) {
+        const rowLen = rows.length;
+        const result = [];
+        for (let rowIdx = 0; rowIdx < rowLen; rowIdx++) {
+            const row = rows[rowIdx];
+            const o = (await this._rowToObject(connection, fields, row)) || {};
+            if (onTransform)
+                onTransform(fields, row, o);
+            result.push(o);
+        }
+        if (!this.keys)
+            return result;
+        await this._iterateForNested(this, connection, fields, rows, result);
+        // Return only non empty objects
+        return result.filter(x => !!x);
+    }
+    _rowToObject(executor, fields, row) {
+        // Cache keys for better performance
+        const fieldKeys = this.keys;
+        const fieldsLen = fieldKeys.length;
+        let result;
+        for (let elIdx = 0; elIdx < fieldsLen; elIdx++) {
+            const elKey = fieldKeys[elIdx];
+            const prop = this._properties[elKey];
+            if (isValueProperty(prop)) {
+                const field = fields.get(prop.fieldAlias);
+                if (field) {
+                    let v = row[field.index];
+                    if (typeof prop.parse === 'function')
+                        v = prop.parse(v, elKey);
+                    if (v != null) {
+                        result = result || {};
+                        if (prop.dataType === DataType.JSON && typeof v === 'string')
+                            v = JSON.parse(v);
+                        result[elKey] = v;
+                    }
+                }
+            }
+            else if (isNestedProperty(prop)) {
+                // One2Many Eager field
+                // Keep a list of key field/value pairs to fetch rows for eager relation
+                const _params = prop.paramValues;
+                const f = fields.get(prop.parentField);
+                const v = f && row[f.index];
+                if (v != null && !_params.includes(v))
+                    _params.push(v);
+            }
+            else if (isObjectProperty(prop)) {
+                const v = prop.converter._rowToObject(executor, fields, row);
+                if (v != null) {
+                    result = result || {};
+                    result[elKey] = v;
+                }
+            }
+        }
+        if (result)
+            Object.setPrototypeOf(result, this.resultType.prototype);
+        return result;
+    }
+    async _iterateForNested(node, connection, fields, rows, result) {
+        // Fetch one-2-many related rows and merge with result rows
+        const keys = node.keys;
+        const propertyLen = keys.length;
+        const promises = [];
+        for (let propIdx = 0; propIdx < propertyLen; propIdx++) {
+            const propKey = keys[propIdx];
+            const prop = node._properties[propKey];
+            if (isNestedProperty(prop)) {
+                if (!(prop.paramValues && prop.paramValues.length))
+                    continue;
+                const resultType = this.resultType;
+                const promise = async function (p) {
+                    const findCommand = p.findCommand;
+                    let fld;
+                    const map = new Map();
+                    const r = await findCommand.execute({
+                        connection,
+                        limit: findCommand.maxEagerFetch + 1,
+                        params: { [p.parentField]: p.paramValues },
+                        onTransformRow: (_fields, row, obj) => {
+                            fld = fld || _fields.get('' + p.keyField);
+                            const keyValue = fld && row[fld.index];
+                            if (keyValue != null) {
+                                let arr = map.get(keyValue);
+                                if (!arr) {
+                                    arr = [];
+                                    map.set(keyValue, arr);
+                                }
+                                arr.push(obj);
+                            }
+                        }
+                    });
+                    if (r.length > findCommand.maxEagerFetch)
+                        throw new Error(`Number of returning rows for "${propKey}" exceeds maxEagerFetch limit`);
+                    for (let i = 0; i < result.length; i++) {
+                        const row = rows[i];
+                        let obj = result[i];
+                        if (!obj) {
+                            obj = {};
+                            Object.setPrototypeOf(result, resultType.prototype);
+                        }
+                        const f = fields.get('' + p.parentField);
+                        const keyValue = f && row[f.index];
+                        if (keyValue != null) {
+                            const arr = map.get(keyValue);
+                            if (arr) {
+                                obj[propKey] = arr;
+                            }
+                        }
+                    }
+                }(prop);
+                promises.push(promise);
+            }
+            else if (isObjectProperty(prop)) {
+                promises.push(this._iterateForNested(prop.converter, connection, fields, rows, result));
+            }
+        }
+        await Promise.all(promises);
+    }
+    _checkCircularDep(t) {
+        if (this.resultType === t)
+            throw new Error('Circular fields requested');
+        if (this.parent)
+            this.parent._checkCircularDep(t);
+    }
+}

package/{dist → esm}/orm/commands/update.command.d.ts

@@ -1,6 +1,6 @@
-import { SqbConnection } from '../../client/SqbConnection';
-import { EntityMetadata } from '../model/entity-metadata';
-import { Repository } from '../repository.class';
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { Repository } from '../repository.class.js';
 export declare type UpdateCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;

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

@@ -0,0 +1,80 @@
+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 {
+    // istanbul ignore next
+    constructor() {
+        throw new Error('This class is abstract');
+    }
+    static async execute(args) {
+        const { entity } = args;
+        const tableName = entity.tableName;
+        if (!tableName)
+            throw new Error(`${entity.ctor.name} is not decorated with @Entity decorator`);
+        // Create a context
+        const ctx = {
+            entity,
+            queryParams: {},
+            queryValues: {},
+            queryFilter: [],
+            colCount: 0,
+        };
+        // Prepare
+        await this._prepareParams(ctx, entity, args.values);
+        if (!ctx.colCount)
+            return 0;
+        if (args.filter)
+            await this._prepareFilter(ctx, args.filter);
+        const query = 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,
+            cursor: false
+        });
+        return qr.rowsAffected || 0;
+    }
+    static async _prepareFilter(ctx, filter) {
+        if (filter) {
+            const where = And();
+            await prepareFilter(ctx.entity, filter, where);
+            ctx.queryFilter.push(...where._items);
+        }
+    }
+    static async _prepareParams(ctx, entity, values, prefix, suffix) {
+        let v;
+        prefix = prefix || '';
+        suffix = suffix || '';
+        for (const col of Object.values(entity.fields)) {
+            v = values[col.name];
+            if (v === undefined)
+                continue;
+            if (isColumnField(col)) {
+                if (col.noUpdate)
+                    continue;
+                if (typeof col.serialize === 'function')
+                    v = col.serialize(v, col.name);
+                if (v === null && col.notNull)
+                    throw new Error(`${entity.name}.${col.name} is required and can't be null`);
+                if (v === undefined)
+                    continue;
+                ColumnFieldMetadata.checkEnumValue(col, v);
+                const fieldName = prefix + col.fieldName + suffix;
+                const k = '$input_' + fieldName;
+                ctx.queryValues[fieldName] = Param({
+                    name: k,
+                    dataType: col.dataType,
+                    isArray: col.isArray
+                });
+                ctx.queryParams[k] = v;
+                ctx.colCount++;
+            }
+            else if (v != null && isEmbeddedField(col)) {
+                const type = await EmbeddedFieldMetadata.resolveType(col);
+                await this._prepareParams(ctx, type, v, col.fieldNamePrefix, col.fieldNameSuffix);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import { DataType } from '@sqb/builder';
+import { ColumnFieldOptions } from '../model/column-field-metadata.js';
+export declare function Column(type?: DataType): PropertyDecorator;
+export declare function Column(options?: ColumnFieldOptions): PropertyDecorator;

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

@@ -0,0 +1,19 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+export function Column(arg0) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new Error('Symbol properties are not accepted');
+        const options = (typeof arg0 === 'string' ? { dataType: arg0 } : arg0) || {};
+        const entity = EntityMetadata.define(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;
+        }
+        EntityMetadata.defineColumnField(entity, propertyKey, options);
+    };
+}

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

@@ -0,0 +1,3 @@
+import { EmbeddedFieldOptions } from '../model/embedded-field-metadata.js';
+import { TypeThunk } from '../orm.type.js';
+export declare function Embedded(type?: TypeThunk, options?: EmbeddedFieldOptions): PropertyDecorator;

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

@@ -0,0 +1,12 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+export 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);
+    };
+}

package/{dist → esm}/orm/decorators/entity.decorator.d.ts

@@ -1,28 +1,28 @@
 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';
+import { AssociationFieldMetadata } from '../model/association-field-metadata.js';
+import { ColumnFieldMetadata } from '../model/column-field-metadata.js';
+import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
+import { AnyFieldMetadata, EntityMetadata, EntityOptions } from '../model/entity-metadata.js';
+import { IndexMetadata } from '../model/index-metadata.js';
 export declare function Entity(options?: EntityOptions | string): ClassDecorator;
 export declare namespace Entity {
     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 getField<T>(ctor: Type<T>, key: keyof T | string): Maybe<AnyFieldMetadata>;
+    function getColumnField<T>(ctor: Type<T>, key: keyof T | string): Maybe<ColumnFieldMetadata>;
+    function getEmbeddedField<T>(ctor: Type<T>, key: keyof T | string): Maybe<EmbeddedFieldMetadata>;
+    function getAssociationField<T>(ctor: Type<T>, key: keyof T | string): Maybe<AssociationFieldMetadata>;
+    function getColumnFieldByFieldName(ctor: Type, fieldName: string): Maybe<ColumnFieldMetadata>;
+    function find(ctor: Type, predicate: (el: AnyFieldMetadata) => boolean): Maybe<AnyFieldMetadata>;
+    function getFieldNames(ctor: Type, filter?: (el: AnyFieldMetadata) => boolean): string[];
+    function getColumnFieldNames(ctor: Type): string[];
+    function getEmbeddedFieldNames(ctor: Type): string[];
+    function getAssociationFieldNames(ctor: Type): string[];
+    function getNonAssociationFieldNames(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 getPrimaryIndexColumns(ctor: Type): ColumnFieldMetadata[];
     function mixin<A, B>(derivedCtor: Type<A>, baseB: Type<B>): Type<A & B>;
     function mixin<A, B, C>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>): Type<A & B & C>;
     function mixin<A, B, C, D>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>): Type<A & B & C & D>;

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

@@ -0,0 +1,175 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { applyMixins } from '../util/apply-mixins.js';
+export 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);
+        entity.tableName = tableName || target.name;
+        if (opts.schema)
+            entity.schema = opts.schema;
+        if (opts.comment)
+            entity.comment = opts.comment;
+    };
+}
+(function (Entity) {
+    Entity.getMetadata = EntityMetadata.get;
+    Entity.getOwnMetadata = EntityMetadata.getOwn;
+    function getField(ctor, key) {
+        const model = EntityMetadata.get(ctor);
+        return model && EntityMetadata.getField(model, key);
+    }
+    Entity.getField = getField;
+    function getColumnField(ctor, key) {
+        const model = EntityMetadata.get(ctor);
+        return model && EntityMetadata.getColumnField(model, key);
+    }
+    Entity.getColumnField = getColumnField;
+    function getEmbeddedField(ctor, key) {
+        const model = EntityMetadata.get(ctor);
+        return model && EntityMetadata.getEmbeddedField(model, key);
+    }
+    Entity.getEmbeddedField = getEmbeddedField;
+    function getAssociationField(ctor, key) {
+        const model = EntityMetadata.get(ctor);
+        return model && EntityMetadata.getAssociationField(model, key);
+    }
+    Entity.getAssociationField = getAssociationField;
+    function getColumnFieldByFieldName(ctor, fieldName) {
+        const model = EntityMetadata.get(ctor);
+        return model && EntityMetadata.getColumnFieldByFieldName(model, fieldName);
+    }
+    Entity.getColumnFieldByFieldName = getColumnFieldByFieldName;
+    function find(ctor, predicate) {
+        const model = EntityMetadata.get(ctor);
+        return model && EntityMetadata.findField(model, predicate);
+    }
+    Entity.find = find;
+    function getFieldNames(ctor, filter) {
+        const model = EntityMetadata.get(ctor);
+        return (model && EntityMetadata.getFieldNames(model, filter)) || [];
+    }
+    Entity.getFieldNames = getFieldNames;
+    function getColumnFieldNames(ctor) {
+        const model = EntityMetadata.get(ctor);
+        return (model && EntityMetadata.getColumnFieldNames(model)) || [];
+    }
+    Entity.getColumnFieldNames = getColumnFieldNames;
+    function getEmbeddedFieldNames(ctor) {
+        const model = EntityMetadata.get(ctor);
+        return (model && EntityMetadata.getEmbeddedFieldNames(model)) || [];
+    }
+    Entity.getEmbeddedFieldNames = getEmbeddedFieldNames;
+    function getAssociationFieldNames(ctor) {
+        const model = EntityMetadata.get(ctor);
+        return (model && EntityMetadata.getAssociationFieldNames(model)) || [];
+    }
+    Entity.getAssociationFieldNames = getAssociationFieldNames;
+    function getNonAssociationFieldNames(ctor) {
+        const model = EntityMetadata.get(ctor);
+        return (model && EntityMetadata.getNonAssociationFieldNames(model)) || [];
+    }
+    Entity.getNonAssociationFieldNames = getNonAssociationFieldNames;
+    function getInsertColumnNames(ctor) {
+        const model = EntityMetadata.get(ctor);
+        return (model && EntityMetadata.getInsertColumnNames(model)) || [];
+    }
+    Entity.getInsertColumnNames = getInsertColumnNames;
+    function getUpdateColumnNames(ctor) {
+        const model = EntityMetadata.get(ctor);
+        return (model && EntityMetadata.getUpdateColumnNames(model)) || [];
+    }
+    Entity.getUpdateColumnNames = getUpdateColumnNames;
+    function getPrimaryIndex(ctor) {
+        const model = EntityMetadata.define(ctor);
+        return EntityMetadata.getPrimaryIndex(model);
+    }
+    Entity.getPrimaryIndex = getPrimaryIndex;
+    function getPrimaryIndexColumns(ctor) {
+        const model = EntityMetadata.define(ctor);
+        return 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);
+            if (srcMeta) {
+                const trgMeta = EntityMetadata.define(derivedCtor);
+                EntityMetadata.mixin(trgMeta, srcMeta);
+            }
+        }
+        return derivedCtor;
+    }
+    Entity.mixin = mixin;
+    function Pick(classRef, keys) {
+        const PickEntityClass = class {
+            constructor(...args) {
+                applyConstructorProperties(this, classRef, args);
+            }
+        };
+        const pickKeys = keys.map(x => x.toLowerCase());
+        const filter = (k) => pickKeys.includes(k.toLowerCase());
+        applyMixins(PickEntityClass, classRef, filter);
+        const srcMeta = EntityMetadata.get(classRef);
+        if (srcMeta) {
+            const trgMeta = EntityMetadata.define(PickEntityClass);
+            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());
+        applyMixins(OmitEntityClass, classRef, filter);
+        const srcMeta = EntityMetadata.get(classRef);
+        if (srcMeta) {
+            const trgMeta = EntityMetadata.define(OmitEntityClass);
+            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) {
+            applyMixins(UnionClass, base);
+            const srcMeta = EntityMetadata.get(base);
+            if (srcMeta) {
+                const trgMeta = EntityMetadata.define(UnionClass);
+                EntityMetadata.mixin(trgMeta, srcMeta);
+            }
+        }
+        return UnionClass;
+    }
+    Entity.Union = Union;
+})(Entity || (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/esm/orm/decorators/events.decorator.js

@@ -0,0 +1,55 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+export 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 fn = target.constructor.prototype[propertyKey];
+        EntityMetadata.addEventListener(model, 'before-insert', fn);
+    };
+}
+export 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 fn = target.constructor.prototype[propertyKey];
+        EntityMetadata.addEventListener(model, 'before-update', fn);
+    };
+}
+export 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 fn = target.constructor.prototype[propertyKey];
+        EntityMetadata.addEventListener(model, 'before-destroy', fn);
+    };
+}
+export 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 fn = target.constructor.prototype[propertyKey];
+        EntityMetadata.addEventListener(model, 'after-insert', fn);
+    };
+}
+export 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 fn = target.constructor.prototype[propertyKey];
+        EntityMetadata.addEventListener(model, 'after-update', fn);
+    };
+}
+export 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 fn = target.constructor.prototype[propertyKey];
+        EntityMetadata.addEventListener(model, 'after-destroy', fn);
+    };
+}

package/{dist → esm}/orm/decorators/foreignkey.decorator.d.ts

@@ -1,2 +1,2 @@
-import { TypeThunk } from '../orm.type';
+import { TypeThunk } from '../orm.type.js';
 export declare function ForeignKey(type: TypeThunk, targetKey?: string): PropertyDecorator;

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

@@ -0,0 +1,9 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+export 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);
+    };
+}

package/{dist → esm}/orm/decorators/index.decorator.d.ts

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

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

@@ -0,0 +1,17 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+export 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 });
+        }
+        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] });
+    };
+}