@sqb/builder 4.0.7 → 4.0.8

package/dist/sql-objects/GroupColumn.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GroupColumn = void 0;
-const enums_1 = require("../enums");
-const BaseField_1 = require("./BaseField");
-const GROUP_COLUMN_PATTERN = /^((?:[a-zA-Z][\w$]*\.){0,2})([\w$]*)$/;
-class GroupColumn extends BaseField_1.BaseField {
-    constructor(value) {
-        super();
-        const m = value.match(GROUP_COLUMN_PATTERN);
-        if (!m)
-            throw new TypeError(`"${value}" does not match group column format`);
-        this._field = m[2];
-        if (m[1]) {
-            const a = m[1].split(/\./g);
-            a.pop();
-            this._table = a.pop();
-            this._schema = a.pop();
-        }
-    }
-    get _type() {
-        return enums_1.SerializationType.GROUP_COLUMN;
-    }
-    _serialize(ctx) {
-        const o = {
-            schema: this._schema,
-            table: this._table,
-            field: this._field,
-            isReservedWord: !!(this._field && ctx.isReservedWord(this._field))
-        };
-        return ctx.serialize(this._type, o, () => {
-            return (this._schema ? this._schema + '.' : '') +
-                (this._table ? this._table + '.' : '') +
-                (o.isReservedWord ? '"' + this._field + '"' : this._field);
-        });
-    }
-}
-exports.GroupColumn = GroupColumn;

package/dist/sql-objects/JoinStatement.d.ts

@@ -1,17 +0,0 @@
-import { Serializable } from '../Serializable';
-import { JoinType, SerializationType } from '../enums';
-import { TableName } from './TableName';
-import { SelectQuery } from '../query/SelectQuery';
-import { RawStatement } from './RawStatement';
-import { LogicalOperator } from './operators/LogicalOperator';
-import { SerializeContext } from '../SerializeContext';
-export declare class JoinStatement extends Serializable {
-    _joinType: JoinType;
-    _table: TableName | SelectQuery | RawStatement;
-    _conditions: LogicalOperator;
-    constructor(joinType: JoinType, table: string | TableName | SelectQuery | RawStatement);
-    get _type(): SerializationType;
-    on(...conditions: Serializable[]): this;
-    _serialize(ctx: SerializeContext): string;
-    protected __serializeConditions(ctx: any, join: JoinStatement): any;
-}

package/dist/sql-objects/JoinStatement.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JoinStatement = void 0;
-const Serializable_1 = require("../Serializable");
-const enums_1 = require("../enums");
-const TableName_1 = require("./TableName");
-const OpAnd_1 = require("./operators/OpAnd");
-const typeguards_1 = require("../typeguards");
-class JoinStatement extends Serializable_1.Serializable {
-    constructor(joinType, table) {
-        super();
-        this._conditions = new OpAnd_1.OpAnd();
-        // noinspection SuspiciousTypeOfGuard
-        if (!((0, typeguards_1.isSelectQuery)(table) || (0, typeguards_1.isRawStatement)(table) || (0, typeguards_1.isTableName)(table) ||
-            typeof table === 'string'))
-            throw new TypeError('Table name, select query or raw object required for Join');
-        this._joinType = joinType;
-        this._table = typeof table === 'string' ? new TableName_1.TableName(table) : table;
-    }
-    get _type() {
-        return enums_1.SerializationType.JOIN;
-    }
-    on(...conditions) {
-        this._conditions.add(...conditions);
-        return this;
-    }
-    _serialize(ctx) {
-        const o = {
-            joinType: this._joinType,
-            table: this._table._serialize(ctx),
-            conditions: this.__serializeConditions(ctx, this)
-        };
-        return ctx.serialize(this._type, o, () => {
-            let out;
-            switch (this._joinType) {
-                case enums_1.JoinType.LEFT:
-                    out = 'left join';
-                    break;
-                case enums_1.JoinType.LEFT_OUTER:
-                    out = 'left outer join';
-                    break;
-                case enums_1.JoinType.RIGHT:
-                    out = 'right join';
-                    break;
-                case enums_1.JoinType.RIGHT_OUTER:
-                    out = 'right outer join';
-                    break;
-                case enums_1.JoinType.OUTER:
-                    out = 'outer join';
-                    break;
-                case enums_1.JoinType.FULL_OUTER:
-                    out = 'full outer join';
-                    break;
-                default:
-                    out = 'inner join';
-                    break;
-            }
-            const lf = o.table.length > 40;
-            if ((0, typeguards_1.isSelectQuery)(this._table)) {
-                const alias = this._table._alias;
-                if (!alias)
-                    throw new Error('Alias required for sub-select in Join');
-                out += ' (' + (lf ? '\n\t' : '') + o.table + (lf ? '\n\b' : '') + ')' +
-                    ' ' + alias;
-            }
-            else
-                out += ' ' + o.table;
-            if (o.conditions)
-                out += ' ' + o.conditions;
-            return out + (lf ? '\b' : '');
-        });
-    }
-    __serializeConditions(ctx, join) {
-        if (join._conditions._items.length) {
-            const s = join._conditions._serialize(ctx);
-            return ctx.serialize(enums_1.SerializationType.JOIN_CONDITIONS, s, () => s ? 'on ' + s : '');
-        }
-        return '';
-    }
-}
-exports.JoinStatement = JoinStatement;

