@sqb/connect 4.0.9 → 4.0.13

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

@@ -0,0 +1,82 @@
+"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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,14 @@
+"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

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

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

@@ -0,0 +1,17 @@
+"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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,23 @@
+"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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,76 @@
+"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

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

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

@@ -0,0 +1,13 @@
+"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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,22 @@
+"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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,88 @@
+"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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,23 @@
+"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

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

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

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

package/dist/orm/model/abstract-entityelement.d.ts

@@ -0,0 +1,8 @@
+import type { EntityModel } from './entity-model';
+import { ElementKind } from '../orm.type';
+export declare abstract class AbstractEntityelement {
+    readonly entity: EntityModel;
+    readonly name: string;
+    abstract kind: ElementKind;
+    protected constructor(entity: EntityModel, name: string);
+}

package/dist/orm/model/abstract-entityelement.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractEntityelement = void 0;
+class AbstractEntityelement {
+    constructor(entity, name) {
+        this.entity = entity;
+        this.name = name;
+    }
+}
+exports.AbstractEntityelement = AbstractEntityelement;

package/dist/orm/model/association-node.d.ts

@@ -0,0 +1,9 @@
+import { Association } from './association';
+export declare class AssociationNode extends Association {
+    prior?: AssociationNode;
+    next?: AssociationNode;
+    conditions?: any[];
+    getFirst(): AssociationNode;
+    getLast(): AssociationNode;
+    returnsMany(): boolean;
+}

package/dist/orm/model/association-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssociationNode = void 0;
+const association_1 = require("./association");
+class AssociationNode extends association_1.Association {
+    getFirst() {
+        let l = this;
+        while (l.prior)
+            l = l.prior;
+        return l;
+    }
+    getLast() {
+        let l = this;
+        while (l.next)
+            l = l.next;
+        return l;
+    }
+    returnsMany() {
+        const n = super.returnsMany();
+        if (n)
+            return n;
+        return !!(this.next && this.next.returnsMany());
+    }
+}
+exports.AssociationNode = AssociationNode;

package/dist/orm/model/association.d.ts

@@ -0,0 +1,28 @@
+import { AssociationKind, AssociationSettings, TypeThunk } from '../orm.type';
+import { EntityModel } from './entity-model';
+import { EntityColumnElement } from './entity-column-element';
+export declare class Association {
+    private _resolved?;
+    private _source?;
+    private _target?;
+    private _sourceKey?;
+    private _targetKey?;
+    private _sourceProperty?;
+    private _targetProperty?;
+    name: string;
+    readonly source: TypeThunk;
+    readonly target: TypeThunk;
+    readonly sourceKey?: string;
+    readonly targetKey?: string;
+    readonly kind?: AssociationKind;
+    constructor(name: string, args: AssociationSettings);
+    resolveSource(): Promise<EntityModel>;
+    resolveTarget(): Promise<EntityModel>;
+    resolveSourceKey(): Promise<string>;
+    resolveSourceProperty(): Promise<EntityColumnElement>;
+    resolveTargetKey(): Promise<string>;
+    resolveTargetProperty(): Promise<EntityColumnElement>;
+    get sourceBelongsToTarget(): boolean;
+    returnsMany(): boolean;
+    protected _resolveKeys(): Promise<void>;
+}