@sqb/connect 4.0.7 → 4.0.10

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]>>;

package/dist/orm/util/entity-mapping.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OmitEntity = exports.PickEntity = exports.UnionEntity = exports.omitEntityInto = exports.pickEntityInto = exports.mixinEntities = void 0;
-const entity_model_1 = require("../model/entity-model");
-const association_1 = require("../model/association");
-const index_meta_1 = require("../model/index-meta");
-function mixinEntities(derived, classARef, classBRef, classCRef, classDRef, classERef, classFRef) {
-    const trg = entity_model_1.EntityModel.attachTo(derived);
-    for (const classRef of [classARef, classBRef, classCRef, classDRef, classERef, classFRef]) {
-        if (!classRef)
-            continue;
-        const src = entity_model_1.EntityModel.get(classRef);
-        if (!src)
-            return derived;
-        trg.tableName = src.tableName;
-        if (!trg.primaryIndex && src.primaryIndex) {
-            trg.primaryIndex = new index_meta_1.IndexMeta(trg, src.primaryIndex.columns, src.primaryIndex);
-        }
-        if (src.foreignKeys) {
-            trg.foreignKeys = trg.foreignKeys || [];
-            for (const fk of src.foreignKeys) {
-                const newFk = new association_1.Association(fk.name, { ...fk, source: derived });
-                trg.foreignKeys.push(newFk);
-            }
-        }
-        if (src.indexes) {
-            trg.indexes = trg.indexes || [];
-            for (const idx of src.indexes) {
-                const newIdx = new index_meta_1.IndexMeta(trg, idx.columns, idx);
-                trg.indexes.push(newIdx);
-            }
-        }
-        if (src.eventListeners) {
-            trg.eventListeners = trg.eventListeners || [];
-            trg.eventListeners.push(...src.eventListeners);
-        }
-        src.elements.forEach((p, n) => {
-            const o = Object.assign({}, p);
-            o.entity = trg;
-            Object.setPrototypeOf(o, Object.getPrototypeOf(p));
-            trg.elements.set(n, o);
-        });
-    }
-    return derived;
-}
-exports.mixinEntities = mixinEntities;
-function pickEntityInto(derived, classRef, keys) {
-    const trg = entity_model_1.EntityModel.attachTo(derived);
-    const src = entity_model_1.EntityModel.get(classRef);
-    if (!src)
-        return derived;
-    trg.tableName = src.tableName;
-    trg.schema = src.schema;
-    trg.comment = src.comment;
-    trg.primaryIndex = src.primaryIndex;
-    const pickKeys = keys.map(x => x.toLowerCase());
-    for (const fk of src.foreignKeys) {
-        if (fk.sourceKey && pickKeys.includes(fk.sourceKey.toLowerCase())) {
-            const newFk = new association_1.Association(fk.name, { ...fk, source: derived });
-            trg.foreignKeys.push(newFk);
-        }
-    }
-    for (const idx of src.indexes) {
-        if (!idx.columns.find(x => !pickKeys.includes(x.toLowerCase()))) {
-            const newIdx = new index_meta_1.IndexMeta(trg, idx.columns, idx);
-            trg.indexes.push(newIdx);
-        }
-    }
-    trg.eventListeners.push(...src.eventListeners);
-    src.elements.forEach((p, n) => {
-        if (pickKeys.includes(n))
-            trg.elements.set(n, p);
-    });
-    return derived;
-}
-exports.pickEntityInto = pickEntityInto;
-function omitEntityInto(derived, classRef, keys) {
-    const trg = entity_model_1.EntityModel.attachTo(derived);
-    const src = entity_model_1.EntityModel.get(classRef);
-    if (!src)
-        return derived;
-    trg.tableName = src.tableName;
-    trg.schema = src.schema;
-    trg.comment = src.comment;
-    trg.primaryIndex = src.primaryIndex;
-    const omitKeys = keys.map(x => x.toLowerCase());
-    for (const fk of src.foreignKeys) {
-        if (!(fk.sourceKey && omitKeys.includes(fk.sourceKey.toLowerCase()))) {
-            const newFk = new association_1.Association(fk.name, { ...fk, source: derived });
-            trg.foreignKeys.push(newFk);
-        }
-    }
-    for (const idx of src.indexes) {
-        if (!idx.columns.find(x => omitKeys.includes(x.toLowerCase()))) {
-            const newIdx = new index_meta_1.IndexMeta(trg, idx.columns, idx);
-            trg.indexes.push(newIdx);
-        }
-    }
-    trg.eventListeners.push(...src.eventListeners);
-    src.elements.forEach((p, n) => {
-        if (!omitKeys.includes(n.toLowerCase()))
-            trg.elements.set(n.toLowerCase(), p);
-    });
-    trg.elements.forEach((p, n) => {
-        if (omitKeys.includes(n.toLowerCase()))
-            trg.elements.delete(n.toLowerCase());
-    });
-    return derived;
-}
-exports.omitEntityInto = omitEntityInto;
-function UnionEntity(classARef, classBRef) {
-    class UnionEntityClass {
-        constructor(...args) {
-            inheritPropertyInitializers(this, classARef, args);
-            inheritPropertyInitializers(this, classBRef, args);
-        }
-    }
-    return mixinEntities(UnionEntityClass, classARef, classBRef);
-}
-exports.UnionEntity = UnionEntity;
-function PickEntity(classRef, keys) {
-    class PickEntityClass {
-        constructor(...args) {
-            inheritPropertyInitializers(this, classRef, args);
-        }
-    }
-    return pickEntityInto(PickEntityClass, classRef, keys);
-}
-exports.PickEntity = PickEntity;
-function OmitEntity(classRef, keys) {
-    class OmitEntityClass {
-        constructor(...args) {
-            inheritPropertyInitializers(this, classRef, args);
-        }
-    }
-    return omitEntityInto(OmitEntityClass, classRef, keys);
-}
-exports.OmitEntity = OmitEntity;
-function inheritPropertyInitializers(target, sourceClass, constructorArgs, isPropertyInherited) {
-    try {
-        const tempInstance = new sourceClass(...constructorArgs);
-        const keys = Object.getOwnPropertyNames(tempInstance);
-        for (const key of keys) {
-            const srcDesc = Object.getOwnPropertyDescriptor(tempInstance, key);
-            const trgDesc = Object.getOwnPropertyDescriptor(target, key);
-            if (!srcDesc || trgDesc || (isPropertyInherited && !isPropertyInherited(key)))
-                continue;
-            Object.defineProperty(target, key, srcDesc);
-        }
-    }
-    catch {
-        //
-    }
-}

