@sqb/builder 4.0.9 → 4.0.13

package/dist/query/SelectQuery.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectQuery = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+const Query_1 = require("./Query");
+const TableName_1 = require("../sql-objects/TableName");
+const FieldExpression_1 = require("../sql-objects/FieldExpression");
+const enums_1 = require("../enums");
+const GroupColumn_1 = require("../sql-objects/GroupColumn");
+const OrderColumn_1 = require("../sql-objects/OrderColumn");
+const OpAnd_1 = require("../sql-objects/operators/OpAnd");
+const typeguards_1 = require("../typeguards");
+const helpers_1 = require("../helpers");
+class SelectQuery extends Query_1.Query {
+    constructor(...column) {
+        super();
+        if (column.length)
+            this.addColumn(...column);
+    }
+    get _type() {
+        return enums_1.SerializationType.SELECT_QUERY;
+    }
+    /**
+     * Adds columns to query.
+     */
+    addColumn(...column) {
+        const self = this;
+        this._columns = this._columns || [];
+        for (const arg of column) {
+            if (!arg)
+                continue;
+            if (Array.isArray(arg))
+                self.addColumn(...arg);
+            else
+                this._columns.push((0, typeguards_1.isSerializable)(arg) ? arg : new FieldExpression_1.FieldExpression(arg));
+        }
+        return this;
+    }
+    /**
+     * Defines "from" part of  query.
+     */
+    from(...table) {
+        this._tables = [];
+        for (const arg of table) {
+            if (!arg)
+                continue;
+            this._tables.push(typeof arg === 'string' ? new TableName_1.TableName(arg) : arg);
+        }
+        return this;
+    }
+    /**
+     * Adds "join" statements to query
+     */
+    join(...join) {
+        this._joins = this._joins || [];
+        for (const arg of join) {
+            if (!arg)
+                continue;
+            if (!(0, typeguards_1.isJoinStatement)(arg))
+                throw new TypeError('Join statement required');
+            this._joins.push(arg);
+        }
+        return this;
+    }
+    /**
+     * Defines "where" part of query
+     */
+    where(...condition) {
+        this._where = this._where || new OpAnd_1.OpAnd();
+        this._where.add(...condition);
+        return this;
+    }
+    /**
+     * Defines "where" part of query
+     */
+    groupBy(...field) {
+        this._groupBy = this._groupBy || [];
+        for (const arg of field) {
+            if (!arg)
+                continue;
+            this._groupBy.push(typeof arg === 'string' ? new GroupColumn_1.GroupColumn(arg) : arg);
+        }
+        return this;
+    }
+    /**
+     * Defines "order by" part of query.
+     */
+    orderBy(...field) {
+        this._orderBy = this._orderBy || [];
+        for (const arg of field) {
+            if (!arg)
+                continue;
+            this._orderBy.push(typeof arg === 'string' ? new OrderColumn_1.OrderColumn(arg) : arg);
+        }
+        return this;
+    }
+    /**
+     * Sets alias for sub-select queries
+     */
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    /**
+     * Sets limit for query
+     */
+    limit(limit) {
+        this._limit = (0, putil_varhelpers_1.coerceToInt)(limit);
+        return this;
+    }
+    /**
+     * Sets offset for query
+     */
+    offset(offset) {
+        this._offset = (0, putil_varhelpers_1.coerceToInt)(offset);
+        return this;
+    }
+    /**
+     * Enables distinct mode
+     */
+    distinct() {
+        this._distinct = true;
+        return this;
+    }
+    onFetch(listener) {
+        this.on('fetch', listener);
+        return this;
+    }
+    onceFetch(listener) {
+        this.once('fetch', listener);
+        return this;
+    }
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx) {
+        const o = {
+            columns: this.__serializeSelectColumns(ctx),
+            from: this.__serializeFrom(ctx),
+            join: this.__serializeJoins(ctx),
+            where: this.__serializeWhere(ctx),
+            groupBy: this.__serializeGroupColumns(ctx),
+            orderBy: this.__serializeOrderColumns(ctx),
+            limit: this._limit,
+            offset: this._offset
+        };
+        return ctx.serialize(this._type, o, () => {
+            let out = 'select';
+            if (this._distinct)
+                out += ' distinct';
+            // columns part
+            /* istanbul ignore else */
+            if (o.columns) {
+                out += (o.columns.indexOf('\n') >= 0) ?
+                    '\n\t' + o.columns + '\b' :
+                    ' ' + o.columns;
+            }
+            // from part
+            if (o.from) {
+                out += (o.columns.length > 60 ||
+                    o.columns.indexOf('\n') >= 0 ? '\n' : ' ') +
+                    o.from;
+            }
+            // join part
+            if (o.join)
+                out += '\n' + o.join;
+            // where part
+            if (o.where)
+                out += '\n' + o.where;
+            // group by part
+            if (o.groupBy)
+                out += '\n' + o.groupBy;
+            // order by part
+            if (o.orderBy)
+                out += '\n' + o.orderBy;
+            return out;
+        });
+    }
+    /**
+     *
+     */
+    __serializeSelectColumns(ctx) {
+        const arr = [];
+        if (this._columns)
+            for (const t of this._columns) {
+                const s = t._serialize(ctx);
+                if (s) {
+                    if (t instanceof SelectQuery) {
+                        if (!t._alias)
+                            throw new TypeError('Alias required for sub-select in columns');
+                        arr.push('(' + s + ') ' + t._alias);
+                    }
+                    else
+                        arr.push(s);
+                }
+            }
+        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_COLUMNS, arr, () => (0, helpers_1.printArray)(arr) || '*');
+    }
+    /**
+     *
+     */
+    __serializeFrom(ctx) {
+        const arr = [];
+        if (this._tables)
+            for (const t of this._tables) {
+                const s = t._serialize(ctx);
+                /* istanbul ignore else */
+                if (s) {
+                    if (t instanceof SelectQuery) {
+                        if (!t._alias)
+                            throw new TypeError('Alias required for sub-select in "from"');
+                        arr.push('\n\t(' + s + ') ' + t._alias);
+                    }
+                    else
+                        arr.push(s);
+                }
+            }
+        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_FROM, arr, () => {
+            const s = arr.join(',');
+            return s ? ('from' + (s.substring(0, 1) !== '\n' ? ' ' : '') + s) : '';
+        });
+    }
+    /**
+     *
+     */
+    __serializeJoins(ctx) {
+        const arr = [];
+        if (this._joins)
+            for (const t of this._joins) {
+                const s = t._serialize(ctx);
+                /* istanbul ignore else */
+                if (s)
+                    arr.push(s);
+            }
+        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_JOIN, arr, () => {
+            return arr.join('\n');
+        });
+    }
+    /**
+     *
+     */
+    __serializeWhere(ctx) {
+        if (!this._where)
+            return '';
+        const s = this._where._serialize(ctx);
+        return ctx.serialize(enums_1.SerializationType.CONDITIONS_BLOCK, s, () => {
+            /* istanbul ignore next */
+            return s ? 'where ' + s : '';
+        });
+    }
+    /**
+     *
+     */
+    __serializeGroupColumns(ctx) {
+        const arr = [];
+        if (this._groupBy)
+            for (const t of this._groupBy) {
+                const s = t._serialize(ctx);
+                /* istanbul ignore else */
+                if (s)
+                    arr.push(s);
+            }
+        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_GROUPBY, arr, () => {
+            const s = (0, helpers_1.printArray)(arr);
+            return s ? 'group by ' + s : '';
+        });
+    }
+    __serializeOrderColumns(ctx) {
+        const arr = [];
+        if (this._orderBy)
+            for (const t of this._orderBy) {
+                const s = t._serialize(ctx);
+                /* istanbul ignore else */
+                if (s)
+                    arr.push(s);
+            }
+        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_ORDERBY, arr, () => {
+            const s = (0, helpers_1.printArray)(arr);
+            return s ? 'order by ' + s : '';
+        });
+    }
+}
+exports.SelectQuery = SelectQuery;

