@sqb/connect 4.2.1 → 4.5.0

package/esm/orm/model/entity-metadata.js

@@ -0,0 +1,337 @@
+import { DataType } from '@sqb/builder';
+import { ENTITY_METADATA_KEY } from '../orm.const.js';
+import { isAssociationField, isColumnField, isEmbeddedField } from '../util/orm.helper.js';
+import { serializeColumn } from '../util/serialize-field.js';
+import { Association } from './association.js';
+import { AssociationFieldMetadata } from './association-field-metadata.js';
+import { ColumnFieldMetadata } from './column-field-metadata.js';
+import { EmbeddedFieldMetadata } from './embedded-field-metadata.js';
+export var EntityMetadata;
+(function (EntityMetadata) {
+    function define(ctor) {
+        const own = getOwn(ctor);
+        if (own)
+            return own;
+        const baseMeta = get(ctor);
+        const meta = {
+            ctor: ctor,
+            name: ctor.name,
+            fields: {},
+            indexes: [],
+            foreignKeys: [],
+            eventListeners: {}
+        };
+        Reflect.defineMetadata(ENTITY_METADATA_KEY, meta, ctor);
+        // Merge base entity columns into this one
+        if (baseMeta) {
+            EntityMetadata.mixin(meta, baseMeta);
+        }
+        ctor.prototype.toJSON = function () {
+            const obj = {};
+            const fieldKeys = Object.keys(meta.fields);
+            const l = fieldKeys.length;
+            let key;
+            let v;
+            for (let i = 0; i < l; i++) {
+                key = fieldKeys[i];
+                const col = EntityMetadata.getField(meta, key);
+                if (col) {
+                    v = this[col.name];
+                    if (v !== undefined)
+                        obj[col.name] = serializeColumn(col, v);
+                }
+            }
+            return obj;
+        };
+        return meta;
+    }
+    EntityMetadata.define = define;
+    function get(ctor) {
+        return Reflect.getMetadata(ENTITY_METADATA_KEY, ctor);
+    }
+    EntityMetadata.get = get;
+    function getOwn(ctor) {
+        return Reflect.getOwnMetadata(ENTITY_METADATA_KEY, ctor);
+    }
+    EntityMetadata.getOwn = getOwn;
+    function getField(entity, fieldName) {
+        return fieldName ? entity.fields[fieldName.toLowerCase()] : undefined;
+    }
+    EntityMetadata.getField = getField;
+    function getColumnField(entity, fieldName) {
+        const el = getField(entity, fieldName);
+        if (el && !isColumnField(el))
+            throw new Error(`"${el.name}" requested as "column" but it is "${el.kind}"`);
+        return el;
+    }
+    EntityMetadata.getColumnField = getColumnField;
+    function getEmbeddedField(entity, fieldName) {
+        const el = getField(entity, fieldName);
+        if (el && !isEmbeddedField(el))
+            throw new Error(`"${el.name}" requested as "embedded" but it is "${el.kind}"`);
+        return el;
+    }
+    EntityMetadata.getEmbeddedField = getEmbeddedField;
+    function getAssociationField(entity, fieldName) {
+        const el = getField(entity, fieldName);
+        if (el && !isAssociationField(el))
+            throw new Error(`"${el.name}" requested as "association" but it is "${el.kind}"`);
+        return el;
+    }
+    EntityMetadata.getAssociationField = getAssociationField;
+    function findField(entity, predicate) {
+        return Object.values(entity.fields).find(predicate);
+    }
+    EntityMetadata.findField = findField;
+    function getColumnFieldByFieldName(entity, fieldName) {
+        if (!fieldName)
+            return;
+        fieldName = fieldName.toLowerCase();
+        for (const prop of Object.values(entity.fields)) {
+            if (isColumnField(prop) && prop.fieldName.toLowerCase() === fieldName)
+                return prop;
+        }
+    }
+    EntityMetadata.getColumnFieldByFieldName = getColumnFieldByFieldName;
+    function getFieldNames(entity, filter) {
+        if (filter) {
+            const out = [];
+            for (const el of Object.values(entity.fields)) {
+                if (el && (!filter || filter(el)))
+                    out.push(el.name);
+            }
+            return out;
+        }
+        // Create a cached name array
+        if (!Object.prototype.hasOwnProperty.call(entity, '_fieldNames'))
+            Object.defineProperty(entity, '_fieldNames', {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: Object.values(entity.fields).map(m => m.name)
+            });
+        return entity._fieldNames;
+    }
+    EntityMetadata.getFieldNames = getFieldNames;
+    function getColumnFieldNames(entity) {
+        return getFieldNames(entity, isColumnField);
+    }
+    EntityMetadata.getColumnFieldNames = getColumnFieldNames;
+    function getEmbeddedFieldNames(entity) {
+        return getFieldNames(entity, isEmbeddedField);
+    }
+    EntityMetadata.getEmbeddedFieldNames = getEmbeddedFieldNames;
+    function getAssociationFieldNames(entity) {
+        return getFieldNames(entity, isAssociationField);
+    }
+    EntityMetadata.getAssociationFieldNames = getAssociationFieldNames;
+    function getNonAssociationFieldNames(entity) {
+        return getFieldNames(entity, x => !isAssociationField(x));
+    }
+    EntityMetadata.getNonAssociationFieldNames = getNonAssociationFieldNames;
+    function getInsertColumnNames(entity) {
+        return getFieldNames(entity, x => isColumnField(x) && !x.noInsert);
+    }
+    EntityMetadata.getInsertColumnNames = getInsertColumnNames;
+    function getUpdateColumnNames(entity) {
+        return getFieldNames(entity, x => isColumnField(x) && !x.noUpdate);
+    }
+    EntityMetadata.getUpdateColumnNames = getUpdateColumnNames;
+    function getPrimaryIndex(entity) {
+        return entity.indexes && entity.indexes.find(idx => idx.primary);
+    }
+    EntityMetadata.getPrimaryIndex = getPrimaryIndex;
+    function getPrimaryIndexColumns(entity) {
+        const idx = getPrimaryIndex(entity);
+        const out = [];
+        if (idx) {
+            for (const k of idx.columns) {
+                const col = getColumnField(entity, k);
+                if (!col)
+                    throw new Error(`Data column "${k}" in primary index of ${entity.name} does not exists`);
+                out.push(col);
+            }
+        }
+        return out;
+    }
+    EntityMetadata.getPrimaryIndexColumns = getPrimaryIndexColumns;
+    async function getForeignKeyFor(src, trg) {
+        if (!src.foreignKeys)
+            return;
+        for (const f of src.foreignKeys) {
+            if (await f.resolveTarget() === trg)
+                return f;
+        }
+    }
+    EntityMetadata.getForeignKeyFor = getForeignKeyFor;
+    function addIndex(entity, index) {
+        entity.indexes = entity.indexes || [];
+        index = {
+            ...index,
+            columns: Array.isArray(index.columns) ? index.columns : [index.columns]
+        };
+        if (index.primary)
+            entity.indexes.forEach(idx => delete idx.primary);
+        entity.indexes.push(index);
+    }
+    EntityMetadata.addIndex = addIndex;
+    function addForeignKey(entity, propertyKey, target, targetKey) {
+        entity.foreignKeys = entity.foreignKeys || [];
+        const fk = new Association(entity.name + '.' + propertyKey, {
+            source: entity.ctor,
+            sourceKey: propertyKey,
+            target,
+            targetKey
+        });
+        entity.foreignKeys.push(fk);
+    }
+    EntityMetadata.addForeignKey = addForeignKey;
+    function addEventListener(entity, event, fn) {
+        if (typeof fn !== 'function')
+            throw new Error('Property must be a function');
+        entity.eventListeners = entity.eventListeners || {};
+        entity.eventListeners[event] = entity.eventListeners[event] || [];
+        entity.eventListeners[event].push(fn);
+    }
+    EntityMetadata.addEventListener = addEventListener;
+    function defineColumnField(entity, name, options = {}) {
+        delete entity._fieldNames;
+        let prop = EntityMetadata.getField(entity, name);
+        if (isColumnField(prop))
+            options = { ...prop, ...options };
+        if (!options.type) {
+            switch (options.dataType) {
+                case DataType.BOOL:
+                    options.type = Boolean;
+                    break;
+                case DataType.VARCHAR:
+                case DataType.CHAR:
+                case DataType.TEXT:
+                    options.type = String;
+                    break;
+                case DataType.NUMBER:
+                case DataType.DOUBLE:
+                case DataType.FLOAT:
+                case DataType.INTEGER:
+                case DataType.SMALLINT:
+                    options.type = Number;
+                    break;
+                case DataType.TIMESTAMP:
+                case DataType.TIMESTAMPTZ:
+                    options.type = Date;
+                    break;
+                case DataType.BINARY:
+                    options.type = Buffer;
+                    break;
+                default:
+                    options.type = String;
+            }
+        }
+        if (!options.dataType) {
+            switch (options.type) {
+                case Boolean:
+                    options.dataType = DataType.BOOL;
+                    break;
+                case Number:
+                    options.dataType = DataType.NUMBER;
+                    break;
+                case Date:
+                    options.dataType = DataType.TIMESTAMP;
+                    break;
+                case Array:
+                    options.dataType = DataType.VARCHAR;
+                    options.isArray = true;
+                    break;
+                case Buffer:
+                    options.dataType = DataType.BINARY;
+                    break;
+                default:
+                    options.dataType = DataType.VARCHAR;
+            }
+        }
+        prop = ColumnFieldMetadata.create(entity, name, options);
+        entity.fields[name.toLowerCase()] = prop;
+        return prop;
+    }
+    EntityMetadata.defineColumnField = defineColumnField;
+    function defineEmbeddedField(entity, name, type, options) {
+        delete entity._fieldNames;
+        let prop = EntityMetadata.getField(entity, name);
+        if (isEmbeddedField(prop))
+            options = { ...prop, ...options };
+        prop = EmbeddedFieldMetadata.create(entity, name, type, options);
+        entity.fields[name.toLowerCase()] = prop;
+        return prop;
+    }
+    EntityMetadata.defineEmbeddedField = defineEmbeddedField;
+    function defineAssociationField(entity, propertyKey, association, options) {
+        delete entity._fieldNames;
+        const prop = AssociationFieldMetadata.create(entity, propertyKey, association, options);
+        let l = association;
+        let i = 1;
+        while (l) {
+            l.name = entity.name + '.' + propertyKey + '#' + (i++);
+            l = l.next;
+        }
+        entity.fields[propertyKey.toLowerCase()] = prop;
+        return prop;
+    }
+    EntityMetadata.defineAssociationField = defineAssociationField;
+    function setPrimaryKeys(entity, column, options) {
+        addIndex(entity, {
+            ...options,
+            columns: Array.isArray(column) ? column : [column],
+            unique: true,
+            primary: true
+        });
+    }
+    EntityMetadata.setPrimaryKeys = setPrimaryKeys;
+    function mixin(derived, base, filter) {
+        const hasField = (k) => !filter || filter(k);
+        delete derived._fieldNames;
+        if (!derived.tableName) {
+            derived.tableName = base.tableName;
+            derived.schema = base.schema;
+            derived.comment = base.comment;
+        }
+        // Copy indexes
+        if (base.indexes && base.indexes.length) {
+            const hasPrimaryIndex = !!getPrimaryIndex(derived);
+            for (const idx of base.indexes) {
+                if (!idx.columns.find(x => !hasField(x))) {
+                    if (hasPrimaryIndex)
+                        addIndex(derived, { ...idx, primary: undefined });
+                    else
+                        addIndex(derived, idx);
+                }
+            }
+        }
+        // Copy foreign indexes
+        if (base.foreignKeys && base.foreignKeys.length) {
+            derived.foreignKeys = derived.foreignKeys || [];
+            for (const fk of base.foreignKeys) {
+                if (!fk.sourceKey || hasField(fk.sourceKey)) {
+                    const newFk = new Association(fk.name, { ...fk, source: derived.ctor });
+                    derived.foreignKeys.push(newFk);
+                }
+            }
+        }
+        // Copy event listeners
+        if (base.eventListeners) {
+            for (const [event, arr] of Object.entries(base.eventListeners)) {
+                arr.forEach(fn => EntityMetadata.addEventListener(derived, event, fn));
+            }
+        }
+        // Copy fields
+        derived.fields = derived.fields || {};
+        for (const [n, p] of Object.entries(base.fields)) {
+            if (!hasField(n))
+                continue;
+            const o = Object.assign({}, p);
+            o.entity = derived;
+            Object.setPrototypeOf(o, Object.getPrototypeOf(p));
+            derived.fields[n] = o;
+        }
+    }
+    EntityMetadata.mixin = mixin;
+})(EntityMetadata || (EntityMetadata = {}));

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

