@sqb/connect 4.0.9 → 4.0.13

package/dist/client/types.d.ts

@@ -0,0 +1,189 @@
+import { Maybe } from 'ts-gems';
+import { DataType, ParamOptions } from '@sqb/builder';
+import type { SqbConnection } from './SqbConnection';
+import type { FieldInfoMap } from './FieldInfoMap';
+import type { Cursor } from './Cursor';
+import type { PoolConfiguration } from 'lightning-pool';
+import type { Adapter } from './Adapter';
+export { DataType } from '@sqb/builder';
+export declare type ExecuteHookFunction = (connection: SqbConnection, request: QueryRequest) => Promise<void>;
+export declare type FetchFunction = (row: any, request: QueryRequest) => void;
+export declare type ValueTransformFunction = (value: any, fieldInfo?: FieldInfo) => any;
+export declare type TransactionFunction = (connection: SqbConnection) => Promise<any>;
+export declare type RowType = 'array' | 'object';
+export declare type FieldNaming = 'original' | 'lowercase' | 'uppercase' | 'camelcase' | 'pascalcase' | ((fieldName: string) => Maybe<string>);
+export declare type ObjectRow = Record<string, any>;
+export declare type ArrayRow = any[];
+export declare type ObjectRowset = ObjectRow[];
+export declare type ArrayRowset = ArrayRow[];
+export interface ClientConfiguration {
+    /**
+     * Dialect to be used
+     */
+    dialect?: string;
+    /**
+     * Database connection driver to be used
+     */
+    driver?: string;
+    /**
+     * Connection name
+     */
+    name?: string;
+    /**
+     * Database server address or url
+     */
+    host?: string;
+    /**
+     * Database listener port number
+     *
+     */
+    port?: number;
+    /**
+     * Database username.
+     */
+    user?: string;
+    /**
+     * Database password.
+     */
+    password?: string;
+    /**
+     * Database name
+     */
+    database?: string;
+    /**
+     * Database schema
+     */
+    schema?: string;
+    /**
+     * Connection options to be passed to the underlying driver
+     */
+    driverOptions?: any;
+    /**
+     * Pooling options
+     */
+    pool?: PoolConfiguration;
+    /**
+     * Default options
+     */
+    defaults?: ClientDefaults;
+}
+export interface ClientDefaults {
+    autoCommit?: boolean;
+    cursor?: boolean;
+    objectRows?: boolean;
+    fieldNaming?: FieldNaming;
+    showSql?: boolean;
+    prettyPrint?: boolean;
+    ignoreNulls?: boolean;
+    /**
+     * Sets how many row will be fetched at a time
+     * Default = 10
+     */
+    fetchRows?: number;
+    transform?: ValueTransformFunction;
+}
+export interface ConnectionOptions {
+    /**
+     *  If this property is true, the transaction committed at the end of query execution.
+     *  Default = false
+     */
+    autoCommit?: boolean;
+}
+export interface QueryExecuteOptions {
+    /**
+     * Array of values or object that contains param/value pairs.
+     */
+    params?: Record<string, any> | any[];
+    /**
+     *  If this property is true, the transaction committed at the end of query execution.
+     *  Default = false
+     */
+    autoCommit?: boolean;
+    /**
+     * If this property is true, query returns a Cursor object that works
+     * in unidirectional "cursor" mode.
+     * Important! Cursor keeps connection open until cursor.close() method is called.
+     */
+    cursor?: boolean;
+    /**
+     * Function for converting data before returning response.
+     */
+    transform?: ValueTransformFunction;
+    /**
+     * In "cursor" mode; it provides an initial suggested number of rows to prefetch.
+     * Prefetching is a tuning option to maximize data transfer efficiency and
+     * minimize round-trips to the database. In regular mode;
+     * it provides the maximum number of rows that are fetched from Connection instance.
+     * Default = 10
+     */
+    fetchRows?: number;
+    /**
+     * If set true, NULL fields will be ignored
+     * Default = false
+     */
+    ignoreNulls?: boolean;
+    /**
+     * Sets the naming strategy for fields. It affects field names in object rows and metadata
+     */
+    namingStrategy?: FieldNaming;
+    /**
+     * Determines whether query rows should be returned as Objects or Arrays.
+     * This property applies to ResultSet.objectRows property also.
+     * Default = driver default
+     */
+    objectRows?: boolean;
+    /**
+     * If set true, result object contains executed sql and values.
+     * Default = false
+     */
+    showSql?: boolean;
+    prettyPrint?: boolean;
+    action?: string;
+    fetchAsString?: DataType[];
+}
+export interface QueryResult {
+    executeTime: number;
+    fields?: FieldInfoMap;
+    rows?: Record<string, any>[] | any[][];
+    rowType?: RowType;
+    query?: QueryRequest;
+    returns?: any;
+    rowsAffected?: number;
+    cursor?: Cursor;
+}
+export interface ObjectQueryResult extends QueryResult {
+    rows?: Record<string, any>[];
+    rowType?: 'object';
+}
+export interface ArrayQueryResult extends QueryResult {
+    rows?: any[][];
+    rowType?: 'array';
+}
+export declare type FieldInfo = {
+    index: number;
+    name: string;
+} & Adapter.Field;
+export interface QueryRequest {
+    dialect?: string;
+    dialectVersion?: string;
+    sql: string;
+    params?: any;
+    paramOptions?: Record<string, ParamOptions> | ParamOptions[];
+    returningFields?: {
+        field: string;
+        alias?: string;
+    }[];
+    autoCommit?: boolean;
+    cursor?: boolean;
+    objectRows?: boolean;
+    ignoreNulls?: boolean;
+    fetchRows?: number;
+    fieldNaming?: FieldNaming;
+    transform?: ValueTransformFunction;
+    showSql?: boolean;
+    prettyPrint?: boolean;
+    action?: string;
+    fetchAsString?: DataType[];
+    executeHooks?: ExecuteHookFunction[];
+    fetchHooks?: FetchFunction[];
+}