package/dist/query/UpdateQuery.d.ts

@@ -0,0 +1,29 @@
+import { ReturningQuery } from './ReturningQuery';
+import { SerializationType } from '../enums';
+import { RawStatement } from '../sql-objects/RawStatement';
+import { TableName } from '../sql-objects/TableName';
+import { LogicalOperator } from '../sql-objects/operators/LogicalOperator';
+import { SerializeContext } from '../SerializeContext';
+export declare class UpdateQuery extends ReturningQuery {
+    _table: TableName | RawStatement;
+    _input: any;
+    _where?: LogicalOperator;
+    constructor(tableName: string | RawStatement, input: any);
+    get _type(): SerializationType;
+    /**
+     * Defines "where" part of query
+     */
+    where(...operator: any[]): this;
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeValues(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeWhere(ctx: SerializeContext): string;
+}

package/dist/query/UpdateQuery.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateQuery = void 0;
+const ReturningQuery_1 = require("./ReturningQuery");
+const enums_1 = require("../enums");
+const TableName_1 = require("../sql-objects/TableName");
+const OpAnd_1 = require("../sql-objects/operators/OpAnd");
+const typeguards_1 = require("../typeguards");
+const helpers_1 = require("../helpers");
+class UpdateQuery extends ReturningQuery_1.ReturningQuery {
+    constructor(tableName, input) {
+        super();
+        if (!tableName || !(typeof tableName === 'string' || (0, typeguards_1.isRawStatement)(tableName)))
+            throw new TypeError('String or Raw instance required as first argument (tableName) for UpdateQuery');
+        if (!input || !((typeof input === 'object' && !Array.isArray(input)) ||
+            input.isSelect))
+            throw new TypeError('Object or Raw instance required as second argument (input) for UpdateQuery');
+        this._table = typeof tableName === 'string' ? new TableName_1.TableName(tableName) : tableName;
+        this._input = input;
+    }
+    get _type() {
+        return enums_1.SerializationType.UPDATE_QUERY;
+    }
+    /**
+     * Defines "where" part of query
+     */
+    where(...operator) {
+        this._where = this._where || new OpAnd_1.OpAnd();
+        this._where.add(...operator);
+        return this;
+    }
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx) {
+        const o = {
+            table: this._table._serialize(ctx),
+            values: this.__serializeValues(ctx),
+            where: this.__serializeWhere(ctx),
+            returning: this.__serializeReturning(ctx)
+        };
+        let out = 'update ' + o.table + ' set \n\t' + o.values + '\b';
+        if (o.where)
+            out += '\n' + o.where;
+        if (o.returning)
+            out += '\n' + o.returning;
+        return out;
+    }
+    /**
+     *
+     */
+    __serializeValues(ctx) {
+        const arr = [];
+        const allValues = this._input;
+        for (const n of Object.getOwnPropertyNames(allValues)) {
+            const value = ctx.anyToSQL(allValues[n]);
+            arr.push({
+                field: n,
+                value: (0, typeguards_1.isSelectQuery)(allValues[n]) ? '(' + value + ')' : value
+            });
+        }
+        return ctx.serialize(enums_1.SerializationType.UPDATE_QUERY_VALUES, arr, () => {
+            const a = arr.map(o => o.field + ' = ' + o.value);
+            return (0, helpers_1.printArray)(a, ',');
+        });
+    }
+    /**
+     *
+     */
+    __serializeWhere(ctx) {
+        if (!this._where)
+            return '';
+        const s = this._where._serialize(ctx);
+        return ctx.serialize(enums_1.SerializationType.CONDITIONS_BLOCK, s, () => {
+            /* istanbul ignore next */
+            return s ? 'where ' + s : '';
+        });
+    }
+}
+exports.UpdateQuery = UpdateQuery;

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