package/dist/sql-objects/Operator.d.ts

@@ -1,5 +0,0 @@
-import { Serializable } from '../Serializable';
-import { OperatorType } from '../enums';
-export declare abstract class Operator extends Serializable {
-    abstract _operatorType: OperatorType;
-}

package/dist/sql-objects/Operator.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Operator = void 0;
-const Serializable_1 = require("../Serializable");
-class Operator extends Serializable_1.Serializable {
-}
-exports.Operator = Operator;

package/dist/sql-objects/OrderColumn.d.ts

@@ -1,9 +0,0 @@
-import { SerializationType } from '../enums';
-import { BaseField } from './BaseField';
-import { SerializeContext } from '../SerializeContext';
-export declare class OrderColumn extends BaseField {
-    _descending?: boolean;
-    constructor(value: string);
-    get _type(): SerializationType;
-    _serialize(ctx: SerializeContext): string;
-}

package/dist/sql-objects/OrderColumn.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrderColumn = void 0;
-const enums_1 = require("../enums");
-const BaseField_1 = require("./BaseField");
-const ORDER_COLUMN_PATTERN = /^([-+])?((?:[a-zA-Z][\w$]*\.){0,2})([a-zA-Z][\w$]*|\*) *(asc|dsc|desc|ascending|descending)?$/i;
-class OrderColumn extends BaseField_1.BaseField {
-    constructor(value) {
-        super();
-        const m = value.match(ORDER_COLUMN_PATTERN);
-        if (!m)
-            throw new TypeError(`"${value}" does not match order column format`);
-        this._field = m[3];
-        if (m[2]) {
-            const a = m[2].split(/\./g);
-            a.pop();
-            this._table = a.pop();
-            this._schema = a.pop();
-        }
-        this._descending = !!((m[1] === '-') ||
-            (!m[1] && m[4] && ['dsc', 'desc', 'descending'].includes(m[4].toLowerCase())));
-    }
-    get _type() {
-        return enums_1.SerializationType.ORDER_COLUMN;
-    }
-    _serialize(ctx) {
-        const o = {
-            schema: this._schema,
-            table: this._table,
-            field: this._field,
-            descending: !!this._descending,
-            isReservedWord: !!(this._field && ctx.isReservedWord(this._field))
-        };
-        return ctx.serialize(this._type, o, () => {
-            return (o.schema ? o.schema + '.' : '') +
-                (o.table ? o.table + '.' : '') +
-                (o.isReservedWord ? '"' + o.field + '"' : o.field) +
-                (o.descending ? ' desc' : '');
-        });
-    }
-}
-exports.OrderColumn = OrderColumn;