package/dist/client/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = void 0;
+var builder_1 = require("@sqb/builder");
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return builder_1.DataType; } });

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export { Type, Maybe, DeepPartial, DeepPickWritable, DeepBuildable } from 'ts-gems';
+export * from './types';
+export * from './client/types';
+export * from './client/Adapter';
+export * from './client/SqbClient';
+export * from './client/SqbConnection';
+export * from './client/Cursor';
+export { registerAdapter, unRegisterAdapter } from './client/extensions';
+export * from './orm/orm.type';
+export * from './orm/base-entity.class';
+export * from './orm/decorators/entity.decorator';
+export * from './orm/decorators/primarykey.decorator';
+export * from './orm/decorators/index.decorator';
+export * from './orm/decorators/column.decorator';
+export * from './orm/decorators/link.decorator';
+export * from './orm/decorators/embedded.decorator';
+export * from './orm/decorators/foreignkey.decorator';
+export * from './orm/decorators/events.decorator';
+export * from './orm/decorators/transform.decorator';
+export * from './orm/repository.class';
+export * from './orm/model/entity-model';
+export * from './orm/model/entity-column-element';
+export * from './orm/model/entity-object-element';
+export * from './orm/model/entity-association-element';
+export * from './orm/model/association';
+export * from './orm/model/index-meta';
+export * from './orm/util/entity-mapping';
+export { isColumnElement, isObjectElement, isAssociationElement, isEntityClass } from './orm/util/orm.helper';

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEntityClass = exports.isAssociationElement = exports.isObjectElement = exports.isColumnElement = exports.unRegisterAdapter = exports.registerAdapter = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./client/types"), exports);
+tslib_1.__exportStar(require("./client/Adapter"), exports);
+tslib_1.__exportStar(require("./client/SqbClient"), exports);
+tslib_1.__exportStar(require("./client/SqbConnection"), exports);
+tslib_1.__exportStar(require("./client/Cursor"), exports);
+var extensions_1 = require("./client/extensions");
+Object.defineProperty(exports, "registerAdapter", { enumerable: true, get: function () { return extensions_1.registerAdapter; } });
+Object.defineProperty(exports, "unRegisterAdapter", { enumerable: true, get: function () { return extensions_1.unRegisterAdapter; } });
+tslib_1.__exportStar(require("./orm/orm.type"), exports);
+tslib_1.__exportStar(require("./orm/base-entity.class"), exports);
+tslib_1.__exportStar(require("./orm/decorators/entity.decorator"), exports);
+tslib_1.__exportStar(require("./orm/decorators/primarykey.decorator"), exports);
+tslib_1.__exportStar(require("./orm/decorators/index.decorator"), exports);
+tslib_1.__exportStar(require("./orm/decorators/column.decorator"), exports);
+tslib_1.__exportStar(require("./orm/decorators/link.decorator"), exports);
+tslib_1.__exportStar(require("./orm/decorators/embedded.decorator"), exports);
+tslib_1.__exportStar(require("./orm/decorators/foreignkey.decorator"), exports);
+tslib_1.__exportStar(require("./orm/decorators/events.decorator"), exports);
+tslib_1.__exportStar(require("./orm/decorators/transform.decorator"), exports);
+tslib_1.__exportStar(require("./orm/repository.class"), exports);
+tslib_1.__exportStar(require("./orm/model/entity-model"), exports);
+tslib_1.__exportStar(require("./orm/model/entity-column-element"), exports);
+tslib_1.__exportStar(require("./orm/model/entity-object-element"), exports);
+tslib_1.__exportStar(require("./orm/model/entity-association-element"), exports);
+tslib_1.__exportStar(require("./orm/model/association"), exports);
+tslib_1.__exportStar(require("./orm/model/index-meta"), exports);
+tslib_1.__exportStar(require("./orm/util/entity-mapping"), exports);
+var orm_helper_1 = require("./orm/util/orm.helper");
+Object.defineProperty(exports, "isColumnElement", { enumerable: true, get: function () { return orm_helper_1.isColumnElement; } });
+Object.defineProperty(exports, "isObjectElement", { enumerable: true, get: function () { return orm_helper_1.isObjectElement; } });
+Object.defineProperty(exports, "isAssociationElement", { enumerable: true, get: function () { return orm_helper_1.isAssociationElement; } });
+Object.defineProperty(exports, "isEntityClass", { enumerable: true, get: function () { return orm_helper_1.isEntityClass; } });