@@ -0,0 +1,16 @@
+import type { FieldKind } from '../orm.type.js';
+import type { EntityMetadata } from './entity-metadata.js';
+export interface FieldMetadata {
+    readonly entity: EntityMetadata;
+    readonly name: string;
+    readonly kind: FieldKind;
+    /**
+     * Indicates whether or not to hide this field by default when making queries.
+     */
+    hidden?: boolean;
+    /**
+     * Indicates whether or not to include this field by default when making queries.
+     * If this set to "true" the field must be requested using "include" or "pick" option.
+     */
+    exclusive?: boolean;
+}

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

@@ -0,0 +1 @@
+export {};

package/esm/orm/model/index-metadata.js

@@ -0,0 +1 @@
+export {};

package/esm/orm/model/link-chain.d.ts

@@ -0,0 +1,13 @@
+import { Type } from 'ts-gems';
+import { TypeResolver, TypeThunk } from '../orm.type.js';
+import { AssociationNode } from './association-node.js';
+export declare class LinkChain<T> {
+    target: TypeThunk<T>;
+    first: AssociationNode;
+    current: AssociationNode;
+    constructor(target: TypeThunk<T>, targetKey?: keyof T, sourceKey?: string, many?: boolean);
+    where(conditions: object | object[]): this;
+    linkToOne<K>(target: Type<K> | TypeResolver<K>, targetColumn?: keyof K, parentColumn?: keyof T): LinkChain<K>;
+    linkToMany<K>(target: Type<K> | TypeResolver<K>, targetColumn?: keyof K, parentColumn?: keyof T): LinkChain<K>;
+    private _newNode;
+}

