@sqb/connect 4.0.7 → 4.0.10

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

@@ -1,187 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RowConverter = void 0;
-const builder_1 = require("@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;
-};
-class RowConverter {
-    constructor(resultType, parent) {
-        this.resultType = resultType;
-        this.parent = parent;
-        this._properties = {};
-    }
-    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 elementKeys = this.keys;
-        const elementLen = elementKeys.length;
-        let result;
-        for (let elIdx = 0; elIdx < elementLen; elIdx++) {
-            const elKey = elementKeys[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 === builder_1.DataType.JSON && typeof v === 'string')
-                            v = JSON.parse(v);
-                        result[elKey] = v;
-                    }
-                }
-            }
-            else if (isNestedProperty(prop)) {
-                // One2Many Eager element
-                // 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 elements requested');
-        if (this.parent)
-            this.parent._checkCircularDep(t);
-    }
-}
-exports.RowConverter = RowConverter;

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

@@ -1,22 +0,0 @@
-import { EntityModel } from '../model/entity-model';
-import { Repository } from '../repository.class';
-import { SqbConnection } from '../../client/SqbConnection';
-export declare type UpdateCommandArgs = {
-    entity: EntityModel;
-    connection: SqbConnection;
-    values: any;
-} & Repository.UpdateAllOptions;
-declare type UpdateCommandContext = {
-    entity: EntityModel;
-    queryParams: any;
-    queryValues: any;
-    queryFilter: any[];
-    colCount: number;
-};
-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>;
-}
-export {};

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

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateCommand = void 0;
-const builder_1 = require("@sqb/builder");
-const command_helper_1 = require("./command.helper");
-const orm_helper_1 = require("../util/orm.helper");
-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 = (0, builder_1.Update)(tableName + ' as T', ctx.queryValues)
-            .where(...ctx.queryFilter);
-        const qr = await args.connection.execute(query, {
-            params: args.params ? [...args.params, ctx.queryParams] : ctx.queryParams,
-            objectRows: false,
-            cursor: false
-        });
-        return qr.rowsAffected || 0;
-    }
-    static async _prepareFilter(ctx, filter) {
-        if (filter) {
-            const where = (0, builder_1.And)();
-            await (0, command_helper_1.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 entity.elements.values()) {
-            v = values[col.name];
-            if (v === undefined)
-                continue;
-            if ((0, orm_helper_1.isColumnElement)(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;
-                col.checkEnumValue(v);
-                const fieldName = prefix + col.fieldName + suffix;
-                const k = '$input_' + fieldName;
-                ctx.queryValues[fieldName] = (0, builder_1.Param)({
-                    name: k,
-                    dataType: col.dataType,
-                    isArray: col.isArray
-                });
-                ctx.queryParams[k] = v;
-                ctx.colCount++;
-            }
-            else if (v != null && (0, orm_helper_1.isObjectElement)(col)) {
-                const type = await col.resolveType();
-                await this._prepareParams(ctx, type, v, col.fieldNamePrefix, col.fieldNameSuffix);
-            }
-        }
-    }
-}
-exports.UpdateCommand = UpdateCommand;

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

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

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

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Column = void 0;
-const entity_model_1 = require("../model/entity-model");
-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);
-    };
-}
-exports.Column = Column;

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

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

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Embedded = void 0;
-const entity_model_1 = require("../model/entity-model");
-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;
-    };
-}
-exports.Embedded = Embedded;

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

@@ -1,6 +0,0 @@
-import { EntityModel } from '../model/entity-model';
-import { EntityConfig } from '../orm.type';
-export declare function Entity(options?: EntityConfig | string): ClassDecorator;
-export declare namespace Entity {
-    function getMetadata(ctor: Function): EntityModel | undefined;
-}

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

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Entity = void 0;
-const entity_model_1 = require("../model/entity-model");
-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);
-        entity.tableName = tableName || target.name;
-        if (opts.schema)
-            entity.schema = opts.schema;
-        if (opts.comment)
-            entity.comment = opts.comment;
-    };
-}
-exports.Entity = Entity;
-(function (Entity) {
-    function getMetadata(ctor) {
-        return entity_model_1.EntityModel.get(ctor);
-    }
-    Entity.getMetadata = getMetadata;
-})(Entity = exports.Entity || (exports.Entity = {}));

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

@@ -1,6 +0,0 @@
-export declare function BeforeInsert(): PropertyDecorator;
-export declare function BeforeUpdate(): PropertyDecorator;
-export declare function BeforeDestroy(): PropertyDecorator;
-export declare function AfterInsert(): PropertyDecorator;
-export declare function AfterUpdate(): PropertyDecorator;
-export declare function AfterDestroy(): PropertyDecorator;

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

@@ -1,76 +0,0 @@
-"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");
-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 fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.before('insert', fn);
-    };
-}
-exports.BeforeInsert = BeforeInsert;
-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 fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.before('update', fn);
-    };
-}
-exports.BeforeUpdate = BeforeUpdate;
-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 fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.before('destroy', fn);
-    };
-}
-exports.BeforeDestroy = BeforeDestroy;
-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 fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.after('insert', fn);
-    };
-}
-exports.AfterInsert = AfterInsert;
-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 fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.after('update', fn);
-    };
-}
-exports.AfterUpdate = AfterUpdate;
-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 fn = target.constructor.prototype[propertyKey];
-        if (typeof fn !== 'function')
-            throw new Error('Property must be a function');
-        entity.after('destroy', fn);
-    };
-}
-exports.AfterDestroy = AfterDestroy;

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

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

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForeignKey = void 0;
-const entity_model_1 = require("../model/entity-model");
-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);
-    };
-}
-exports.ForeignKey = ForeignKey;

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

