@sqb/connect 4.2.1 → 4.5.1

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

@@ -0,0 +1,13 @@
+import { AssociationFieldOptions } from '../model/association-field-metadata.js';
+import { TypeThunk } from '../orm.type.js';
+declare type LinkArgs<T> = {
+    sourceKey?: string;
+    targetKey?: keyof T;
+    where?: object | object[];
+};
+declare type LinkPropertyDecorator = PropertyDecorator & {
+    toOne<T>(type: TypeThunk<T>, args?: LinkArgs<T>): LinkPropertyDecorator;
+    toMany<T>(type: TypeThunk<T>, args?: LinkArgs<T>): LinkPropertyDecorator;
+};
+export declare function Link(options?: AssociationFieldOptions): LinkPropertyDecorator;
+export {};

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

@@ -0,0 +1,66 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { LinkChain } from '../model/link-chain.js';
+export function Link(options) {
+    let root;
+    let chain;
+    const fn = (target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError('Symbol properties are not allowed');
+        const reflectType = Reflect.getMetadata("design:type", target, propertyKey);
+        if (!root) {
+            if (reflectType === Array)
+                throw new TypeError(`Can't get type information while it is an array. Please define entity type`);
+            if (!EntityMetadata.get(reflectType))
+                throw new TypeError(`No entity metadata found for type "${reflectType}"`);
+            fn.toOne(reflectType);
+        }
+        if (reflectType !== Array && root.first.returnsMany())
+            throw new TypeError(`Link returns single instance however property type is an array`);
+        if (reflectType === Array && !root.first.returnsMany())
+            throw new TypeError(`Link returns array of instances however property type is not an array`);
+        const entity = EntityMetadata.define(target.constructor);
+        // @ts-ignore
+        // noinspection JSConstantReassignment
+        root.first.source = entity.ctor;
+        EntityMetadata.defineAssociationField(entity, propertyKey, root.first, options);
+    };
+    fn.toOne = (type, args) => {
+        if (chain) {
+            chain = chain.linkToOne(type, args?.targetKey, args?.sourceKey);
+            if (args?.where)
+                chain.where(args.where);
+            return fn;
+        }
+        root = linkToOne(type, args?.targetKey, args?.sourceKey);
+        chain = root;
+        if (args?.where)
+            chain.where(args.where);
+        return fn;
+    };
+    fn.toMany = (type, args) => {
+        if (chain) {
+            chain = chain.linkToMany(type, args?.targetKey, args?.sourceKey);
+            if (args?.where)
+                chain.where(args.where);
+            return fn;
+        }
+        root = linkToMany(type, args?.targetKey, args?.sourceKey);
+        chain = root;
+        if (args?.where)
+            chain.where(args.where);
+        return fn;
+    };
+    return fn;
+}
+/**
+ * Crates an Link Chain object
+ */
+function linkToOne(type, targetKey, sourceKey) {
+    return new LinkChain(type, targetKey, sourceKey);
+}
+/**
+ * Crates an Link Chain object
+ */
+function linkToMany(type, targetKey, sourceKey) {
+    return new LinkChain(type, targetKey, sourceKey, true);
+}

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

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

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

@@ -0,0 +1,20 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { Column } from './column.decorator.js';
+export 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 meta = EntityMetadata.define(target);
+            EntityMetadata.setPrimaryKeys(meta, 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 meta = EntityMetadata.define(target.constructor);
+        Column({ notNull: true })(target, propertyKey);
+        EntityMetadata.setPrimaryKeys(meta, propertyKey, arg0);
+    };
+}

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

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

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

@@ -0,0 +1,19 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+export function Parse(fn) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new Error('You can define a Column for only string properties');
+        const entity = EntityMetadata.define(target.constructor);
+        EntityMetadata.defineColumnField(entity, propertyKey)
+            .parse = fn;
+    };
+}
+export function Serialize(fn) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new Error('You can define a Column for only string properties');
+        const entity = EntityMetadata.define(target.constructor);
+        EntityMetadata.defineColumnField(entity, propertyKey)
+            .serialize = fn;
+    };
+}

