@sqb/connect 4.0.7 → 4.0.10

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

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

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

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

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

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

@@ -1,28 +0,0 @@
-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>;
-}

package/dist/orm/model/association.js

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

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

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

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

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityColumnElement = void 0;
-const tslib_1 = require("tslib");
-require("reflect-metadata");
-const lodash_1 = (0, 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

@@ -1,59 +0,0 @@
-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;
-}