@sqb/builder 4.1.5 → 4.5.0

package/cjs/query/select-query.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectQuery = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+const enums_js_1 = require("../enums.js");
+const helpers_js_1 = require("../helpers.js");
+const field_expression_js_1 = require("../sql-objects/field-expression.js");
+const group_column_js_1 = require("../sql-objects/group-column.js");
+const op_and_js_1 = require("../sql-objects/operators/op-and.js");
+const order_column_js_1 = require("../sql-objects/order-column.js");
+const table_name_js_1 = require("../sql-objects/table-name.js");
+const typeguards_js_1 = require("../typeguards.js");
+const query_js_1 = require("./query.js");
+class SelectQuery extends query_js_1.Query {
+    _tables;
+    _columns;
+    _joins;
+    _where;
+    _groupBy;
+    _orderBy;
+    _limit;
+    _offset;
+    _alias;
+    _distinct;
+    constructor(...column) {
+        super();
+        if (column.length)
+            this.addColumn(...column);
+    }
+    get _type() {
+        return enums_js_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_js_1.isSerializable)(arg) ? arg : new field_expression_js_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 table_name_js_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_js_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 op_and_js_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 group_column_js_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 order_column_js_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 = ctx.anyToSQL(t);
+                // 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_js_1.SerializationType.SELECT_QUERY_COLUMNS, arr, () => (0, helpers_js_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_js_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_js_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_js_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_js_1.SerializationType.SELECT_QUERY_GROUPBY, arr, () => {
+            const s = (0, helpers_js_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_js_1.SerializationType.SELECT_QUERY_ORDERBY, arr, () => {
+            const s = (0, helpers_js_1.printArray)(arr);
+            return s ? 'order by ' + s : '';
+        });
+    }
+}
+exports.SelectQuery = SelectQuery;

package/{dist/query/UpdateQuery.js → cjs/query/update-query.js}