package/esm/orm/model/association-field-metadata.d.ts

@@ -0,0 +1,12 @@
+import { AssociationNode } from './association-node.js';
+import { EntityMetadata } from './entity-metadata.js';
+import { FieldMetadata } from './field-metadata.js';
+export declare type AssociationFieldOptions = Partial<Omit<AssociationFieldMetadata, 'entity' | 'name' | 'kind' | 'association'>>;
+export interface AssociationFieldMetadata extends FieldMetadata {
+    readonly kind: 'association';
+    readonly association: AssociationNode;
+}
+export declare namespace AssociationFieldMetadata {
+    function create(entity: EntityMetadata, name: string, association: AssociationNode, options?: AssociationFieldOptions): AssociationFieldMetadata;
+    function assign(target: AssociationFieldMetadata, options: AssociationFieldOptions): void;
+}

package/esm/orm/model/association-field-metadata.js

@@ -0,0 +1,20 @@
+import _ from 'lodash';
+export var AssociationFieldMetadata;
+(function (AssociationFieldMetadata) {
+    function create(entity, name, association, options = {}) {
+        const result = {
+            kind: 'association',
+            entity,
+            name,
+            association
+        };
+        if (options)
+            AssociationFieldMetadata.assign(result, options);
+        return result;
+    }
+    AssociationFieldMetadata.create = create;
+    function assign(target, options) {
+        Object.assign(target, _.omit(options, ['entity', 'name', 'kind', 'association']));
+    }
+    AssociationFieldMetadata.assign = assign;
+})(AssociationFieldMetadata || (AssociationFieldMetadata = {}));

package/{dist → esm}/orm/model/association-node.d.ts

@@ -1,4 +1,4 @@
-import { Association } from './association';
+import { Association } from './association.js';
 export declare class AssociationNode extends Association {
     prior?: AssociationNode;
     next?: AssociationNode;

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

@@ -0,0 +1,24 @@
+import { Association } from './association.js';
+export class AssociationNode extends Association {
+    prior;
+    next;
+    conditions;
+    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());
+    }
+}

package/{dist → esm}/orm/model/association.d.ts