package/esm/orm/model/link-chain.js

@@ -0,0 +1,43 @@
+import { AssociationNode } from './association-node.js';
+export class LinkChain {
+    target;
+    first;
+    current;
+    constructor(target, targetKey, sourceKey, many) {
+        this.target = target;
+        this.first = this.current = new AssociationNode('', {
+            many,
+            target,
+            source: null,
+            sourceKey,
+            targetKey: targetKey
+        });
+    }
+    where(conditions) {
+        this.current.conditions = this.current.conditions || [];
+        if (Array.isArray(conditions))
+            this.current.conditions.push(...conditions);
+        else
+            this.current.conditions.push(conditions);
+        return this;
+    }
+    linkToOne(target, targetColumn, parentColumn) {
+        return this._newNode(target, targetColumn, parentColumn);
+    }
+    linkToMany(target, targetColumn, parentColumn) {
+        return this._newNode(target, targetColumn, parentColumn, true);
+    }
+    _newNode(target, targetKey, parentKey, many = false) {
+        const child = new AssociationNode(this.current.name, {
+            many,
+            source: this.current.target,
+            target,
+            sourceKey: parentKey,
+            targetKey: targetKey
+        });
+        child.prior = this.current;
+        this.current.next = child;
+        this.current = child;
+        return this;
+    }
+}