package/dist/sql-objects/ParamExpression.d.ts

@@ -1,23 +0,0 @@
-import { Serializable } from '../Serializable';
-import { DataType, SerializationType } from '../enums';
-import { SerializeContext } from '../SerializeContext';
-export declare class ParamExpression extends Serializable {
-    _name: string;
-    _dataType?: DataType;
-    _isArray?: boolean;
-    constructor(arg: string | {
-        name: string;
-        dataType?: DataType;
-        isArray?: boolean;
-    });
-    get _type(): SerializationType;
-    /**
-     * Performs serialization
-     */
-    _serialize(ctx: SerializeContext): string;
-    protected __defaultSerialize(ctx: SerializeContext, o: {
-        name: string;
-        dataType?: DataType;
-        isArray?: boolean;
-    }): string;
-}

package/dist/sql-objects/ParamExpression.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParamExpression = void 0;
-const Serializable_1 = require("../Serializable");
-const enums_1 = require("../enums");
-class ParamExpression extends Serializable_1.Serializable {
-    constructor(arg) {
-        super();
-        if (typeof arg === 'object') {
-            this._name = arg.name;
-            this._dataType = arg.dataType;
-            this._isArray = arg.isArray;
-        }
-        else
-            this._name = arg;
-    }
-    get _type() {
-        return enums_1.SerializationType.EXTERNAL_PARAMETER;
-    }
-    /**
-     * Performs serialization
-     */
-    _serialize(ctx) {
-        const o = {
-            name: this._name,
-            dataType: this._dataType,
-            isArray: this._isArray,
-        };
-        return ctx.serialize(this._type, o, () => this.__defaultSerialize(ctx, o));
-    }
-    __defaultSerialize(ctx, o) {
-        let prmValue = (ctx.params && ctx.params[o.name]) ?? null;
-        if (prmValue != null && o.isArray && !Array.isArray(prmValue))
-            prmValue = [prmValue];
-        ctx.preparedParams = ctx.preparedParams || {};
-        if (Array.isArray(ctx.preparedParams))
-            ctx.preparedParams.push(prmValue);
-        else
-            ctx.preparedParams[o.name] = prmValue;
-        const paramOps = {
-            dataType: this._dataType,
-            isArray: this._isArray,
-        };
-        ctx.paramOptions = ctx.paramOptions ||
-            (Array.isArray(ctx.preparedParams) ? [] : {});
-        if (Array.isArray(ctx.paramOptions))
-            ctx.paramOptions.push(paramOps);
-        else
-            ctx.paramOptions[o.name] = paramOps;
-        return ':' + o.name;
-    }
-}
-exports.ParamExpression = ParamExpression;

package/dist/sql-objects/RawStatement.d.ts

@@ -1,9 +0,0 @@
-import { Serializable } from '../Serializable';
-import { SerializationType } from '../enums';
-import { SerializeContext } from '../SerializeContext';
-export declare class RawStatement extends Serializable {
-    _text: string;
-    constructor(str: string);
-    get _type(): SerializationType;
-    _serialize(ctx: SerializeContext): string;
-}

package/dist/sql-objects/RawStatement.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RawStatement = void 0;
-const Serializable_1 = require("../Serializable");
-const enums_1 = require("../enums");
-class RawStatement extends Serializable_1.Serializable {
-    constructor(str) {
-        super();
-        this._text = str;
-    }
-    get _type() {
-        return enums_1.SerializationType.RAW;
-    }
-    _serialize(ctx) {
-        return ctx.serialize(this._type, this._text, () => this._text);
-    }
-}
-exports.RawStatement = RawStatement;

package/dist/sql-objects/ReturningColumn.d.ts

@@ -1,9 +0,0 @@
-import { SerializationType } from '../enums';
-import { BaseField } from './BaseField';
-import { SerializeContext } from '../SerializeContext';
-export declare class ReturningColumn extends BaseField {
-    _alias: string;
-    constructor(field: string);
-    get _type(): SerializationType;
-    _serialize(ctx: SerializeContext): string;
-}