@@ -1,6 +1,6 @@
-import { AssociationKind, AssociationSettings, TypeThunk } from '../orm.type';
-import { ColumnElementMetadata } from './column-element-metadata';
-import { EntityMetadata } from './entity-metadata';
+import { AssociationSettings, TypeThunk } from '../orm.type.js';
+import { ColumnFieldMetadata } from './column-field-metadata.js';
+import { EntityMetadata } from './entity-metadata.js';
 export declare class Association {
     private _resolved?;
     private _source?;
@@ -14,15 +14,14 @@ export declare class Association {
     readonly target: TypeThunk;
     readonly sourceKey?: string;
     readonly targetKey?: string;
-    readonly kind?: AssociationKind;
+    readonly many: boolean;
     constructor(name: string, args: AssociationSettings);
     resolveSource(): Promise<EntityMetadata>;
     resolveTarget(): Promise<EntityMetadata>;
     resolveSourceKey(): Promise<string>;
-    resolveSourceProperty(): Promise<ColumnElementMetadata>;
+    resolveSourceProperty(): Promise<ColumnFieldMetadata>;
     resolveTargetKey(): Promise<string>;
-    resolveTargetProperty(): Promise<ColumnElementMetadata>;
-    get sourceBelongsToTarget(): boolean;
+    resolveTargetProperty(): Promise<ColumnFieldMetadata>;
     returnsMany(): boolean;
     protected _resolveKeys(): Promise<void>;
 }

package/esm/orm/model/association.js

@@ -0,0 +1,118 @@
+import { camelCase } from 'putil-varhelpers';
+import { resolveEntityMeta } from '../util/orm.helper.js';
+import { EntityMetadata } from './entity-metadata.js';
+export class Association {
+    _resolved;
+    _source; // cached value
+    _target; // cached value
+    _sourceKey; // cached value
+    _targetKey; // cached value
+    _sourceProperty;
+    _targetProperty;
+    name;
+    source;
+    target;
+    sourceKey;
+    targetKey;
+    many;
+    constructor(name, args) {
+        this.name = name;
+        this.source = args.source;
+        this.target = args.target;
+        this.sourceKey = args.sourceKey;
+        this.targetKey = args.targetKey;
+        this.many = !!args.many;
+    }
+    async resolveSource() {
+        this._source = await 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 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;
+    }
+    returnsMany() {
+        return this.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 EntityMetadata.getForeignKeyFor(source, 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 EntityMetadata.getForeignKeyFor(target, 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;
+                }
+            }
+            const master = source;
+            const detail = target;
+            let masterKey = sourceKey || '';
+            let detailKey = targetKey || '';
+            if (!detailKey) {
+                const primaryIndexColumns = EntityMetadata.getPrimaryIndexColumns(detail);
+                detailKey = primaryIndexColumns && primaryIndexColumns.length === 1 ?
+                    primaryIndexColumns[0].name : 'id';
+            }
+            if (!masterKey) {
+                // snake-case
+                masterKey = detail.name[0].toLowerCase() + detail.name.substring(1) + '_' + detailKey;
+                if (!EntityMetadata.getColumnField(master, masterKey))
+                    masterKey = camelCase(masterKey);
+            }
+            targetKey = detailKey;
+            sourceKey = masterKey;
+        }
+        this._targetProperty = EntityMetadata.getColumnField(target, targetKey);
+        if (!this._targetProperty)
+            throw new Error(`Can't determine target key of ${this.name}`);
+        this._sourceProperty = EntityMetadata.getColumnField(source, sourceKey);
+        if (!this._sourceProperty)
+            throw new Error(`Can't determine source key of ${this.name}`);
+        this._targetKey = targetKey;
+        this._sourceKey = sourceKey;
+    }
+}

package/{dist/orm/model/column-element-metadata.d.ts → esm/orm/model/column-field-metadata.d.ts}

@@ -1,9 +1,9 @@
 import { DataType } from '@sqb/builder';