package/dist/orm/util/extract-keyvalues.d.ts

@@ -1,2 +0,0 @@
-import { EntityModel } from '../model/entity-model';
-export declare function extractKeyValues<T>(entityDef: EntityModel, valueOrInstance: any | Record<string, any> | T, keepOther?: boolean): Record<string, any>;

package/dist/orm/util/extract-keyvalues.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractKeyValues = void 0;
-const orm_helper_1 = require("./orm.helper");
-function extractKeyValues(entityDef, valueOrInstance, keepOther) {
-    const primaryIndex = entityDef.primaryIndex;
-    if (!primaryIndex)
-        throw new Error(`No primary fields defined for "${entityDef.name}" entity`);
-    const validateCol = (k) => {
-        const col = entityDef.getElement(k);
-        if (!col)
-            throw new Error(`Unknown column (${k}) defined as primary key in entity "${entityDef.name}"`);
-        if (!(0, orm_helper_1.isColumnElement)(col))
-            throw new Error(`Column (${k}) defined as primary key in entity "${entityDef.name}" is not a data column`);
-    };
-    // if entity's primary key has more than one key field
-    if (primaryIndex.columns.length > 1) {
-        if (typeof valueOrInstance !== 'object')
-            throw new Error(`"${entityDef.name}" entity` +
-                ` has more than one primary key field and you must provide all values with an key/value pair`);
-        const valueKeys = Object.keys(valueOrInstance);
-        const valueKeysUpper = valueKeys.map(x => x.toUpperCase());
-        const out = {};
-        for (const k of primaryIndex.columns) {
-            const i = valueKeysUpper.indexOf(k.toUpperCase());
-            if (i < 0)
-                throw new Error(`Value of key field "${entityDef.name}.${k}" required to perform this operation`);
-            validateCol(k);
-            out[k] = valueOrInstance[valueKeys[i]];
-        }
-        if (keepOther) {
-            for (let i = 0; i < valueKeys.length; i++) {
-                if (primaryIndex.columns.find(x => x.toUpperCase() === valueKeysUpper[i]))
-                    continue;
-                out[valueKeys[i]] = valueOrInstance[valueKeys[i]];
-            }
-        }
-        return out;
-    }
-    const primaryColumnName = primaryIndex.columns[0];
-    validateCol(primaryColumnName);
-    if (typeof valueOrInstance === 'object') {
-        const valueKeys = Object.keys(valueOrInstance);
-        const valueKeysUpper = valueKeys.map(x => x.toUpperCase());
-        const k = valueKeysUpper.indexOf(primaryColumnName.toUpperCase());
-        if (k < 0)
-            throw new Error(`Value of key field "${entityDef.name}.${primaryColumnName}" required to perform this operation`);
-        const out = { [primaryColumnName]: valueOrInstance[valueKeys[k]] };
-        if (keepOther) {
-            for (let i = 0; i < valueKeys.length; i++) {
-                if (primaryIndex.columns.find(x => x.toUpperCase() === valueKeysUpper[i]))
-                    continue;
-                out[valueKeys[i]] = valueOrInstance[valueKeys[i]];
-            }
-        }
-        return out;
-    }
-    return { [primaryColumnName]: valueOrInstance };
-}
-exports.extractKeyValues = extractKeyValues;

