@sqb/builder 4.1.5 → 4.5.0

package/{dist/query/SelectQuery.d.ts → esm/query/select-query.d.ts}

@@ -1,19 +1,19 @@
-import { SerializationType } from '../enums';
-import { Serializable } from '../Serializable';
-import { SerializeContext } from '../SerializeContext';
-import { GroupColumn } from '../sql-objects/GroupColumn';
-import { JoinStatement } from '../sql-objects/JoinStatement';
-import { LogicalOperator } from '../sql-objects/operators/LogicalOperator';
-import { OrderColumn } from '../sql-objects/OrderColumn';
-import { RawStatement } from '../sql-objects/RawStatement';
-import { Query } from './Query';
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
+import { GroupColumn } from '../sql-objects/group-column.js';
+import { JoinStatement } from '../sql-objects/join-statement.js';
+import { LogicalOperator } from '../sql-objects/operators/logical-operator.js';
+import { OrderColumn } from '../sql-objects/order-column.js';
+import { RawStatement } from '../sql-objects/raw-statement.js';
+import { Query } from './query.js';
 export declare class SelectQuery extends Query {
     _tables?: Serializable[];
     _columns?: Serializable[];
     _joins?: JoinStatement[];
     _where?: LogicalOperator;
-    _groupBy?: (GroupColumn | RawStatement)[];
-    _orderBy?: (OrderColumn | RawStatement)[];
+    _groupBy?: (GroupColumn | Serializable)[];
+    _orderBy?: (OrderColumn | Serializable)[];
     _limit?: number;
     _offset?: number;
     _alias?: string;
@@ -39,11 +39,11 @@ export declare class SelectQuery extends Query {
     /**
      * Defines "where" part of query
      */
-    groupBy(...field: (string | RawStatement)[]): this;
+    groupBy(...field: (string | Serializable)[]): this;
     /**
      * Defines "order by" part of query.
      */
-    orderBy(...field: (string | RawStatement)[]): this;
+    orderBy(...field: (string | Serializable)[]): this;
     /**
      * Sets alias for sub-select queries
      */

package/{dist/query/SelectQuery.js → esm/query/select-query.js}

@@ -1,24 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelectQuery = void 0;
-const putil_varhelpers_1 = require("putil-varhelpers");
-const enums_1 = require("../enums");
-const helpers_1 = require("../helpers");
-const FieldExpression_1 = require("../sql-objects/FieldExpression");
-const GroupColumn_1 = require("../sql-objects/GroupColumn");
-const OpAnd_1 = require("../sql-objects/operators/OpAnd");
-const OrderColumn_1 = require("../sql-objects/OrderColumn");
-const TableName_1 = require("../sql-objects/TableName");
-const typeguards_1 = require("../typeguards");
-const Query_1 = require("./Query");
-class SelectQuery extends Query_1.Query {
+import { coerceToInt } from 'putil-varhelpers';
+import { SerializationType } from '../enums.js';
+import { printArray } from '../helpers.js';
+import { FieldExpression } from '../sql-objects/field-expression.js';
+import { GroupColumn } from '../sql-objects/group-column.js';
+import { OpAnd } from '../sql-objects/operators/op-and.js';
+import { OrderColumn } from '../sql-objects/order-column.js';
+import { TableName } from '../sql-objects/table-name.js';
+import { isJoinStatement, isSerializable } from '../typeguards.js';
+import { Query } from './query.js';
+export class SelectQuery extends Query {
+    _tables;
+    _columns;
+    _joins;
+    _where;
+    _groupBy;
+    _orderBy;
+    _limit;
+    _offset;
+    _alias;
+    _distinct;
     constructor(...column) {
         super();
         if (column.length)
             this.addColumn(...column);
     }
     get _type() {
-        return enums_1.SerializationType.SELECT_QUERY;
+        return SerializationType.SELECT_QUERY;
     }
     /**
      * Adds columns to query.
@@ -32,7 +39,7 @@ class SelectQuery extends Query_1.Query {
             if (Array.isArray(arg))
                 self.addColumn(...arg);
             else
-                this._columns.push((0, typeguards_1.isSerializable)(arg) ? arg : new FieldExpression_1.FieldExpression(arg));
+                this._columns.push(isSerializable(arg) ? arg : new FieldExpression(arg));
         }
         return this;
     }
@@ -44,7 +51,7 @@ class SelectQuery extends Query_1.Query {
         for (const arg of table) {
             if (!arg)
                 continue;
-            this._tables.push(typeof arg === 'string' ? new TableName_1.TableName(arg) : arg);
+            this._tables.push(typeof arg === 'string' ? new TableName(arg) : arg);
         }
         return this;
     }
@@ -56,7 +63,7 @@ class SelectQuery extends Query_1.Query {
         for (const arg of join) {
             if (!arg)
                 continue;
-            if (!(0, typeguards_1.isJoinStatement)(arg))
+            if (!isJoinStatement(arg))
                 throw new TypeError('Join statement required');
             this._joins.push(arg);
         }
@@ -66,7 +73,7 @@ class SelectQuery extends Query_1.Query {
      * Defines "where" part of query
      */
     where(...condition) {
-        this._where = this._where || new OpAnd_1.OpAnd();
+        this._where = this._where || new OpAnd();
         this._where.add(...condition);
         return this;
     }
@@ -78,7 +85,7 @@ class SelectQuery extends Query_1.Query {
         for (const arg of field) {
             if (!arg)
                 continue;
-            this._groupBy.push(typeof arg === 'string' ? new GroupColumn_1.GroupColumn(arg) : arg);
+            this._groupBy.push(typeof arg === 'string' ? new GroupColumn(arg) : arg);
         }
         return this;
     }
@@ -90,7 +97,7 @@ class SelectQuery extends Query_1.Query {
         for (const arg of field) {
             if (!arg)
                 continue;
-            this._orderBy.push(typeof arg === 'string' ? new OrderColumn_1.OrderColumn(arg) : arg);
+            this._orderBy.push(typeof arg === 'string' ? new OrderColumn(arg) : arg);
         }
         return this;
     }
@@ -105,14 +112,14 @@ class SelectQuery extends Query_1.Query {
      * Sets limit for query
      */
     limit(limit) {
-        this._limit = (0, putil_varhelpers_1.coerceToInt)(limit);
+        this._limit = coerceToInt(limit);
         return this;
     }
     /**
      * Sets offset for query
      */
     offset(offset) {
-        this._offset = (0, putil_varhelpers_1.coerceToInt)(offset);
+        this._offset = coerceToInt(offset);
         return this;
     }
     /**
@@ -183,18 +190,19 @@ class SelectQuery extends Query_1.Query {
         const arr = [];
         if (this._columns)
             for (const t of this._columns) {
-                const s = t._serialize(ctx);
+                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);
+                        arr.push(s + ' ' + t._alias);
                     }
                     else
                         arr.push(s);
                 }
             }
-        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_COLUMNS, arr, () => (0, helpers_1.printArray)(arr) || '*');
+        return ctx.serialize(SerializationType.SELECT_QUERY_COLUMNS, arr, () => printArray(arr) || '*');
     }
     /**
      *
@@ -215,7 +223,7 @@ class SelectQuery extends Query_1.Query {
                         arr.push(s);
                 }
             }
-        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_FROM, arr, () => {
+        return ctx.serialize(SerializationType.SELECT_QUERY_FROM, arr, () => {
             const s = arr.join(',');
             return s ? ('from' + (s.substring(0, 1) !== '\n' ? ' ' : '') + s) : '';
         });
@@ -232,7 +240,7 @@ class SelectQuery extends Query_1.Query {
                 if (s)
                     arr.push(s);
             }
-        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_JOIN, arr, () => {
+        return ctx.serialize(SerializationType.SELECT_QUERY_JOIN, arr, () => {
             return arr.join('\n');
         });
     }
@@ -243,7 +251,7 @@ class SelectQuery extends Query_1.Query {
         if (!this._where)
             return '';
         const s = this._where._serialize(ctx);
-        return ctx.serialize(enums_1.SerializationType.CONDITIONS_BLOCK, s, () => {
+        return ctx.serialize(SerializationType.CONDITIONS_BLOCK, s, () => {
             /* istanbul ignore next */
             return s ? 'where ' + s : '';
         });
@@ -260,8 +268,8 @@ class SelectQuery extends Query_1.Query {
                 if (s)
                     arr.push(s);
             }
-        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_GROUPBY, arr, () => {
-            const s = (0, helpers_1.printArray)(arr);
+        return ctx.serialize(SerializationType.SELECT_QUERY_GROUPBY, arr, () => {
+            const s = printArray(arr);
             return s ? 'group by ' + s : '';
         });
     }
@@ -274,10 +282,9 @@ class SelectQuery extends Query_1.Query {
                 if (s)
                     arr.push(s);
             }
-        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_ORDERBY, arr, () => {
-            const s = (0, helpers_1.printArray)(arr);
+        return ctx.serialize(SerializationType.SELECT_QUERY_ORDERBY, arr, () => {
+            const s = printArray(arr);
             return s ? 'order by ' + s : '';
         });
     }
 }
-exports.SelectQuery = SelectQuery;

package/{dist/query/UpdateQuery.d.ts → esm/query/update-query.d.ts}

@@ -1,9 +1,9 @@
-import { SerializationType } from '../enums';
-import { SerializeContext } from '../SerializeContext';
-import { LogicalOperator } from '../sql-objects/operators/LogicalOperator';
-import { RawStatement } from '../sql-objects/RawStatement';
-import { TableName } from '../sql-objects/TableName';
-import { ReturningQuery } from './ReturningQuery';
+import { SerializationType } from '../enums.js';
+import { SerializeContext } from '../serialize-context.js';
+import { LogicalOperator } from '../sql-objects/operators/logical-operator.js';
+import { RawStatement } from '../sql-objects/raw-statement.js';
+import { TableName } from '../sql-objects/table-name.js';
+import { ReturningQuery } from './returning-query.js';
 export declare class UpdateQuery extends ReturningQuery {
     _table: TableName | RawStatement;
     _input: any;

package/esm/query/update-query.js

@@ -0,0 +1,79 @@
+import { SerializationType } from '../enums.js';
+import { printArray } from '../helpers.js';
+import { OpAnd } from '../sql-objects/operators/op-and.js';
+import { TableName } from '../sql-objects/table-name.js';
+import { isRawStatement } from '../typeguards.js';
+import { ReturningQuery } from './returning-query.js';
+export class UpdateQuery extends ReturningQuery {
+    _table;
+    _input;
+    _where;
+    constructor(tableName, input) {
+        super();
+        if (!tableName || !(typeof tableName === 'string' || 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(tableName) : tableName;
+        this._input = input;
+    }
+    get _type() {
+        return SerializationType.UPDATE_QUERY;
+    }
+    /**
+     * Defines "where" part of query
+     */
+    where(...operator) {
+        this._where = this._where || new 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
+            });
+        }
+        return ctx.serialize(SerializationType.UPDATE_QUERY_VALUES, arr, () => {
+            const a = arr.map(o => o.field + ' = ' + o.value);
+            return printArray(a, ',');
+        });
+    }
+    /**
+     *
+     */
+    __serializeWhere(ctx) {
+        if (!this._where)
+            return '';
+        const s = this._where._serialize(ctx);
+        return ctx.serialize(SerializationType.CONDITIONS_BLOCK, s, () => {
+            /* istanbul ignore next */
+            return s ? 'where ' + s : '';
+        });
+    }
+}

package/{dist/Serializable.d.ts → esm/serializable.d.ts}

@@ -1,5 +1,5 @@
-import type { SerializationType } from './enums';
-import type { SerializeContext } from './SerializeContext';
+import type { SerializationType } from './enums.js';
+import type { SerializeContext } from './serialize-context.js';
 export declare abstract class Serializable {
     abstract _type: SerializationType;
     /**

package/esm/serializable.js

@@ -0,0 +1,2 @@
+export class Serializable {
+}

package/{dist/SerializeContext.d.ts → esm/serialize-context.d.ts}

@@ -1,4 +1,4 @@
-import { DefaultSerializeFunction, GenerateOptions, ParamOptions } from './types';
+import { DefaultSerializeFunction, GenerateOptions, ParamOptions } from './types.js';
 export declare class SerializeContext implements GenerateOptions {
     readonly reservedWords: string[];
     dialect?: string;

package/esm/serialize-context.js

@@ -0,0 +1,145 @@
+import { SerializationType } from './enums.js';
+import { serializers } from './extensions.js';
+import { Serializable } from './serializable.js';
+import { isLogicalOperator, isQuery, isSerializable } from './typeguards.js';
+export 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) {
+        if (opts)
+            Object.assign(this, opts);
+    }
+    /**
+     * Performs a fallback mechanism, tries hook functions, extensions than default function to serialize
+     */
+    serialize(type, o, fallback) {
+        if (this.serializeHooks) {
+            for (const hook of this.serializeHooks) {
+                const s = hook(this, type, o, fallback);
+                if (s != null)
+                    return s;
+            }
+        }
+        for (const ext of serializers) {
+            if (ext.dialect === this.dialect && ext.serialize) {
+                const s = ext.serialize(this, type, o, fallback);
+                if (s != null)
+                    return s;
+            }
+        }
+        return fallback(this, o);
+    }
+    /**
+     * Serializes object
+     */
+    anyToSQL(v) {
+        if (v == null)
+            return 'null';
+        if (Array.isArray(v)) {
+            const vv = v.map(x => this.anyToSQL(x));
+            return this.serialize(SerializationType.ARRAY, vv, () => '(' + v.join(',')) + ')';
+        }
+        if (typeof v === 'object') {
+            if (isSerializable(v)) {
+                const s = v._serialize(this);
+                return s ? (isQuery(v) || isLogicalOperator(v) ? '(' + s + ')' : s) :
+                    /* istanbul ignore next */
+                    '';
+            }
+            if (v instanceof Date) {
+                return this.serialize(SerializationType.DATE_VALUE, v, () => this.dateToSQL(v));
+            }
+        }
+        if (typeof v === 'string') {
+            return this.serialize(SerializationType.STRING_VALUE, v, () => this.stringToSQL(v));
+        }
+        if (typeof v === 'boolean') {
+            return this.serialize(SerializationType.BOOLEAN_VALUE, v, () => this.booleanToSQL(v));
+        }
+        if (typeof v === 'number') {
+            return this.serialize(SerializationType.NUMBER_VALUE, v, () => this.numberToSQL(v));
+        }
+        if (v instanceof Serializable)
+            return v._serialize(this);
+        return v;
+    }
+    /**
+     *
+     */
+    stringToSQL(val) {
+        return '\'' + String(val).replace(/'/g, '\'\'') + '\'';
+    }
+    /**
+     *
+     */
+    booleanToSQL(val) {
+        return val ? 'true' : 'false';
+    }
+    /**
+     *
+     */
+    numberToSQL(val) {
+        return '' + val;
+    }
+    /**
+     *
+     */
+    dateToSQL(date) {
+        const d = date.getUTCDate();
+        const m = date.getUTCMonth() + 1;
+        const y = date.getUTCFullYear();
+        const h = date.getUTCHours();
+        const n = date.getUTCMinutes();
+        const s = date.getUTCSeconds();
+        let str = y + '-' + (m <= 9 ? '0' + m : m) + '-' + (d <= 9 ? '0' + d : d);
+        /* istanbul ignore else */
+        if (h + n + s)
+            str += ' ' + (h <= 9 ? '0' + h : h) + ':' +
+                (n <= 9 ? '0' + n : n) + ':' +
+                (s <= 9 ? '0' + s : s);
+        return '\'' + str + '\'';
+    }
+    /**
+     * Check if a string value is a reserved word
+     */
+    isReservedWord(s) {
+        if (!s)
+            return false;
+        if (this.reservedWords.includes(s.toLowerCase()))
+            return true;
+        for (const ext of serializers) {
+            if (ext.dialect === this.dialect && ext.isReservedWord) {
+                if (ext.isReservedWord(this, s))
+                    return true;
+            }
+        }
+        return false;
+    }
+    escapeReserved(s) {
+        if (!s)
+            return '';
+        if (this.isReservedWord(s))
+            return '"' + s + '"';
+        return s;
+    }
+}

package/{dist/sql-objects/BaseField.d.ts → esm/sql-objects/base-field.d.ts}

@@ -1,4 +1,4 @@
-import { Expression } from './Expression';
+import { Expression } from './expression.js';
 export declare abstract class BaseField extends Expression {
     _field: string;
     _schema?: string;

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

@@ -0,0 +1,7 @@
+import { Expression } from './expression.js';
+export class BaseField extends Expression {
+    _field = '';
+    _schema;
+    _table;
+    _descending;
+}

package/{dist/sql-objects/CaseStatement.d.ts → esm/sql-objects/case-statement.d.ts}

@@ -1,9 +1,9 @@
-import { SerializationType } from '../enums';
-import { Serializable } from '../Serializable';
-import { SerializeContext } from '../SerializeContext';
-import { Operator } from './Operator';
-import { LogicalOperator } from './operators/LogicalOperator';
-import { RawStatement } from './RawStatement';
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
+import { Operator } from './operator.js';
+import { LogicalOperator } from './operators/logical-operator.js';
+import { RawStatement } from './raw-statement.js';
 export declare class CaseStatement extends Serializable {
     _expressions: {
         condition: Serializable;

package/esm/sql-objects/case-statement.js

@@ -0,0 +1,85 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { OpAnd } from './operators/op-and.js';
+export class CaseStatement extends Serializable {
+    _expressions;
+    _elseValue;
+    _condition;
+    _alias;
+    constructor() {
+        super();
+        this._expressions = [];
+    }
+    get _type() {
+        return SerializationType.CASE_STATEMENT;
+    }
+    /**
+     * Defines "when" part of Case expression.
+     */
+    when(...condition) {
+        if (condition.length)
+            this._condition = new 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;
+    }
+}

package/esm/sql-objects/coalesce-statement.d.ts

@@ -0,0 +1,22 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
+export declare class CoalesceStatement extends Serializable {
+    _expressions: any[];
+    _alias?: string;
+    constructor(...expressions: any[]);
+    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;
+}