package/dist/sql-objects/ReturningColumn.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReturningColumn = void 0;
-const enums_1 = require("../enums");
-const BaseField_1 = require("./BaseField");
-const RETURNING_COLUMN_PATTERN = /^([a-zA-Z]\w*) *(?:as)? *(\w+)?$/;
-class ReturningColumn extends BaseField_1.BaseField {
-    constructor(field) {
-        super();
-        const m = field.match(RETURNING_COLUMN_PATTERN);
-        if (!m)
-            throw new TypeError(`"${field}" does not match returning column format`);
-        this._field = m[1];
-        this._alias = m[2];
-    }
-    get _type() {
-        return enums_1.SerializationType.RETURNING_COLUMN;
-    }
-    _serialize(ctx) {
-        const o = {
-            field: this._field,
-            alias: this._alias
-        };
-        ctx.returningFields = ctx.returningFields || [];
-        ctx.returningFields.push(o);
-        return ctx.serialize(this._type, o, () => {
-            return ctx.escapeReserved(o.field) +
-                (o.alias ? ' as ' + ctx.escapeReserved(o.alias) : '');
-        });
-    }
-}
-exports.ReturningColumn = ReturningColumn;

package/dist/sql-objects/TableName.d.ts

@@ -1,11 +0,0 @@
-import { Serializable } from '../Serializable';
-import { SerializationType } from '../enums';
-import { SerializeContext } from '../SerializeContext';
-export declare class TableName extends Serializable {
-    schema?: string;
-    table?: string;
-    alias?: string;
-    constructor(tableName: string);
-    get _type(): SerializationType;
-    _serialize(ctx: SerializeContext): string;
-}

package/dist/sql-objects/TableName.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableName = void 0;
-const Serializable_1 = require("../Serializable");
-const enums_1 = require("../enums");
-class TableName extends Serializable_1.Serializable {
-    constructor(tableName) {
-        super();
-        const m = tableName.match(/^(?:([a-zA-Z][\w$]*)\.)? *([a-zA-Z][\w$]*) *(?:as)? *(\w+)?$/);
-        if (!m)
-            throw new TypeError(`(${tableName}) does not match table name format`);
-        if (m[1])
-            this.schema = m[1];
-        if (m[2])
-            this.table = m[2];
-        if (m[3])
-            this.alias = m[3];
-    }
-    get _type() {
-        return enums_1.SerializationType.TABLE_NAME;
-    }
-    _serialize(ctx) {
-        return ctx.serialize(this._type, {
-            schema: this.schema,
-            table: this.table,
-            alias: this.alias
-        }, () => (this.schema ? this.schema + '.' : '') + this.table +
-            (this.alias ? ' ' + this.alias : ''));
-    }
-}
-exports.TableName = TableName;

package/dist/sql-objects/operators/CompOperator.d.ts

@@ -1,16 +0,0 @@
-import { Operator } from '../Operator';
-import { Serializable } from '../../Serializable';
-import { SerializationType } from '../../enums';
-import { SerializeContext } from '../../SerializeContext';
-export declare abstract class CompOperator extends Operator {
-    _left: Serializable | string;
-    _right?: any | Serializable;
-    _symbol?: string;
-    _isArray?: boolean;
-    protected constructor(left: string | Serializable, right?: any);
-    get _type(): SerializationType;
-    _serialize(ctx: SerializeContext): string;
-    protected __serializeItem(ctx: SerializeContext, x: any, isRight?: boolean): any;
-    protected __serialize(ctx: SerializeContext, o: any): string;
-    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
-}