package/dist/orm/base-entity.class.d.ts

@@ -0,0 +1,16 @@
+import { PickReadonly, PickWritable, Type } from 'ts-gems';
+import { REPOSITORY_KEY } from './orm.const';
+export declare abstract class BaseEntity {
+    private [REPOSITORY_KEY];
+    constructor(partial?: any);
+    destroy(): Promise<boolean>;
+    exists(): Promise<boolean>;
+    toJSON(): any;
+}
+export declare function getElementNames<T, K extends keyof T>(classRef: Type<T>): K[];
+export declare function getColumnNames<T, K extends keyof PickWritable<T>>(classRef: Type<T>): K[];
+export declare function getObjectElementNames<T, K extends keyof PickWritable<T>>(classRef: Type<T>): K[];
+export declare function getAssociationElementNames<T, K extends keyof PickReadonly<T>>(classRef: Type<T>): K[];
+export declare function getNonAssociationElementNames<T, K extends keyof PickWritable<T>>(classRef: Type<T>): K[];
+export declare function getInsertColumnNames<T, K extends keyof PickWritable<T>>(classRef: Type<T>): K[];
+export declare function getUpdateColumnNames<T, K extends keyof PickWritable<T>>(classRef: Type<T>): K[];

package/dist/orm/base-entity.class.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUpdateColumnNames = exports.getInsertColumnNames = exports.getNonAssociationElementNames = exports.getAssociationElementNames = exports.getObjectElementNames = exports.getColumnNames = exports.getElementNames = exports.BaseEntity = void 0;
+const orm_const_1 = require("./orm.const");
+const entity_model_1 = require("./model/entity-model");
+class BaseEntity {
+    constructor(partial) {
+        const elements = entity_model_1.EntityModel.getColumnNames(Object.getPrototypeOf(this).constructor);
+        if (elements && partial) {
+            for (const k of elements)
+                if (partial[k] !== undefined)
+                    this[k] = partial[k];
+        }
+    }
+    async destroy() {
+        const repo = this[orm_const_1.REPOSITORY_KEY];
+        return repo.destroy(this);
+    }
+    async exists() {
+        const repo = this[orm_const_1.REPOSITORY_KEY];
+        return repo.exists(this);
+    }
+    toJSON() {
+        // this method is an placeholder an will be overwritten by declareEntity() method
+        return this;
+    }
+}
+exports.BaseEntity = BaseEntity;
+function getElementNames(classRef) {
+    return (entity_model_1.EntityModel.getElementNames(classRef) || []);
+}
+exports.getElementNames = getElementNames;
+function getColumnNames(classRef) {
+    return (entity_model_1.EntityModel.getColumnNames(classRef) || []);
+}
+exports.getColumnNames = getColumnNames;
+function getObjectElementNames(classRef) {
+    return (entity_model_1.EntityModel.getObjectElementNames(classRef) || []);
+}
+exports.getObjectElementNames = getObjectElementNames;
+function getAssociationElementNames(classRef) {
+    return (entity_model_1.EntityModel.getAssociationElementNames(classRef) || []);
+}
+exports.getAssociationElementNames = getAssociationElementNames;
+function getNonAssociationElementNames(classRef) {
+    return (entity_model_1.EntityModel.getNonAssociationElementNames(classRef) || []);
+}
+exports.getNonAssociationElementNames = getNonAssociationElementNames;
+function getInsertColumnNames(classRef) {
+    return (entity_model_1.EntityModel.getInsertColumnNames(classRef) || []);
+}
+exports.getInsertColumnNames = getInsertColumnNames;
+function getUpdateColumnNames(classRef) {
+    return (entity_model_1.EntityModel.getUpdateColumnNames(classRef) || []);
+}
+exports.getUpdateColumnNames = getUpdateColumnNames;