package/dist/orm/util/orm.helper.d.ts

@@ -1,14 +0,0 @@
-import 'reflect-metadata';
-import { Type } from 'ts-gems';
-import type { TypeThunk } from '../orm.type';
-import type { EntityModel } from '../model/entity-model';
-import type { EntityColumnElement } from '../model/entity-column-element';
-import type { EntityObjectElement } from '../model/entity-object-element';
-import type { EntityAssociationElement } from '../model/entity-association-element';
-export declare function isClass(fn: any): fn is Type;
-export declare function isEntityClass(fn: any): fn is Type;
-export declare function isColumnElement(f: any): f is EntityColumnElement;
-export declare const isObjectElement: (f: any) => f is EntityObjectElement;
-export declare const isAssociationElement: (f: any) => f is EntityAssociationElement;
-export declare function resolveEntity(ctorThunk: TypeThunk): Promise<Type | undefined>;
-export declare function resolveEntityMeta(ctorThunk: TypeThunk): Promise<EntityModel | undefined>;

package/dist/orm/util/orm.helper.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveEntityMeta = exports.resolveEntity = exports.isAssociationElement = exports.isObjectElement = exports.isColumnElement = exports.isEntityClass = exports.isClass = void 0;
-require("reflect-metadata");
-const orm_const_1 = require("../orm.const");
-function isClass(fn) {
-    return typeof fn === 'function' && /^\s*class/.test(fn.toString());
-}
-exports.isClass = isClass;
-function isEntityClass(fn) {
-    return !!(isClass(fn) && fn[orm_const_1.ENTITY_DEFINITION_KEY]);
-}
-exports.isEntityClass = isEntityClass;
-function isColumnElement(f) {
-    return !!(f && f.entity && f.kind === 'column');
-}
-exports.isColumnElement = isColumnElement;
-const isObjectElement = (f) => {
-    return !!(f && f.entity && f.kind === 'object');
-};
-exports.isObjectElement = isObjectElement;
-const isAssociationElement = (f) => {
-    return !!(f && f.entity && f.kind === 'association');
-};
-exports.isAssociationElement = isAssociationElement;
-async function resolveEntity(ctorThunk) {
-    if (typeof ctorThunk !== 'function')
-        return;
-    if (!isClass(ctorThunk))
-        ctorThunk = await ctorThunk();
-    if (isEntityClass(ctorThunk))
-        return ctorThunk;
-}
-exports.resolveEntity = resolveEntity;
-async function resolveEntityMeta(ctorThunk) {
-    const ctor = await resolveEntity(ctorThunk);
-    return ctor && ctor[orm_const_1.ENTITY_DEFINITION_KEY];
-}
-exports.resolveEntityMeta = resolveEntityMeta;

package/dist/orm/util/serialize-element.d.ts

@@ -1,2 +0,0 @@
-import { AbstractEntityelement } from '../model/abstract-entityelement';
-export declare function serializeColumn(col: AbstractEntityelement, v: any): any;

package/dist/orm/util/serialize-element.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeColumn = void 0;
-const builder_1 = require("@sqb/builder");
-const orm_helper_1 = require("./orm.helper");
-function serializeColumn(col, v) {
-    if ((0, orm_helper_1.isColumnElement)(col)) {
-        if (col.isArray) {
-            if (Array.isArray(v))
-                return v.map(x => serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, x));
-            return [serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, v)];
-        }
-        return serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, v);
-    }
-    if (typeof v === 'object' && typeof v.toJSON === 'function')
-        return v.toJSON();
-    return v;
-}
-exports.serializeColumn = serializeColumn;
-const padZero = (n) => (n < 9 ? '0' : '') + n;
-function serializeDataValue(dataType, v) {
-    if (v == null)
-        return;
-    if (v instanceof Date &&
-        (dataType === builder_1.DataType.DATE || dataType === builder_1.DataType.TIMESTAMP)) {
-        return v.getFullYear() + '-' +
-            padZero(v.getMonth() + 1) + '-' +
-            padZero(v.getDate()) + (dataType === builder_1.DataType.TIMESTAMP ?
-            'T' + padZero(v.getHours()) + ':' +
-                padZero(v.getMinutes()) + ':' +
-                padZero(v.getSeconds()) : '');
-    }
-    if (v instanceof Buffer)
-        return v.toString('base64');
-    if (typeof v === 'number' && (dataType === builder_1.DataType.SMALLINT ||
-        dataType === builder_1.DataType.INTEGER))
-        return Math.trunc(v);
-    if (typeof v === 'bigint')
-        return v.toString();
-    if (v && typeof v === 'object' && typeof v.toJSON === 'function')
-        return v.toJSON();
-    return v;
-}

package/dist/types.d.ts

@@ -1,2 +0,0 @@
-import { DeepPartial, DeepPickWritable } from 'ts-gems';
-export declare type InstanceValues<T> = DeepPartial<DeepPickWritable<T>>;

package/dist/types.js

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