package/dist/sql-objects/operators/CompOperator.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompOperator = void 0;
-const Operator_1 = require("../Operator");
-const Serializable_1 = require("../../Serializable");
-const enums_1 = require("../../enums");
-const typeguards_1 = require("../../typeguards");
-const sqlobject_initializers_1 = require("../../sqlobject.initializers");
-const ParamExpression_1 = require("../ParamExpression");
-const FieldExpression_1 = require("../FieldExpression");
-const EXPRESSION_PATTERN = /^([\w\\.$]+)(\[])?/;
-class CompOperator extends Operator_1.Operator {
-    constructor(left, right) {
-        super();
-        if (typeof left === 'string') {
-            const m = left.match(EXPRESSION_PATTERN);
-            if (!m)
-                throw new TypeError(`"${left}" is not a valid expression definition`);
-            this._left = m[1];
-            this._isArray = !!m[2];
-        }
-        else
-            this._left = left;
-        this._right = right;
-    }
-    get _type() {
-        return enums_1.SerializationType.COMPARISON_EXPRESSION;
-    }
-    _serialize(ctx) {
-        const left = this.__serializeItem(ctx, this._left);
-        if (this._isArray)
-            left.isArray = true;
-        const right = this.__serializeItem(ctx, this._right, true);
-        const o = {
-            operatorType: this._operatorType,
-            symbol: this._symbol,
-            left,
-            right
-        };
-        return this.__serialize(ctx, o);
-    }
-    __serializeItem(ctx, x, isRight) {
-        if (ctx.strictParams && !(x instanceof Serializable_1.Serializable) &&
-            (typeof x !== 'string' || isRight)) {
-            ctx.strictParamGenId = ctx.strictParamGenId || 0;
-            const name = 'strictParam$' + ++ctx.strictParamGenId;
-            ctx.params = ctx.params || {};
-            ctx.params[name] = x;
-            x = (0, sqlobject_initializers_1.Param)(name);
-        }
-        if (x instanceof Serializable_1.Serializable) {
-            const expression = x._serialize(ctx);
-            const result = {
-                expression: (0, typeguards_1.isSelectQuery)(x) ? '(' + expression + ')' : expression
-            };
-            if (x instanceof FieldExpression_1.FieldExpression) {
-                result.dataType = result._dataType;
-                result.isArray = x._isArray;
-            }
-            if (x instanceof ParamExpression_1.ParamExpression) {
-                let value = ctx.params ? ctx.params[x._name] : undefined;
-                if (x._isArray && value != null)
-                    value = [value];
-                result.value = value;
-                result.isArray = x._isArray || Array.isArray(value);
-                result.isParam = true;
-            }
-            return result;
-        }
-        else {
-            const result = {
-                expression: (isRight || typeof x !== 'string') ?
-                    ctx.anyToSQL(x) : x
-            };
-            if (isRight || typeof x !== 'string')
-                result.isArray = Array.isArray(x);
-            return result;
-        }
-    }
-    __serialize(ctx, o) {
-        return ctx.serialize(this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
-    }
-    __defaultSerialize(ctx, o) {
-        return o.left.expression + ' ' + o.symbol + ' ' + o.right.expression;
-    }
-}
-exports.CompOperator = CompOperator;

package/dist/sql-objects/operators/LogicalOperator.d.ts

@@ -1,16 +0,0 @@
-import { Operator } from '../Operator';
-import { SerializationType } from '../../enums';
-import { Serializable } from '../../Serializable';
-import { SerializeContext } from '../../SerializeContext';
-export declare const WrapOps: {};
-export declare abstract class LogicalOperator extends Operator {
-    _items: Serializable[];
-    constructor(...expressions: any[]);
-    get _type(): SerializationType;
-    /**
-     * Adds operator(s) to item list
-     */
-    add(...expressions: (LogicalOperator | any)[]): this;
-    _serialize(ctx: SerializeContext): string;
-    private _wrapObject;
-}

package/dist/sql-objects/operators/LogicalOperator.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogicalOperator = exports.WrapOps = void 0;
-const tslib_1 = require("tslib");
-const Operator_1 = require("../Operator");
-const putil_isplainobject_1 = (0, tslib_1.__importDefault)(require("putil-isplainobject"));
-const enums_1 = require("../../enums");
-const typeguards_1 = require("../../typeguards");
-const helpers_1 = require("../../helpers");
-exports.WrapOps = {};
-// noinspection RegExpUnnecessaryNonCapturingGroup
-const COMPARE_LEFT_PATTERN = /^([\w\\.$]+(?:\[])?) *(.*)$/;
-class LogicalOperator extends Operator_1.Operator {
-    constructor(...expressions) {
-        super();
-        this._items = [];
-        this.add(...expressions);
-    }
-    get _type() {
-        return enums_1.SerializationType.LOGICAL_EXPRESSION;
-    }
-    /**
-     * Adds operator(s) to item list
-     */
-    add(...expressions) {
-        for (const item of expressions) {
-            if (!item)
-                continue;
-            if ((0, typeguards_1.isLogicalOperator)(item)) {
-                this._items.push(item);
-            }
-            else if ((0, typeguards_1.isRawStatement)(item) || (0, typeguards_1.isCompOperator)(item)) {
-                this._items.push(item);
-            }
-            else if ((0, putil_isplainobject_1.default)(item)) {
-                this.add(...this._wrapObject(item));
-            }
-            else
-                throw new TypeError('Operator or Raw type required');
-        }
-        return this;
-    }
-    _serialize(ctx) {
-        const arr = [];
-        for (const t of this._items) {
-            const s = t._serialize(ctx);
-            /* istanbul ignore else */
-            if (s)
-                arr.push((0, typeguards_1.isLogicalOperator)(t) ? '(' + s + ')' : s);
-        }
-        return ctx.serialize(enums_1.SerializationType.LOGICAL_EXPRESSION, arr, () => {
-            const s = (0, helpers_1.printArray)(arr, ' ' + String(this._operatorType));
-            return (s.indexOf('\n') > 0) ? s.replace('\n', '\n\t') + '\b' : s;
-        });
-    }
-    _wrapObject(obj) {
-        const result = [];
-        for (const n of Object.getOwnPropertyNames(obj)) {
-            let op;
-            const v = obj[n];
-            if (['and', 'or'].includes(n.toLowerCase())) {
-                op = exports.WrapOps[n.toLowerCase()];
-                if (!op)
-                    throw new Error(`Unknown operator "${n}"`);
-                result.push(Array.isArray(v) ? op(...v) : op(v));
-                continue;
-            }
-            if (['exists', '!exists'].includes(n))
-                result.push(exports.WrapOps[n](obj[n]));
-            else {
-                const m = n.match(COMPARE_LEFT_PATTERN);
-                if (!m)
-                    throw new TypeError(`"${n}" is not a valid expression definition`);
-                op = exports.WrapOps[m[2] || 'eq'];
-                if (!op)
-                    throw new Error(`Unknown operator "${m[2]}"`);
-                result.push(op(m[1], obj[n]));
-            }
-        }
-        return result;
-    }
-}
-exports.LogicalOperator = LogicalOperator;

package/dist/sql-objects/operators/OpAnd.d.ts

@@ -1,5 +0,0 @@
-import { LogicalOperator } from './LogicalOperator';
-import { OperatorType } from '../../enums';
-export declare class OpAnd extends LogicalOperator {
-    _operatorType: OperatorType;
-}

package/dist/sql-objects/operators/OpAnd.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpAnd = void 0;
-const LogicalOperator_1 = require("./LogicalOperator");
-const enums_1 = require("../../enums");
-class OpAnd extends LogicalOperator_1.LogicalOperator {
-    constructor() {
-        super(...arguments);
-        this._operatorType = enums_1.OperatorType.and;
-    }
-}
-exports.OpAnd = OpAnd;

package/dist/sql-objects/operators/OpBetween.d.ts

@@ -1,11 +0,0 @@
-import { CompOperator } from './CompOperator';
-import { Serializable } from '../../Serializable';
-import { OperatorType } from '../../enums';
-import { SerializeContext } from '../../SerializeContext';
-export declare class OpBetween extends CompOperator {
-    _operatorType: OperatorType;
-    _symbol: string;
-    constructor(left: string | Serializable, right: any[]);
-    _serialize(ctx: SerializeContext): string;
-    __defaultSerialize(ctx: any, o: any): string;
-}