package/dist/orm/commands/command.helper.d.ts

@@ -0,0 +1,14 @@
+import { JoinStatement, LogicalOperator } from '@sqb/builder';
+import { EntityModel } from '../model/entity-model';
+import { AssociationNode } from '../model/association-node';
+export interface JoinInfo {
+    association: AssociationNode;
+    sourceEntity: EntityModel;
+    targetEntity: EntityModel;
+    joinAlias: string;
+    join: JoinStatement;
+}
+export declare function joinAssociationGetFirst(joinInfos: JoinInfo[], association: AssociationNode, parentAlias: string, innerJoin?: boolean): Promise<JoinInfo>;
+export declare function joinAssociationGetLast(joinInfos: JoinInfo[], association: AssociationNode, parentAlias: string, innerJoin?: boolean): Promise<JoinInfo>;
+export declare function joinAssociation(joinInfos: JoinInfo[], association: AssociationNode, parentAlias: string, innerJoin?: boolean): Promise<JoinInfo[]>;
+export declare function prepareFilter(entityDef: EntityModel, filter: any, trgOp: LogicalOperator, tableAlias?: string): Promise<void>;

package/dist/orm/commands/command.helper.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareFilter = exports.joinAssociation = exports.joinAssociationGetLast = exports.joinAssociationGetFirst = void 0;
+const builder_1 = require("@sqb/builder");
+const orm_helper_1 = require("../util/orm.helper");
+async function joinAssociationGetFirst(joinInfos, association, parentAlias, innerJoin) {
+    const joins = await joinAssociation(joinInfos, association, parentAlias, innerJoin);
+    return joins[0];
+}
+exports.joinAssociationGetFirst = joinAssociationGetFirst;
+async function joinAssociationGetLast(joinInfos, association, parentAlias, innerJoin) {
+    const joins = await joinAssociation(joinInfos, association, parentAlias, innerJoin);
+    return joins[joins.length - 1];
+}
+exports.joinAssociationGetLast = joinAssociationGetLast;
+async function joinAssociation(joinInfos, association, parentAlias, innerJoin) {
+    let joinInfo;
+    let node = association;
+    const result = [];
+    while (node) {
+        joinInfo = joinInfos.find(j => j.association === node);
+        if (!joinInfo) {
+            const targetEntity = await node.resolveTarget();
+            const sourceEntity = await node.resolveSource();
+            const keyCol = await node.resolveSourceProperty();
+            const targetCol = await node.resolveTargetProperty();
+            const joinAlias = 'J' + (joinInfos.length + 1);
+            const join = innerJoin ? (0, builder_1.InnerJoin)(targetEntity.tableName + ' as ' + joinAlias) :
+                (0, builder_1.LeftOuterJoin)(targetEntity.tableName + ' as ' + joinAlias);
+            join.on((0, builder_1.Eq)((0, builder_1.Field)(joinAlias + '.' + targetCol.fieldName, targetCol.dataType, targetCol.isArray), (0, builder_1.Field)(parentAlias + '.' + keyCol.fieldName, keyCol.dataType, keyCol.isArray)));
+            if (node.conditions)
+                await prepareFilter(targetEntity, node.conditions, join._conditions, joinAlias);
+            joinInfo = {
+                association: node,
+                sourceEntity,
+                targetEntity,
+                joinAlias,
+                join
+            };
+            joinInfos.push(joinInfo);
+        }
+        result.push(joinInfo);
+        if (!node.next)
+            break;
+        parentAlias = joinInfo.joinAlias;
+        node = node.next;
+    }
+    return result;
+}
+exports.joinAssociation = joinAssociation;
+async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T') {
+    let srcOp;
+    if ((0, builder_1.isLogicalOperator)(filter))
+        srcOp = filter;
+    else {
+        srcOp = (0, builder_1.And)();
+        if (Array.isArray(filter))
+            srcOp.add(...filter);
+        else
+            srcOp.add(filter);
+    }
+    for (const item of srcOp._items) {
+        if ((0, builder_1.isLogicalOperator)(item)) {
+            const ctor = Object.getPrototypeOf(item).constructor;
+            const logOp = new ctor();
+            await prepareFilter(entityDef, item, logOp, tableAlias);
+            trgOp.add(logOp);
+            continue;
+        }
+        if ((0, builder_1.isCompOperator)(item)) {
+            if (typeof item._left === 'string') {
+                const itemPath = item._left.split('.');
+                const l = itemPath.length;
+                let pt;
+                let _curEntity = entityDef;
+                let _curAlias = tableAlias;
+                let _curPrefix = '';
+                let _curSuffix = '';
+                let subSelect;
+                for (let i = 0; i < l; i++) {
+                    pt = itemPath[i];
+                    const col = _curEntity.getElement(pt);
+                    if (!col)
+                        throw new Error(`Unknown property (${item._left}) defined in filter`);
+                    // if last item on path
+                    if (i === l - 1) {
+                        if (!(0, orm_helper_1.isColumnElement)(col))
+                            throw new Error(`Invalid column expression (${item._left}) defined in filter`);
+                        const ctor = Object.getPrototypeOf(item).constructor;
+                        trgOp.add(new ctor((0, builder_1.Field)(_curAlias + '.' + _curPrefix + col.fieldName + _curSuffix, col.dataType, col.isArray), item._right));
+                    }
+                    else {
+                        if ((0, orm_helper_1.isColumnElement)(col))
+                            throw new Error(`Invalid column (${item._left}) defined in filter`);
+                        if ((0, orm_helper_1.isObjectElement)(col)) {
+                            _curEntity = await col.resolveType();
+                            _curPrefix = _curPrefix + (col.fieldNamePrefix || '');
+                            _curSuffix = (col.fieldNameSuffix || '') + _curSuffix;
+                            continue;
+                        }
+                        if (!(0, orm_helper_1.isAssociationElement)(col))
+                            throw new Error(`Invalid column (${item._left}) defined in filter`);
+                        let node;
+                        _curEntity = await col.association.resolveTarget();
+                        if (!subSelect) {
+                            const keyCol = await col.association.resolveSourceProperty();
+                            const targetCol = await col.association.resolveTargetProperty();
+                            subSelect = (0, builder_1.Select)((0, builder_1.Raw)('1'))
+                                .from(_curEntity.tableName + ' K');
+                            subSelect.where((0, builder_1.Eq)((0, builder_1.Field)('K.' + targetCol.fieldName, targetCol.dataType, targetCol.isArray), (0, builder_1.Field)(tableAlias + '.' + keyCol.fieldName, keyCol.dataType, keyCol.isArray)));
+                            trgOp.add((0, builder_1.Exists)(subSelect));
+                            trgOp = subSelect._where;
+                            if (col.association.conditions) {
+                                await prepareFilter(_curEntity, col.association.conditions, trgOp, 'K');
+                            }
+                            node = col.association.next;
+                            _curAlias = 'K';
+                        }
+                        else
+                            node = col.association;
+                        while (node) {
+                            const targetEntity = await node.resolveTarget();
+                            const sourceColumn = await node.resolveSourceProperty();
+                            const targetColumn = await node.resolveTargetProperty();
+                            const joinAlias = 'J' + (((subSelect?._joins?.length) || 0) + 1);
+                            subSelect.join((0, builder_1.InnerJoin)(targetEntity.tableName + ' ' + joinAlias)
+                                .on((0, builder_1.Eq)((0, builder_1.Field)(joinAlias + '.' + targetColumn.fieldName, targetColumn.dataType, targetColumn.isArray), (0, builder_1.Field)(_curAlias + '.' + sourceColumn.fieldName, sourceColumn.dataType, sourceColumn.isArray))));
+                            _curEntity = targetEntity;
+                            _curAlias = joinAlias;
+                            node = node.next;
+                        }
+                    }
+                }
+                continue;
+            }
+        }
+        trgOp.add(item);
+    }
+}
+exports.prepareFilter = prepareFilter;