@@ -1,3 +0,0 @@
-import { IndexOptions } from '../orm.type';
-export declare function Index(fields: string | string[], options?: IndexOptions): ClassDecorator;
-export declare function Index(options?: IndexOptions): PropertyDecorator;

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

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Index = void 0;
-const entity_model_1 = require("../model/entity-model");
-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;
-        }
-        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);
-    };
-}
-exports.Index = Index;

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

@@ -1,23 +0,0 @@
-import { TypeThunk } from '../orm.type';
-import { LinkChain } from '../model/link-chain';
-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;
-export declare function LinkFromOne(type?: TypeThunk, targetKey?: string, sourceKey?: string): PropertyDecorator;
-export declare function LinkFromMany(type?: TypeThunk, targetKey?: string, sourceKey?: string): PropertyDecorator;
-/**
- * Crates an Link Chain object
- */
-export declare function linkToOne<T>(type: TypeThunk<T>, targetKey?: keyof T, sourceKey?: string): LinkChain<T>;
-/**
- * Crates an Link Chain object
- */
-export declare function linkToMany<T>(type: TypeThunk<T>, targetKey?: keyof T, sourceKey?: string): LinkChain<T>;
-/**
- * Crates an Link Chain object
- */
-export declare function linkFromOne<T>(type: TypeThunk<T>, targetKey?: keyof T, sourceKey?: string): LinkChain<T>;
-/**
- * Crates an Link Chain object
- */
-export declare function linkFromMany<T>(type: TypeThunk<T>, targetKey?: keyof T, sourceKey?: string): LinkChain<T>;

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

@@ -1,88 +0,0 @@
-"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 link_chain_1 = require("../model/link-chain");
-function Link(chain) {
-    return (target, propertyKey) => {
-        if (typeof propertyKey !== 'string')
-            throw new Error('You can define a column for only string properties');
-        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);
-        // @ts-ignore
-        // noinspection JSConstantReassignment
-        chain.first.source = entity.ctor;
-        entity.defineAssociationElement(propertyKey, chain.first);
-    };
-}
-exports.Link = Link;
-function LinkToOne(type, targetKey, sourceKey) {
-    return (target, propertyKey) => {
-        type = type || Reflect.getMetadata("design:type", target, propertyKey);
-        if (!type || type === Array)
-            throw new Error('You must provide "type"');
-        const chain = linkToOne(type, targetKey, sourceKey);
-        Link(chain)(target, propertyKey);
-    };
-}
-exports.LinkToOne = LinkToOne;
-function LinkToMany(type, targetKey, sourceKey) {
-    return (target, propertyKey) => {
-        type = type || Reflect.getMetadata("design:type", target, propertyKey);
-        if (!type || type === Array)
-            throw new Error('You must provide "type"');
-        const chain = linkToMany(type, targetKey, sourceKey);
-        Link(chain)(target, propertyKey);
-    };
-}
-exports.LinkToMany = LinkToMany;
-function LinkFromOne(type, targetKey, sourceKey) {
-    return (target, propertyKey) => {
-        type = type || Reflect.getMetadata("design:type", target, propertyKey);
-        if (!type || type === Array)
-            throw new Error('You must provide "type"');
-        const chain = linkFromOne(type, targetKey, sourceKey);
-        Link(chain)(target, propertyKey);
-    };
-}
-exports.LinkFromOne = LinkFromOne;
-function LinkFromMany(type, targetKey, sourceKey) {
-    return (target, propertyKey) => {
-        type = type || Reflect.getMetadata("design:type", target, propertyKey);
-        if (!type || type === Array)
-            throw new Error('You must provide "type"');
-        const chain = linkFromMany(type, targetKey, sourceKey);
-        Link(chain)(target, propertyKey);
-    };
-}
-exports.LinkFromMany = LinkFromMany;
-/**
- * Crates an Link Chain object
- */
-function linkToOne(type, targetKey, sourceKey) {
-    return new link_chain_1.LinkChain(type, 'to', targetKey, sourceKey);
-}
-exports.linkToOne = linkToOne;
-/**
- * Crates an Link Chain object
- */
-function linkToMany(type, targetKey, sourceKey) {
-    return new link_chain_1.LinkChain(type, 'to-many', targetKey, sourceKey);
-}
-exports.linkToMany = linkToMany;
-/**
- * Crates an Link Chain object
- */
-function linkFromOne(type, targetKey, sourceKey) {
-    return new link_chain_1.LinkChain(type, 'from', targetKey, sourceKey);
-}
-exports.linkFromOne = linkFromOne;
-/**
- * Crates an Link Chain object
- */
-function linkFromMany(type, targetKey, sourceKey) {
-    return new link_chain_1.LinkChain(type, 'from-many', targetKey, sourceKey);
-}
-exports.linkFromMany = linkFromMany;

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

@@ -1,3 +0,0 @@
-import { IndexOptions } from '../orm.type';
-export declare function PrimaryKey(fields: string | string[], options?: IndexOptions): ClassDecorator;
-export declare function PrimaryKey(options?: IndexOptions): PropertyDecorator;

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

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrimaryKey = void 0;
-const entity_model_1 = require("../model/entity-model");
-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);
-            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);
-    };
-}
-exports.PrimaryKey = PrimaryKey;

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

@@ -1,3 +0,0 @@
-import { ColumnTransformFunction } from '../orm.type';
-export declare function Parse(fn: ColumnTransformFunction): PropertyDecorator;
-export declare function Serialize(fn: ColumnTransformFunction): PropertyDecorator;