package/esm/orm/orm.const.js

@@ -0,0 +1,2 @@
+export const ENTITY_METADATA_KEY = Symbol.for('SQB_ENTITY_METADATA');
+export const REPOSITORY_KEY = Symbol.for('SQB_REPOSITORY');

package/{dist → esm}/orm/orm.type.d.ts

@@ -1,7 +1,6 @@
 import { Type } from 'ts-gems';
 export declare type Ctor = Type | Function;
-export declare type ElementKind = 'column' | 'object' | 'association';
-export declare type AssociationKind = 'to' | 'to-many' | 'from' | 'from-many';
+export declare type FieldKind = 'column' | 'object' | 'association';
 /**
  * Indicates auto generation strategy
  */
@@ -11,11 +10,11 @@ export declare type TypeResolver<T> = () => Type<T> | Promise<Type<T>>;
 export declare type TypeThunk<T = any> = Type<T> | TypeResolver<T>;
 export declare type EnumValue = (FieldValue)[] | Object;
 export declare type FieldValue = string | number | boolean | Date | null;
-export declare type DefaultValueGetter = (obj?: any) => FieldValue;
+export declare type DefaultValueGetter = (obj?: any) => FieldValue | undefined;
 export interface AssociationSettings {
     source: TypeThunk;
     target: TypeThunk;
     sourceKey?: string;
     targetKey?: string;
-    kind?: AssociationKind;
+    many?: boolean;
 }