package/dist/orm/commands/count.command.d.ts

@@ -0,0 +1,11 @@
+import { EntityModel } from '../model/entity-model';
+import { Repository } from '../repository.class';
+import { SqbConnection } from '../../client/SqbConnection';
+export declare type CountCommandArgs = {
+    entity: EntityModel;
+    connection: SqbConnection;
+} & Repository.CountOptions;
+export declare class CountCommand {
+    protected constructor();
+    static execute(args: CountCommandArgs): Promise<number>;
+}

package/dist/orm/commands/count.command.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountCommand = void 0;
+const builder_1 = require("@sqb/builder");
+const command_helper_1 = require("./command.helper");
+class CountCommand {
+    // istanbul ignore next
+    constructor() {
+        throw new Error('This class is abstract');
+    }
+    static async execute(args) {
+        const { connection, entity, filter, params } = args;
+        let where;
+        if (filter) {
+            where = (0, builder_1.And)();
+            await (0, command_helper_1.prepareFilter)(entity, filter, where, 'T');
+        }
+        const query = (0, builder_1.Select)((0, builder_1.Count)()).from(entity.tableName + ' T');
+        if (where)
+            query.where(where);
+        // Execute query
+        const resp = await connection.execute(query, {
+            params,
+            objectRows: false,
+            cursor: false,
+        });
+        return (resp && resp.rows && resp.rows[0][0]) || 0;
+    }
+}
+exports.CountCommand = CountCommand;