@@ -0,0 +1,7 @@
+import { Expression } from './Expression';
+export declare abstract class BaseField extends Expression {
+    _field: string;
+    _schema?: string;
+    _table?: string;
+    _descending?: boolean;
+}

package/dist/sql-objects/BaseField.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseField = void 0;
+const Expression_1 = require("./Expression");
+class BaseField extends Expression_1.Expression {
+    constructor() {
+        super(...arguments);
+        this._field = '';
+    }
+}
+exports.BaseField = BaseField;

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

@@ -0,0 +1,42 @@
+import { Serializable } from '../Serializable';
+import { SerializationType } from '../enums';
+import { LogicalOperator } from './operators/LogicalOperator';
+import { Operator } from './Operator';
+import { RawStatement } from './RawStatement';
+import { SerializeContext } from '../SerializeContext';
+export declare class CaseStatement extends Serializable {
+    _expressions: {
+        condition: Serializable;
+        value: any;
+    }[];
+    _elseValue: any;
+    _condition?: LogicalOperator;
+    _alias?: string;
+    constructor();
+    get _type(): SerializationType;
+    /**
+     * Defines "when" part of Case expression.
+     */
+    when(...condition: (Operator | RawStatement)[]): this;
+    /**
+     * Defines "then" part of Case expression.
+     */
+    then(value: any): this;
+    /**
+     * Defines "else" part of Case expression.
+     */
+    else(value: any): this;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}