package/esm/orm/orm.type.js

@@ -0,0 +1 @@
+export {};

package/{dist → esm}/orm/repository.class.d.ts

@@ -1,19 +1,19 @@
 import { DeepPartial, Type } from 'ts-gems';
-import { FieldInfoMap } from '../client/FieldInfoMap';
-import { SqbClient } from '../client/SqbClient';
-import { SqbConnection } from '../client/SqbConnection';
-import { QueryRequest, TransactionFunction } from '../client/types';
-import { InstanceValues } from '../types';
-import { EntityMetadata } from './model/entity-metadata';
+import { FieldInfoMap } from '../client/field-info-map.js';
+import { SqbClient } from '../client/sqb-client.js';
+import { SqbConnection } from '../client/sqb-connection.js';
+import { QueryRequest, TransactionFunction } from '../client/types.js';
+import { EntityData } from '../types.js';
+import { EntityMetadata } from './model/entity-metadata.js';
 export declare namespace Repository {
     type TransformRowFunction = (fields: FieldInfoMap, row: object, obj: object) => void;
     interface CommandOptions {
         connection?: SqbConnection;
     }
     interface CreateOptions extends CommandOptions {
-        elements?: string[];
+        pick?: string[];
+        omit?: string[];
         include?: string[];
-        exclude?: string[];
     }
     interface CountOptions extends CommandOptions {
         filter?: any;
@@ -28,9 +28,9 @@ export declare namespace Repository {
         params?: any;
     }
     interface FindOneOptions extends CommandOptions {
-        elements?: string[];
+        pick?: string[];
+        omit?: string[];
         include?: string[];
-        exclude?: string[];
         filter?: any;
         params?: any;
         sort?: string[];
@@ -44,16 +44,16 @@ export declare namespace Repository {
         maxSubQueries?: number;
     }
     interface GetOptions extends CommandOptions {
-        elements?: string[];
+        pick?: string[];
+        omit?: string[];
         include?: string[];
-        exclude?: string[];
         filter?: any;
         params?: any;
     }
     interface UpdateOptions extends CommandOptions {
-        elements?: string[];
+        pick?: string[];
+        omit?: string[];
         include?: string[];
-        exclude?: string[];
         filter?: any;
         params?: any;
     }
@@ -75,8 +75,8 @@ export declare class Repository<T> extends Repository_base {
     constructor(entityDef: EntityMetadata, executor: SqbClient | SqbConnection, schema?: string);
     get entity(): EntityMetadata;
     get type(): Type<T>;
-    create(values: InstanceValues<T>, options?: Repository.CreateOptions): Promise<DeepPartial<T>>;
-    createOnly(values: InstanceValues<T>, options?: Repository.CreateOptions): Promise<void>;
+    create(values: EntityData<T>, options?: Repository.CreateOptions): Promise<DeepPartial<T>>;
+    createOnly(values: EntityData<T>, options?: Repository.CreateOptions): Promise<void>;
     exists(keyValue: any | Record<string, any>, options?: Repository.ExistsOptions): Promise<boolean>;
     count(options?: Repository.CountOptions): Promise<number>;
     findAll(options?: Repository.FindAllOptions): Promise<DeepPartial<T>[]>;
@@ -84,14 +84,14 @@ export declare class Repository<T> extends Repository_base {
     findByPk(keyValue: any | Record<string, any>, options?: Repository.GetOptions): Promise<DeepPartial<T> | undefined>;
     destroy(keyValue: any | Record<string, any>, options?: Repository.DestroyOptions): Promise<boolean>;
     destroyAll(options?: Repository.DestroyOptions): Promise<number>;
-    update(keyValue: any | Record<string, any>, values: InstanceValues<T>, options?: Repository.UpdateOptions): Promise<DeepPartial<T> | undefined>;
-    updateOnly(keyValue: any | Record<string, any>, values: InstanceValues<T>, options?: Repository.UpdateOptions): Promise<DeepPartial<T>>;
-    updateAll(values: InstanceValues<T>, options?: Repository.UpdateAllOptions): Promise<number>;
+    update(keyValue: any | Record<string, any>, values: EntityData<T>, options?: Repository.UpdateOptions): Promise<DeepPartial<T> | undefined>;
+    updateOnly(keyValue: any | Record<string, any>, values: EntityData<T>, options?: Repository.UpdateOptions): Promise<DeepPartial<T>>;
+    updateAll(values: EntityData<T>, options?: Repository.UpdateAllOptions): Promise<number>;
     protected _execute(fn: TransactionFunction, opts?: Repository.CommandOptions): Promise<any>;
-    protected _create(values: InstanceValues<T>, options: Repository.CreateOptions & {
+    protected _create(values: EntityData<T>, options: Repository.CreateOptions & {
         connection: SqbConnection;
     }): Promise<DeepPartial<T>>;
-    protected _createOnly(values: InstanceValues<T>, options: Repository.CreateOptions & {
+    protected _createOnly(values: EntityData<T>, options: Repository.CreateOptions & {
         connection: SqbConnection;
     }): Promise<void>;
     protected _exists(keyValue: any | Record<string, any>, options: Repository.ExistsOptions & {
@@ -115,10 +115,10 @@ export declare class Repository<T> extends Repository_base {
     protected _destroyAll(options: Repository.DestroyOptions & {
         connection: SqbConnection;
     }): Promise<number>;
-    protected _update(keyValue: any | Record<string, any>, values: InstanceValues<T>, options: Repository.UpdateOptions & {
+    protected _update(keyValue: any | Record<string, any>, values: EntityData<T>, options: Repository.UpdateOptions & {
         connection: SqbConnection;
     }): Promise<Record<string, any> | undefined>;
-    protected _updateAll(values: InstanceValues<T>, options: Repository.UpdateAllOptions & {
+    protected _updateAll(values: EntityData<T>, options: Repository.UpdateAllOptions & {
         connection: SqbConnection;
     }): Promise<number>;
     protected _emit(event: string, ...args: any[]): Promise<void>;