@@ -1,31 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateQuery = void 0;
-const enums_1 = require("../enums");
-const helpers_1 = require("../helpers");
-const OpAnd_1 = require("../sql-objects/operators/OpAnd");
-const TableName_1 = require("../sql-objects/TableName");
-const typeguards_1 = require("../typeguards");
-const ReturningQuery_1 = require("./ReturningQuery");
-class UpdateQuery extends ReturningQuery_1.ReturningQuery {
+const enums_js_1 = require("../enums.js");
+const helpers_js_1 = require("../helpers.js");
+const op_and_js_1 = require("../sql-objects/operators/op-and.js");
+const table_name_js_1 = require("../sql-objects/table-name.js");
+const typeguards_js_1 = require("../typeguards.js");
+const returning_query_js_1 = require("./returning-query.js");
+class UpdateQuery extends returning_query_js_1.ReturningQuery {
+    _table;
+    _input;
+    _where;
     constructor(tableName, input) {
         super();
-        if (!tableName || !(typeof tableName === 'string' || (0, typeguards_1.isRawStatement)(tableName)))
+        if (!tableName || !(typeof tableName === 'string' || (0, typeguards_js_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._table = typeof tableName === 'string' ? new table_name_js_1.TableName(tableName) : tableName;
         this._input = input;
     }
     get _type() {
-        return enums_1.SerializationType.UPDATE_QUERY;
+        return enums_js_1.SerializationType.UPDATE_QUERY;
     }
     /**
      * Defines "where" part of query
      */
     where(...operator) {
-        this._where = this._where || new OpAnd_1.OpAnd();
+        this._where = this._where || new op_and_js_1.OpAnd();
         this._where.add(...operator);
         return this;
     }
@@ -56,12 +59,12 @@ class UpdateQuery extends ReturningQuery_1.ReturningQuery {
             const value = ctx.anyToSQL(allValues[n]);
             arr.push({
                 field: n,
-                value: (0, typeguards_1.isSelectQuery)(allValues[n]) ? '(' + value + ')' : value
+                value
             });
         }
-        return ctx.serialize(enums_1.SerializationType.UPDATE_QUERY_VALUES, arr, () => {
+        return ctx.serialize(enums_js_1.SerializationType.UPDATE_QUERY_VALUES, arr, () => {
             const a = arr.map(o => o.field + ' = ' + o.value);
-            return (0, helpers_1.printArray)(a, ',');
+            return (0, helpers_js_1.printArray)(a, ',');
         });
     }
     /**
@@ -71,7 +74,7 @@ class UpdateQuery extends ReturningQuery_1.ReturningQuery {
         if (!this._where)
             return '';
         const s = this._where._serialize(ctx);
-        return ctx.serialize(enums_1.SerializationType.CONDITIONS_BLOCK, s, () => {
+        return ctx.serialize(enums_js_1.SerializationType.CONDITIONS_BLOCK, s, () => {
             /* istanbul ignore next */
             return s ? 'where ' + s : '';
         });

package/{dist/SerializeContext.js → cjs/serialize-context.js}

@@ -1,23 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SerializeContext = void 0;
-const enums_1 = require("./enums");
-const extensions_1 = require("./extensions");
-const Serializable_1 = require("./Serializable");
+const enums_js_1 = require("./enums.js");
+const extensions_js_1 = require("./extensions.js");
+const serializable_js_1 = require("./serializable.js");
+const typeguards_js_1 = require("./typeguards.js");
 class SerializeContext {
+    reservedWords = [
+        'schema', 'table', 'field', 'index', 'foreign', 'key',
+        'select', 'insert', 'update', 'delete', 'with', 'merge',
+        'join', 'inner', 'outer', 'left', 'right', 'full',
+        'from', 'where', 'order', 'by', 'group', 'having',
+        'acs', 'ascending', 'dsc', 'descending', 'distinct',
+        'and', 'or', 'not', 'between', 'null', 'like', 'ilike',
+        'count', 'sum', 'average', 'avg', 'cascade', 'authorization',
+        'create', 'add', 'drop', 'alter', 'index', 'private', 'sequence',
+        'default', 'constraint', 'references', 'primary', 'foreign',
+        'user', 'password'
+    ];
+    dialect;
+    prettyPrint;
+    params;
+    dialectVersion;
+    strictParams;
+    serializeHooks;
+    paramOptions;
+    preparedParams;
+    returningFields;
+    strictParamGenId;
     constructor(opts) {
-        this.reservedWords = [
-            'schema', 'table', 'field', 'index', 'foreign', 'key',
-            'select', 'insert', 'update', 'delete', 'with', 'merge',
-            'join', 'inner', 'outer', 'left', 'right', 'full',
-            'from', 'where', 'order', 'by', 'group', 'having',
-            'acs', 'ascending', 'dsc', 'descending', 'distinct',
-            'and', 'or', 'not', 'between', 'null', 'like', 'ilike',
-            'count', 'sum', 'average', 'avg', 'cascade', 'authorization',
-            'create', 'add', 'drop', 'alter', 'index', 'private', 'sequence',
-            'default', 'constraint', 'references', 'primary', 'foreign',
-            'user', 'password'
-        ];
         if (opts)
             Object.assign(this, opts);
     }
@@ -32,7 +43,7 @@ class SerializeContext {
                     return s;
             }
         }
-        for (const ext of extensions_1.serializers) {
+        for (const ext of extensions_js_1.serializers) {
             if (ext.dialect === this.dialect && ext.serialize) {
                 const s = ext.serialize(this, type, o, fallback);
                 if (s != null)
@@ -49,29 +60,29 @@ class SerializeContext {
             return 'null';
         if (Array.isArray(v)) {
             const vv = v.map(x => this.anyToSQL(x));
-            return this.serialize(enums_1.SerializationType.ARRAY, vv, () => '(' + v.join(',')) + ')';
+            return this.serialize(enums_js_1.SerializationType.ARRAY, vv, () => '(' + v.join(',')) + ')';
         }
         if (typeof v === 'object') {
-            if (v.isSerializable) {
+            if ((0, typeguards_js_1.isSerializable)(v)) {
                 const s = v._serialize(this);
-                return s ? (v.isQuery ? '(' + s + ')' : s) :
+                return s ? ((0, typeguards_js_1.isQuery)(v) || (0, typeguards_js_1.isLogicalOperator)(v) ? '(' + s + ')' : s) :
                     /* istanbul ignore next */
-                    'null';
+                    '';
             }
             if (v instanceof Date) {
-                return this.serialize(enums_1.SerializationType.DATE_VALUE, v, () => this.dateToSQL(v));
+                return this.serialize(enums_js_1.SerializationType.DATE_VALUE, v, () => this.dateToSQL(v));
             }
         }
         if (typeof v === 'string') {
-            return this.serialize(enums_1.SerializationType.STRING_VALUE, v, () => this.stringToSQL(v));
+            return this.serialize(enums_js_1.SerializationType.STRING_VALUE, v, () => this.stringToSQL(v));
         }
         if (typeof v === 'boolean') {
-            return this.serialize(enums_1.SerializationType.BOOLEAN_VALUE, v, () => this.booleanToSQL(v));
+            return this.serialize(enums_js_1.SerializationType.BOOLEAN_VALUE, v, () => this.booleanToSQL(v));
         }
         if (typeof v === 'number') {
-            return this.serialize(enums_1.SerializationType.NUMBER_VALUE, v, () => this.numberToSQL(v));
+            return this.serialize(enums_js_1.SerializationType.NUMBER_VALUE, v, () => this.numberToSQL(v));
         }
-        if (v instanceof Serializable_1.Serializable)
+        if (v instanceof serializable_js_1.Serializable)
             return v._serialize(this);
         return v;
     }
@@ -119,7 +130,7 @@ class SerializeContext {
             return false;
         if (this.reservedWords.includes(s.toLowerCase()))
             return true;
-        for (const ext of extensions_1.serializers) {
+        for (const ext of extensions_js_1.serializers) {
             if (ext.dialect === this.dialect && ext.isReservedWord) {
                 if (ext.isReservedWord(this, s))
                     return true;

package/cjs/sql-objects/base-field.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseField = void 0;
+const expression_js_1 = require("./expression.js");
+class BaseField extends expression_js_1.Expression {
+    _field = '';
+    _schema;
+    _table;
+    _descending;
+}
+exports.BaseField = BaseField;

package/{dist/sql-objects/CaseStatement.js → cjs/sql-objects/case-statement.js}

@@ -1,23 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CaseStatement = void 0;
-const enums_1 = require("../enums");
-const Serializable_1 = require("../Serializable");
-const OpAnd_1 = require("./operators/OpAnd");
-class CaseStatement extends Serializable_1.Serializable {
+const enums_js_1 = require("../enums.js");
+const serializable_js_1 = require("../serializable.js");
+const op_and_js_1 = require("./operators/op-and.js");
+class CaseStatement extends serializable_js_1.Serializable {
+    _expressions;
+    _elseValue;
+    _condition;
+    _alias;
     constructor() {
         super();
         this._expressions = [];
     }
     get _type() {
-        return enums_1.SerializationType.CASE_STATEMENT;
+        return enums_js_1.SerializationType.CASE_STATEMENT;
     }
     /**
      * Defines "when" part of Case expression.
      */
     when(...condition) {
         if (condition.length)
-            this._condition = new OpAnd_1.OpAnd(...condition);
+            this._condition = new op_and_js_1.OpAnd(...condition);
         else
             this._condition = undefined;
         return this;

package/cjs/sql-objects/coalesce-statement.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoalesceStatement = void 0;
+const enums_js_1 = require("../enums.js");
+const serializable_js_1 = require("../serializable.js");
+class CoalesceStatement extends serializable_js_1.Serializable {
+    _expressions;
+    _alias;
+    constructor(...expressions) {
+        super();
+        this._expressions = expressions;
+    }
+    get _type() {
+        return enums_js_1.SerializationType.COALESCE_STATEMENT;
+    }
+    /**
+     * 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: [],
+        };
+        for (const x of this._expressions) {
+            q.expressions.push(ctx.anyToSQL(x));
+        }
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        return 'coalesce(' + o.expressions.join(', ') + ')' +
+            (this._alias ? ' ' + this._alias : '');
+    }
+}
+exports.CoalesceStatement = CoalesceStatement;

package/{dist/sql-objects/CountStatement.js → cjs/sql-objects/count-statement.js}

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CountStatement = void 0;
-const enums_1 = require("../enums");
-const Serializable_1 = require("../Serializable");
-class CountStatement extends Serializable_1.Serializable {
+const enums_js_1 = require("../enums.js");
+const serializable_js_1 = require("../serializable.js");
+class CountStatement extends serializable_js_1.Serializable {
+    _alias;
     get _type() {
-        return enums_1.SerializationType.COUNT_STATEMENT;
+        return enums_js_1.SerializationType.COUNT_STATEMENT;
     }
     /**
      * Sets alias to case expression.

package/cjs/sql-objects/expression.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Expression = void 0;
+const serializable_js_1 = require("../serializable.js");
+class Expression extends serializable_js_1.Serializable {
+    _dataType;
+    _isArray;
+    _isDataSet;
+}
+exports.Expression = Expression;

package/{dist/sql-objects/FieldExpression.js → cjs/sql-objects/field-expression.js}

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldExpression = void 0;
-const enums_1 = require("../enums");
-const BaseField_1 = require("./BaseField");
+const enums_js_1 = require("../enums.js");
+const base_field_js_1 = require("./base-field.js");
 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 {
+class FieldExpression extends base_field_js_1.BaseField {
+    _alias;
     constructor(arg0, arg1, arg2) {
         super();
         let expression;
@@ -31,7 +32,7 @@ class FieldExpression extends BaseField_1.BaseField {
         this._alias = this._field !== '*' ? m[3] : '';
     }
     get _type() {
-        return enums_1.SerializationType.SELECT_COLUMN;
+        return enums_js_1.SerializationType.SELECT_COLUMN;
     }
     _serialize(ctx) {
         const o = {

package/{dist/sql-objects/GroupColumn.js → cjs/sql-objects/group-column.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupColumn = void 0;
-const enums_1 = require("../enums");
-const BaseField_1 = require("./BaseField");
+const enums_js_1 = require("../enums.js");
+const base_field_js_1 = require("./base-field.js");
 const GROUP_COLUMN_PATTERN = /^((?:[a-zA-Z][\w$]*\.){0,2})([\w$]*)$/;
-class GroupColumn extends BaseField_1.BaseField {
+class GroupColumn extends base_field_js_1.BaseField {
     constructor(value) {
         super();
         const m = value.match(GROUP_COLUMN_PATTERN);
@@ -19,7 +19,7 @@ class GroupColumn extends BaseField_1.BaseField {
         }
     }
     get _type() {
-        return enums_1.SerializationType.GROUP_COLUMN;
+        return enums_js_1.SerializationType.GROUP_COLUMN;
     }
     _serialize(ctx) {
         const o = {