package/dist/sql-objects/CaseStatement.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseStatement = void 0;
+const Serializable_1 = require("../Serializable");
+const enums_1 = require("../enums");
+const OpAnd_1 = require("./operators/OpAnd");
+class CaseStatement extends Serializable_1.Serializable {
+    constructor() {
+        super();
+        this._expressions = [];
+    }
+    get _type() {
+        return enums_1.SerializationType.CASE_STATEMENT;
+    }
+    /**
+     * Defines "when" part of Case expression.
+     */
+    when(...condition) {
+        if (condition.length)
+            this._condition = new OpAnd_1.OpAnd(...condition);
+        else
+            this._condition = undefined;
+        return this;
+    }
+    /**
+     * Defines "then" part of Case expression.
+     */
+    then(value) {
+        if (this._condition)
+            this._expressions.push({
+                condition: this._condition,
+                value
+            });
+        return this;
+    }
+    /**
+     * Defines "else" part of Case expression.
+     */
+    else(value) {
+        this._elseValue = value;
+        return this;
+    }
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx) {
+        if (!this._expressions.length)
+            return '';
+        const q = {
+            expressions: [],
+            elseValue: this._elseValue !== undefined ?
+                ctx.anyToSQL(this._elseValue) : undefined
+        };
+        for (const x of this._expressions) {
+            const o = {
+                condition: x.condition._serialize(ctx),
+                value: ctx.anyToSQL(x.value)
+            };
+            q.expressions.push(o);
+        }
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        let out = 'case\n\t';
+        for (const x of o.expressions) {
+            out += 'when ' + x.condition + ' then ' + x.value + '\n';
+        }
+        if (o.elseValue !== undefined)
+            out += 'else ' + o.elseValue + '\n';
+        out += '\bend' + (this._alias ? ' ' + this._alias : '');
+        return out;
+    }
+}
+exports.CaseStatement = CaseStatement;

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

@@ -0,0 +1,20 @@
+import { Serializable } from '../Serializable';
+import { SerializationType } from '../enums';
+import { SerializeContext } from '../SerializeContext';
+export declare class CountStatement extends Serializable {
+    _alias?: string;
+    get _type(): SerializationType;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}

package/dist/sql-objects/CountStatement.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountStatement = void 0;
+const Serializable_1 = require("../Serializable");
+const enums_1 = require("../enums");
+class CountStatement extends Serializable_1.Serializable {
+    get _type() {
+        return enums_1.SerializationType.COUNT_STATEMENT;
+    }
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx) {
+        return ctx.serialize(this._type, undefined, () => this.__defaultSerialize(ctx, undefined));
+    }
+    // noinspection JSUnusedLocalSymbols
+    __defaultSerialize(
+    /* eslint-disable-next-line */
+    ctx, o) {
+        return 'count(*)';
+    }
+}
+exports.CountStatement = CountStatement;

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

@@ -0,0 +1,7 @@
+import { Serializable } from '../Serializable';
+import { DataType } from '../enums';
+export declare abstract class Expression extends Serializable {
+    _dataType?: DataType;
+    _isArray?: boolean;
+    _isDataSet?: boolean;
+}

package/dist/sql-objects/Expression.js

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

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

@@ -0,0 +1,14 @@
+import { DataType, SerializationType } from '../enums';
+import { BaseField } from './BaseField';
+import { SerializeContext } from '../SerializeContext';
+export declare class FieldExpression extends BaseField {
+    _alias?: string;
+    constructor(expression: string, dataType?: DataType, isArray?: boolean);
+    constructor(args: {
+        expression: string;
+        dataType?: DataType;
+        isArray?: boolean;
+    });
+    get _type(): SerializationType;
+    _serialize(ctx: SerializeContext): string;
+}

package/dist/sql-objects/FieldExpression.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldExpression = void 0;
+const enums_1 = require("../enums");
+const BaseField_1 = require("./BaseField");
+const TABLE_COLUMN_PATTERN = /^((?:[a-zA-Z_][\w$_]*\.){0,2}) *([0-9a-zA-Z_][\w$_]*|\*) *(?:as)? *([a-zA-Z_][\w$_]*)?$/;
+class FieldExpression extends BaseField_1.BaseField {
+    constructor(arg0, arg1, arg2) {
+        super();
+        let expression;
+        if (typeof arg0 === 'object') {
+            expression = arg0.expression;
+            this._dataType = arg0.dataType;
+            this._isArray = arg0.isArray;
+        }
+        else {
+            expression = arg0;
+            this._dataType = arg1;
+            this._isArray = arg2;
+        }
+        const m = expression.match(TABLE_COLUMN_PATTERN);
+        if (!m)
+            throw new TypeError(`${expression} does not match table 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();
+        }
+        this._alias = this._field !== '*' ? m[3] : '';
+    }
+    get _type() {
+        return enums_1.SerializationType.SELECT_COLUMN;
+    }
+    _serialize(ctx) {
+        const o = {
+            schema: this._schema,
+            table: this._table,
+            field: this._field,
+            alias: this._alias,
+            isReservedWord: !!(this._field && ctx.isReservedWord(this._field))
+        };
+        return ctx.serialize(this._type, o, () => {
+            const prefix = ctx.escapeReserved(this._schema ? this._schema + '.' : '') +
+                (this._table ? this._table + '.' : '');
+            return prefix +
+                (!prefix && o.isReservedWord ? '"' + this._field + '"' : this._field) +
+                (this._alias ? ' as ' + this._alias : '');
+        });
+    }
+}
+exports.FieldExpression = FieldExpression;

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

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