package/dist/orm/commands/create.command.d.ts

@@ -0,0 +1,20 @@
+import type { EntityModel } from '../model/entity-model';
+import { SqbConnection } from '../../client/SqbConnection';
+export declare type CreateCommandArgs = {
+    entity: EntityModel;
+    connection: SqbConnection;
+    values: any;
+    returning?: boolean;
+};
+declare type CreateCommandContext = {
+    entity: EntityModel;
+    queryParams: any;
+    queryValues: any;
+    colCount: number;
+};
+export declare class CreateCommand {
+    protected constructor();
+    static execute(args: CreateCommandArgs): Promise<any>;
+    protected static _prepareParams(ctx: CreateCommandContext, entity: EntityModel, values: any, prefix?: string, suffix?: string): Promise<void>;
+}
+export {};

package/dist/orm/commands/create.command.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCommand = void 0;
+const builder_1 = require("@sqb/builder");
+const orm_helper_1 = require("../util/orm.helper");
+class CreateCommand {
+    // istanbul ignore next
+    constructor() {
+        throw new Error('This class is abstract');
+    }
+    static async execute(args) {
+        const { entity } = args;
+        const tableName = entity.tableName;
+        if (!tableName)
+            throw new Error(`${entity.ctor.name} is not decorated with @Entity decorator`);
+        // Create a context
+        const ctx = {
+            entity,
+            queryParams: {},
+            queryValues: {},
+            colCount: 0
+        };
+        // Prepare
+        await this._prepareParams(ctx, entity, args.values);
+        if (!ctx.colCount)
+            throw new Error('No element given to create new entity instance');
+        const query = (0, builder_1.Insert)(tableName, ctx.queryValues);
+        if (args.returning && entity.primaryIndex)
+            query.returning(...entity.getPrimaryIndexColumns().map(col => col.fieldName));
+        const qr = await args.connection.execute(query, {
+            params: ctx.queryParams,
+            objectRows: false,
+            cursor: false
+        });
+        if (args.returning && qr.fields && qr.rows?.length) {
+            const keyValues = {};
+            for (const f of qr.fields.values()) {
+                const el = entity.getColumnElementByFieldName(f.fieldName);
+                if (el)
+                    keyValues[el.name] = qr.rows[0][f.index];
+            }
+            return keyValues;
+        }
+    }
+    static async _prepareParams(ctx, entity, values, prefix, suffix) {
+        let v;
+        prefix = prefix || '';
+        suffix = suffix || '';
+        for (const col of entity.elements.values()) {
+            v = values[col.name];
+            if ((0, orm_helper_1.isColumnElement)(col)) {
+                if (col.noInsert)
+                    continue;
+                if (v == null && col.default !== undefined) {
+                    v = typeof col.default === 'function' ?
+                        col.default(values) : col.default;
+                }
+                if (typeof col.serialize === 'function')
+                    v = col.serialize(v, col.name);
+                if (v == null) {
+                    if (col.notNull && !col.autoGenerated)
+                        throw new Error(`${entity.name}.${col.name} is required and can't be null`);
+                    continue;
+                }
+                col.checkEnumValue(v);
+                const fieldName = prefix + col.fieldName + suffix;
+                const k = '$input_' + fieldName;
+                ctx.queryValues[fieldName] = (0, builder_1.Param)({
+                    name: k,
+                    dataType: col.dataType,
+                    isArray: col.isArray
+                });
+                ctx.queryParams[k] = v;
+                ctx.colCount++;
+            }
+            else if (v != null && (0, orm_helper_1.isObjectElement)(col)) {
+                const type = await col.resolveType();
+                await this._prepareParams(ctx, type, v, col.fieldNamePrefix, col.fieldNameSuffix);
+            }
+        }
+    }
+}
+exports.CreateCommand = CreateCommand;

package/dist/orm/commands/destroy.command.d.ts

@@ -0,0 +1,11 @@
+import { EntityModel } from '../model/entity-model';
+import { Repository } from '../repository.class';
+import { SqbConnection } from '../../client/SqbConnection';
+export declare type DestroyCommandArgs = {
+    entity: EntityModel;
+    connection: SqbConnection;
+} & Repository.DestroyOptions;
+export declare class DestroyCommand {
+    protected constructor();
+    static execute(args: DestroyCommandArgs): Promise<number>;
+}