@sqb/connect 4.0.9 → 4.0.13

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

@@ -0,0 +1,15 @@
+import { Type } from 'ts-gems';
+import { AssociationKind, TypeResolver, TypeThunk } from '../orm.type';
+import { AssociationNode } from './association-node';
+export declare class LinkChain<T> {
+    target: TypeThunk<T>;
+    first: AssociationNode;
+    current: AssociationNode;
+    constructor(target: TypeThunk<T>, kind: AssociationKind, targetKey?: keyof T, sourceKey?: string);
+    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>;
+    linkFromOne<K>(target: Type<K> | TypeResolver<K>, targetColumn?: keyof K, parentColumn?: keyof T): LinkChain<K>;
+    linkFromMany<K>(target: Type<K> | TypeResolver<K>, targetColumn?: keyof K, parentColumn?: keyof T): LinkChain<K>;
+    private _newNode;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkChain = void 0;
+const association_node_1 = require("./association-node");
+class LinkChain {
+    constructor(target, kind, targetKey, sourceKey) {
+        this.target = target;
+        this.first = this.current = new association_node_1.AssociationNode('', {
+            kind,
+            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, 'to', targetColumn, parentColumn);
+    }
+    linkToMany(target, targetColumn, parentColumn) {
+        return this._newNode(target, 'to-many', targetColumn, parentColumn);
+    }
+    linkFromOne(target, targetColumn, parentColumn) {
+        return this._newNode(target, 'from', targetColumn, parentColumn);
+    }
+    linkFromMany(target, targetColumn, parentColumn) {
+        return this._newNode(target, 'from-many', targetColumn, parentColumn);
+    }
+    _newNode(target, kind, targetKey, parentKey) {
+        const child = new association_node_1.AssociationNode(this.current.name, {
+            kind,
+            source: this.current.target,
+            target,
+            sourceKey: parentKey,
+            targetKey: targetKey
+        });
+        child.prior = this.current;
+        this.current.next = child;
+        this.current = child;
+        return this;
+    }
+}
+exports.LinkChain = LinkChain;

package/dist/orm/orm.const.d.ts

@@ -0,0 +1,2 @@
+export declare const ENTITY_DEFINITION_KEY: unique symbol;
+export declare const REPOSITORY_KEY: unique symbol;

package/dist/orm/orm.const.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPOSITORY_KEY = exports.ENTITY_DEFINITION_KEY = void 0;
+exports.ENTITY_DEFINITION_KEY = Symbol.for('sqb.entity-definition');
+exports.REPOSITORY_KEY = Symbol.for('sqb.entity.repository');

package/dist/orm/orm.type.d.ts

@@ -0,0 +1,112 @@
+import { Type } from 'ts-gems';
+import { DataType } from '..';
+export declare type ElementKind = 'column' | 'object' | 'association';
+export declare type AssociationKind = 'to' | 'to-many' | 'from' | 'from-many';
+/**
+ * Indicates auto generation strategy
+ */
+export declare type ColumnAutoGenerationStrategy = 'increment' | 'uuid' | 'rowid' | 'timestamp' | 'custom';
+export declare type ColumnTransformFunction = (value: any, name: string) => any;
+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 interface EntityConfig {
+    /**
+     *  Name of the table name. Default: entity class name.
+     */
+    tableName?: string;
+    /**
+     * Schema name which entity belongs to
+     */
+    schema?: string;
+    /**
+     * Table comment
+     */
+    comment?: string;
+}
+export interface IndexOptions {
+    /**
+     *  Name of the index
+     */
+    name?: string;
+    /**
+     * Specifies if index is unique
+     */
+    unique?: boolean;
+}
+export interface AssociationSettings {
+    source: TypeThunk;
+    target: TypeThunk;
+    sourceKey?: string;
+    targetKey?: string;
+    kind?: AssociationKind;
+}
+export interface DataPropertyOptions {
+    type?: Function;
+    /**
+     * Column data type
+     */
+    dataType?: DataType;
+    /**
+     *
+     */
+    isArray?: boolean;
+    /**
+     * Field name in the database table. Default: property name
+     */
+    fieldName?: string;
+    /**
+     * Field comment
+     */
+    comment?: string;
+    /**
+     * Character or byte length of column
+     */
+    length?: number;
+    /**
+     * Column's default value
+     */
+    default?: FieldValue | DefaultValueGetter;
+    /**
+     * 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 enum values
+     */
+    enum?: EnumValue;
+    /**
+     * 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;
+}
+export interface EmbeddedTypeOptions {
+    fieldNamePrefix?: string;
+    fieldNameSuffix?: string;
+}

package/dist/orm/orm.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/orm/repository.class.d.ts

@@ -0,0 +1,125 @@
+import { DeepPartial, Type } from 'ts-gems';
+import { SqbClient } from '../client/SqbClient';
+import { SqbConnection } from '../client/SqbConnection';
+import { EntityModel } from './model/entity-model';
+import { QueryRequest, TransactionFunction } from '../client/types';
+import { InstanceValues } from '../types';
+import { FieldInfoMap } from '../client/FieldInfoMap';
+export declare namespace Repository {
+    type TransformRowFunction = (fields: FieldInfoMap, row: object, obj: object) => void;
+    interface CommandOptions {
+        connection?: SqbConnection;
+    }
+    interface CreateOptions extends CommandOptions {
+        elements?: string[];
+        include?: string[];
+        exclude?: string[];
+    }
+    interface CountOptions extends CommandOptions {
+        filter?: any;
+        params?: any;
+    }
+    interface ExistsOptions extends CommandOptions {
+        filter?: any;
+        params?: any;
+    }
+    interface DestroyOptions extends CommandOptions {
+        filter?: any;
+        params?: any;
+    }
+    interface FindOneOptions extends CommandOptions {
+        elements?: string[];
+        include?: string[];
+        exclude?: string[];
+        filter?: any;
+        params?: any;
+        sort?: string[];
+        offset?: number;
+        distinct?: boolean;
+        onTransformRow?: TransformRowFunction;
+    }
+    interface FindAllOptions extends FindOneOptions {
+        limit?: number;
+        maxEagerFetch?: number;
+        maxSubQueries?: number;
+    }
+    interface GetOptions extends CommandOptions {
+        elements?: string[];
+        include?: string[];
+        exclude?: string[];
+        filter?: any;
+        params?: any;
+    }
+    interface UpdateOptions extends CommandOptions {
+        elements?: string[];
+        include?: string[];
+        exclude?: string[];
+        filter?: any;
+        params?: any;
+    }
+    interface UpdateAllOptions extends CommandOptions {
+        filter?: any;
+        params?: any;
+    }
+}
+interface RepositoryEvents {
+    execute: (request: QueryRequest) => void;
+    error: (error: Error) => void;
+    acquire: (connection: SqbConnection) => Promise<void>;
+}
+declare const Repository_base: Type<import("strict-typed-events").TypedEventEmitter<any, RepositoryEvents, RepositoryEvents>>;
+export declare class Repository<T> extends Repository_base {
+    private readonly _executor;
+    private readonly _entity;
+    private readonly _schema?;
+    constructor(entityDef: EntityModel, executor: SqbClient | SqbConnection, schema?: string);
+    get entity(): EntityModel;
+    get type(): Type<T>;
+    create(values: InstanceValues<T>, options?: Repository.CreateOptions): Promise<DeepPartial<T>>;
+    createOnly(values: InstanceValues<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>[]>;
+    findOne(options?: Repository.FindOneOptions): Promise<DeepPartial<T> | undefined>;
+    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>;
+    protected _execute(fn: TransactionFunction, opts?: Repository.CommandOptions): Promise<any>;
+    protected _create(values: InstanceValues<T>, options: Repository.CreateOptions & {
+        connection: SqbConnection;
+    }): Promise<DeepPartial<T>>;
+    protected _createOnly(values: InstanceValues<T>, options: Repository.CreateOptions & {
+        connection: SqbConnection;
+    }): Promise<void>;
+    protected _exists(keyValue: any | Record<string, any>, options: Repository.ExistsOptions & {
+        connection: SqbConnection;
+    }): Promise<boolean>;
+    protected _count(options: Repository.CountOptions & {
+        connection: SqbConnection;
+    }): Promise<number>;
+    protected _findAll(options: Repository.FindAllOptions & {
+        connection: SqbConnection;
+    }): Promise<DeepPartial<T>[]>;
+    protected _findOne(options: Repository.FindOneOptions & {
+        connection: SqbConnection;
+    }): Promise<DeepPartial<T> | undefined>;
+    protected _findByPk(keyValue: any | Record<string, any>, options: Repository.GetOptions & {
+        connection: SqbConnection;
+    }): Promise<DeepPartial<T> | undefined>;
+    protected _destroy(keyValue: any | Record<string, any>, options: Repository.DestroyOptions & {
+        connection: SqbConnection;
+    }): Promise<boolean>;
+    protected _destroyAll(options: Repository.DestroyOptions & {
+        connection: SqbConnection;
+    }): Promise<number>;
+    protected _update(keyValue: any | Record<string, any>, values: InstanceValues<T>, options: Repository.UpdateOptions & {
+        connection: SqbConnection;
+    }): Promise<Record<string, any> | undefined>;
+    protected _updateAll(values: InstanceValues<T>, options: Repository.UpdateAllOptions & {
+        connection: SqbConnection;
+    }): Promise<number>;
+}
+export {};

package/dist/orm/repository.class.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = void 0;
+const strict_typed_events_1 = require("strict-typed-events");
+const SqbConnection_1 = require("../client/SqbConnection");
+const extract_keyvalues_1 = require("./util/extract-keyvalues");
+const count_command_1 = require("./commands/count.command");
+const create_command_1 = require("./commands/create.command");
+const find_command_1 = require("./commands/find.command");
+const destroy_command_1 = require("./commands/destroy.command");
+const update_command_1 = require("./commands/update.command");
+class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_typed_events_1.AsyncEventEmitter) {
+    constructor(entityDef, executor, schema) {
+        super();
+        this._executor = executor;
+        this._entity = entityDef;
+        this._schema = schema;
+    }
+    get entity() {
+        return this._entity;
+    }
+    get type() {
+        return this._entity.ctor;
+    }
+    create(values, options) {
+        return this._execute(async (connection) => {
+            return this._create(values, { ...options, connection });
+        }, options);
+    }
+    createOnly(values, options) {
+        return this._execute(async (connection) => {
+            return this._createOnly(values, { ...options, connection });
+        }, options);
+    }
+    exists(keyValue, options) {
+        return this._execute(async (connection) => {
+            return this._exists(keyValue, { ...options, connection });
+        }, options);
+    }
+    count(options) {
+        return this._execute(async (connection) => {
+            return this._count({ ...options, connection });
+        }, options);
+    }
+    findAll(options) {
+        return this._execute(async (connection) => {
+            return this._findAll({ ...options, connection });
+        }, options);
+    }
+    findOne(options) {
+        return this._execute(async (connection) => {
+            return this._findOne({ ...options, connection });
+        }, options);
+    }
+    findByPk(keyValue, options) {
+        return this._execute(async (connection) => {
+            return this._findByPk(keyValue, { ...options, connection });
+        }, options);
+    }
+    destroy(keyValue, options) {
+        return this._execute(async (connection) => {
+            return this._destroy(keyValue, { ...options, connection });
+        }, options);
+    }
+    destroyAll(options) {
+        return this._execute(async (connection) => {
+            return this._destroyAll({ ...options, connection });
+        }, options);
+    }
+    update(keyValue, values, options) {
+        return this._execute(async (connection) => {
+            const opts = { ...options, connection };
+            const keyValues = await this._update(keyValue, values, opts);
+            if (keyValues)
+                return this._findByPk(keyValues, opts);
+        }, options);
+    }
+    updateOnly(keyValue, values, options) {
+        return this._execute(async (connection) => {
+            return !!(await this._update(keyValue, values, { ...options, connection }));
+        }, options);
+    }
+    updateAll(values, options) {
+        return this._execute(async (connection) => {
+            return this._updateAll(values, { ...options, connection });
+        });
+    }
+    async _execute(fn, opts) {
+        let connection = opts?.connection;
+        if (!connection && this._executor instanceof SqbConnection_1.SqbConnection)
+            connection = this._executor;
+        if (connection) {
+            if (this._schema)
+                await connection.setSchema(this._schema);
+            return fn(connection);
+        }
+        return this._executor.acquire(async (conn) => {
+            if (this._schema)
+                await conn.setSchema(this._schema);
+            await this.emitAsyncSerial('acquire', conn);
+            return fn(conn);
+        });
+    }
+    async _create(values, options) {
+        const keyValues = await create_command_1.CreateCommand.execute({
+            ...options,
+            entity: this._entity,
+            values,
+            returning: true
+        });
+        const result = keyValues && (await this.findByPk(keyValues, options));
+        if (!result)
+            throw new Error('Unable to insert new row');
+        return result;
+    }
+    async _createOnly(values, options) {
+        await create_command_1.CreateCommand.execute({
+            ...options,
+            entity: this._entity,
+            values,
+            returning: false
+        });
+    }
+    async _exists(keyValue, options) {
+        const filter = [(0, extract_keyvalues_1.extractKeyValues)(this._entity, keyValue, true)];
+        if (options && options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        return !!(await count_command_1.CountCommand.execute({
+            ...options,
+            filter,
+            entity: this._entity
+        }));
+    }
+    async _count(options) {
+        return count_command_1.CountCommand.execute({
+            ...options,
+            entity: this._entity
+        });
+    }
+    async _findAll(options) {
+        return await find_command_1.FindCommand.execute({
+            ...options,
+            entity: this._entity,
+        });
+    }
+    async _findOne(options) {
+        const rows = await find_command_1.FindCommand.execute({
+            ...options,
+            entity: this._entity,
+            limit: 1
+        });
+        return rows && rows[0];
+    }
+    async _findByPk(keyValue, options) {
+        const filter = [(0, extract_keyvalues_1.extractKeyValues)(this._entity, keyValue, true)];
+        if (options && options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        return await this._findOne({ ...options, filter, offset: 0 });
+    }
+    async _destroy(keyValue, options) {
+        const filter = [(0, extract_keyvalues_1.extractKeyValues)(this._entity, keyValue, true)];
+        if (options && options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        return !!(await destroy_command_1.DestroyCommand.execute({
+            ...options,
+            filter,
+            entity: this._entity,
+        }));
+    }
+    async _destroyAll(options) {
+        return destroy_command_1.DestroyCommand.execute({
+            ...options,
+            entity: this._entity,
+            filter: options?.filter,
+            params: options?.params
+        });
+    }
+    async _update(keyValue, values, options) {
+        const keyValues = (0, extract_keyvalues_1.extractKeyValues)(this._entity, keyValue, true);
+        const filter = [keyValues];
+        if (options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        const updateValues = { ...values };
+        Object.keys(keyValues).forEach(k => delete updateValues[k]);
+        const rowsAffected = await update_command_1.UpdateCommand.execute({
+            ...options,
+            entity: this._entity,
+            values: updateValues,
+            filter
+        });
+        return rowsAffected ? keyValues : undefined;
+    }
+    async _updateAll(values, options) {
+        return await update_command_1.UpdateCommand.execute({
+            ...options,
+            entity: this._entity,
+            values
+        });
+    }
+}
+exports.Repository = Repository;

package/dist/orm/util/entity-mapping.d.ts

@@ -0,0 +1,12 @@
+import { Type } from 'ts-gems';
+export declare function mixinEntities<A, B, C, D, E, F>(derived: Type, classARef: Type<A>, classBRef: Type<B>, classCRef: Type<C>, classDRef: Type<D>, classERef: Type<E>, classFRef: Type<F>): Type<A & B & C & D & E & F>;
+export declare function mixinEntities<A, B, C, D, E>(derived: Type, classARef: Type<A>, classBRef: Type<B>, classCRef: Type<C>, classDRef: Type<D>, classERef: Type<E>): Type<A & B & C & D & E>;
+export declare function mixinEntities<A, B, C, D>(derived: Type, classARef: Type<A>, classBRef: Type<B>, classCRef: Type<C>, classDRef: Type<D>): Type<A & B & C & D>;
+export declare function mixinEntities<A, B, C>(derived: Type, classARef: Type<A>, classBRef: Type<B>, classCRef: Type<C>): Type<A & B & C>;
+export declare function mixinEntities<A, B>(derived: Type, classARef: Type<A>, classBRef: Type<B>): Type<A & B>;
+export declare function mixinEntities<A, B>(derived: Type, classARef: Type<A>, classBRef: Type<B>): Type<A & B>;
+export declare function pickEntityInto<T, K extends keyof T>(derived: Type, classRef: Type<T>, keys: readonly K[]): Type<Pick<T, typeof keys[number]>>;
+export declare function omitEntityInto<T, K extends keyof T>(derived: Type, classRef: Type<T>, keys: readonly K[]): Type<Omit<T, typeof keys[number]>>;
+export declare function UnionEntity<A, B>(classARef: Type<A>, classBRef: Type<B>): Type<A & B>;
+export declare function PickEntity<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Pick<T, typeof keys[number]>>;
+export declare function OmitEntity<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Omit<T, typeof keys[number]>>;