@sqb/connect 4.0.7 → 4.0.8

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

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

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

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

package/dist/orm/orm.const.js

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

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

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

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

@@ -1,125 +0,0 @@
-import { DeepPartial, Type } from 'ts-gems';
-import { AsyncEventEmitter } from 'strict-typed-events';
-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>;
-}
-export declare class Repository<T> extends AsyncEventEmitter<RepositoryEvents> {
-    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

@@ -1,217 +0,0 @@
-"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 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.emitAsync({ event: 'acquire', serial: true }, 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

@@ -1,12 +0,0 @@
-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]>>;