-import type { ColumnAutoGenerationStrategy, ColumnTransformFunction, DefaultValueGetter, EnumValue, FieldValue } from '../orm.type';
-import { ElementMetadata } from './element-metadata';
-import type { EntityMetadata } from './entity-metadata';
-export declare type ColumnElementOptions = Partial<Omit<ColumnElementMetadata, 'entity' | 'name' | 'kind'>>;
-export interface ColumnElementMetadata extends ElementMetadata {
+import type { ColumnAutoGenerationStrategy, ColumnTransformFunction, DefaultValueGetter, EnumValue, FieldValue } from '../orm.type.js';
+import type { EntityMetadata } from './entity-metadata.js';
+import { FieldMetadata } from './field-metadata.js';
+export declare type ColumnFieldOptions = Partial<Omit<ColumnFieldMetadata, 'entity' | 'name' | 'kind'>>;
+export interface ColumnFieldMetadata extends FieldMetadata {
     readonly kind: 'column';
     /**
      Name of table field
@@ -11,7 +11,7 @@ export interface ColumnElementMetadata extends ElementMetadata {
     fieldName: string;
     /**
      JS type. String, Boolean, Person etc
-    */
+     */
     type?: Function;
     /**
      * Column data type
@@ -57,10 +57,6 @@ export interface ColumnElementMetadata extends ElementMetadata {
      * 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
      */
@@ -72,8 +68,8 @@ export interface ColumnElementMetadata extends ElementMetadata {
     parse?: ColumnTransformFunction;
     serialize?: ColumnTransformFunction;
 }
-export declare namespace ColumnElementMetadata {
-    function create(entity: EntityMetadata, name: string, options?: ColumnElementOptions): ColumnElementMetadata;
-    function assign(target: ColumnElementMetadata, options: ColumnElementOptions): void;
-    function checkEnumValue(col: ColumnElementMetadata, v: FieldValue): void;
+export declare namespace ColumnFieldMetadata {
+    function create(entity: EntityMetadata, name: string, options?: ColumnFieldOptions): ColumnFieldMetadata;
+    function assign(target: ColumnFieldMetadata, options: ColumnFieldOptions): void;
+    function checkEnumValue(col: ColumnFieldMetadata, v: FieldValue): void;
 }

package/esm/orm/model/column-field-metadata.js

@@ -0,0 +1,28 @@
+import _ from 'lodash';
+export var ColumnFieldMetadata;
+(function (ColumnFieldMetadata) {
+    function create(entity, name, options = {}) {
+        const result = {
+            kind: 'column',
+            entity,
+            name,
+            fieldName: name
+        };
+        if (options)
+            ColumnFieldMetadata.assign(result, options);
+        return result;
+    }
+    ColumnFieldMetadata.create = create;
+    function assign(target, options) {
+        Object.assign(target, _.omit(options, ['entity', 'name', 'kind']));
+    }
+    ColumnFieldMetadata.assign = assign;
+    function checkEnumValue(col, v) {
+        if (v === undefined || !col.enum || (v == null && !col.notNull))
+            return;
+        const enumKeys = Array.isArray(col.enum) ? col.enum : Object.keys(col.enum);
+        if (!enumKeys.includes(v))
+            throw new Error(`${col.entity.name}.${col.name} value must be one of (${enumKeys})`);
+    }
+    ColumnFieldMetadata.checkEnumValue = checkEnumValue;
+})(ColumnFieldMetadata || (ColumnFieldMetadata = {}));

package/esm/orm/model/embedded-field-metadata.d.ts

@@ -0,0 +1,14 @@
+import { TypeThunk } from '../orm.type.js';
+import type { EntityMetadata } from './entity-metadata.js';
+import { FieldMetadata } from './field-metadata.js';
+export declare type EmbeddedFieldOptions = Partial<Omit<EmbeddedFieldMetadata, 'entity' | 'name' | 'kind' | 'type'>>;
+export interface EmbeddedFieldMetadata extends FieldMetadata {
+    readonly kind: 'object';
+    type: TypeThunk;
+    fieldNamePrefix?: string;
+    fieldNameSuffix?: string;
+}
+export declare namespace EmbeddedFieldMetadata {
+    function create(entity: EntityMetadata, name: string, type: TypeThunk, options?: EmbeddedFieldOptions): EmbeddedFieldMetadata;
+    function resolveType(meta: EmbeddedFieldMetadata): Promise<EntityMetadata>;
+}

package/esm/orm/model/embedded-field-metadata.js

@@ -0,0 +1,25 @@
+import { resolveEntityMeta } from '../util/orm.helper.js';
+export var EmbeddedFieldMetadata;
+(function (EmbeddedFieldMetadata) {
+    function create(entity, name, type, options) {
+        const result = {
+            kind: 'object',
+            entity,
+            name,
+            type
+        };
+        if (options?.fieldNamePrefix)
+            result.fieldNamePrefix = options.fieldNamePrefix;
+        if (options?.fieldNameSuffix)
+            result.fieldNameSuffix = options.fieldNameSuffix;
+        return result;
+    }
+    EmbeddedFieldMetadata.create = create;
+    async function resolveType(meta) {
+        const typ = await resolveEntityMeta(meta.type);
+        if (typ)
+            return typ;
+        throw new Error(`Can't resolve type of ${meta.entity.name}.${meta.name}`);
+    }
+    EmbeddedFieldMetadata.resolveType = resolveType;
+})(EmbeddedFieldMetadata || (EmbeddedFieldMetadata = {}));

package/esm/orm/model/entity-metadata.d.ts

@@ -0,0 +1,50 @@
+import { Maybe, Type } from 'ts-gems';
+import { Ctor, TypeThunk } from '../orm.type.js';
+import { Association } from './association.js';
+import { AssociationFieldMetadata, AssociationFieldOptions } from './association-field-metadata.js';
+import { AssociationNode } from './association-node.js';
+import { ColumnFieldMetadata, ColumnFieldOptions } from './column-field-metadata.js';
+import { EmbeddedFieldMetadata, EmbeddedFieldOptions } from './embedded-field-metadata.js';
+import { IndexMetadata } from './index-metadata.js';
+export declare type AnyFieldMetadata = ColumnFieldMetadata | EmbeddedFieldMetadata | AssociationFieldMetadata;
+export declare type EntityOptions = Partial<Pick<EntityMetadata, 'name' | 'schema' | 'comment' | 'tableName'>>;
+export interface EntityMetadata {
+    readonly ctor: Type;
+    readonly name: string;
+    tableName?: string;
+    schema?: string;
+    comment?: string;
+    fields: Record<string, AnyFieldMetadata>;
+    indexes: IndexMetadata[];
+    foreignKeys: Association[];
+    eventListeners: Record<string, Function[]>;
+}
+export declare namespace EntityMetadata {
+    function define(ctor: Ctor): EntityMetadata;
+    function get(ctor: Ctor): Maybe<EntityMetadata>;
+    function getOwn(ctor: Ctor): Maybe<EntityMetadata>;
+    function getField(entity: EntityMetadata, fieldName: string): Maybe<AnyFieldMetadata>;
+    function getColumnField(entity: EntityMetadata, fieldName: string): Maybe<ColumnFieldMetadata>;
+    function getEmbeddedField(entity: EntityMetadata, fieldName: string): Maybe<EmbeddedFieldMetadata>;
+    function getAssociationField(entity: EntityMetadata, fieldName: string): Maybe<AssociationFieldMetadata>;
+    function findField(entity: EntityMetadata, predicate: (el: AnyFieldMetadata) => boolean): Maybe<AnyFieldMetadata>;
+    function getColumnFieldByFieldName(entity: EntityMetadata, fieldName: string): Maybe<ColumnFieldMetadata>;
+    function getFieldNames(entity: EntityMetadata, filter?: (el: AnyFieldMetadata) => boolean): string[];
+    function getColumnFieldNames(entity: EntityMetadata): string[];
+    function getEmbeddedFieldNames(entity: EntityMetadata): string[];
+    function getAssociationFieldNames(entity: EntityMetadata): string[];
+    function getNonAssociationFieldNames(entity: EntityMetadata): string[];
+    function getInsertColumnNames(entity: EntityMetadata): string[];
+    function getUpdateColumnNames(entity: EntityMetadata): string[];
+    function getPrimaryIndex(entity: EntityMetadata): Maybe<IndexMetadata>;
+    function getPrimaryIndexColumns(entity: EntityMetadata): ColumnFieldMetadata[];
+    function getForeignKeyFor(src: EntityMetadata, trg: EntityMetadata): Promise<Maybe<Association>>;
+    function addIndex(entity: EntityMetadata, index: IndexMetadata): void;
+    function addForeignKey(entity: EntityMetadata, propertyKey: string, target: TypeThunk, targetKey?: string): void;
+    function addEventListener(entity: EntityMetadata, event: string, fn: Function): void;
+    function defineColumnField(entity: EntityMetadata, name: string, options?: ColumnFieldOptions): ColumnFieldMetadata;
+    function defineEmbeddedField(entity: EntityMetadata, name: string, type: TypeThunk, options?: EmbeddedFieldOptions): EmbeddedFieldMetadata;
+    function defineAssociationField(entity: EntityMetadata, propertyKey: string, association: AssociationNode, options?: AssociationFieldOptions): AssociationFieldMetadata;
+    function setPrimaryKeys(entity: EntityMetadata, column: string | string[], options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): void;
+    function mixin(derived: EntityMetadata, base: EntityMetadata, filter?: (n: string) => boolean): void;
+}