@sqb/builder 4.2.1 → 4.5.1

package/{dist/sql-objects/FieldExpression.d.ts → esm/sql-objects/field-expression.d.ts}

@@ -1,6 +1,6 @@
-import { DataType, SerializationType } from '../enums';
-import { SerializeContext } from '../SerializeContext';
-import { BaseField } from './BaseField';
+import { DataType, SerializationType } from '../enums.js';
+import { SerializeContext } from '../serialize-context.js';
+import { BaseField } from './base-field.js';
 export declare class FieldExpression extends BaseField {
     _alias?: string;
     constructor(expression: string, dataType?: DataType, isArray?: boolean);

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

@@ -0,0 +1,50 @@
+import { SerializationType } from '../enums.js';
+import { BaseField } from './base-field.js';
+const TABLE_COLUMN_PATTERN = /^((?:[a-zA-Z_][\w$_]*\.){0,2}) *([0-9a-zA-Z_][\w$_]*|\*) *(?:as)? *([a-zA-Z_][\w$_]*)?$/;
+export class FieldExpression extends BaseField {
+    _alias;
+    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 SerializationType.FIELD_NAME;
+    }
+    _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 : '');
+        });
+    }
+}

package/{dist/sql-objects/GroupColumn.d.ts → esm/sql-objects/group-column.d.ts}

@@ -1,6 +1,6 @@
-import { SerializationType } from '../enums';
-import { SerializeContext } from '../SerializeContext';
-import { BaseField } from './BaseField';
+import { SerializationType } from '../enums.js';
+import { SerializeContext } from '../serialize-context.js';
+import { BaseField } from './base-field.js';
 export declare class GroupColumn extends BaseField {
     constructor(value: string);
     get _type(): SerializationType;

package/esm/sql-objects/group-column.js

@@ -0,0 +1,34 @@
+import { SerializationType } from '../enums.js';
+import { BaseField } from './base-field.js';
+const GROUP_COLUMN_PATTERN = /^((?:[a-zA-Z][\w$]*\.){0,2})([\w$]*)$/;
+export class GroupColumn extends 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 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);
+        });
+    }
+}

package/{dist/sql-objects/JoinStatement.d.ts → esm/sql-objects/join-statement.d.ts}

@@ -1,10 +1,10 @@
-import { JoinType, SerializationType } from '../enums';
-import { SelectQuery } from '../query/SelectQuery';
-import { Serializable } from '../Serializable';
-import { SerializeContext } from '../SerializeContext';
-import { LogicalOperator } from './operators/LogicalOperator';
-import { RawStatement } from './RawStatement';
-import { TableName } from './TableName';
+import { JoinType, SerializationType } from '../enums.js';
+import { SelectQuery } from '../query/select-query.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
+import { LogicalOperator } from './operators/logical-operator.js';
+import { RawStatement } from './raw-statement.js';
+import { TableName } from './table-name.js';
 export declare class JoinStatement extends Serializable {
     _joinType: JoinType;
     _table: TableName | SelectQuery | RawStatement;

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

@@ -0,0 +1,79 @@
+import { JoinType, SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { isRawStatement, isSelectQuery, isTableName } from '../typeguards.js';
+import { OpAnd } from './operators/op-and.js';
+import { TableName } from './table-name.js';
+export class JoinStatement extends Serializable {
+    _joinType;
+    _table;
+    _conditions = new OpAnd();
+    constructor(joinType, table) {
+        super();
+        // noinspection SuspiciousTypeOfGuard
+        if (!(isSelectQuery(table) || isRawStatement(table) || 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(table) : table;
+    }
+    get _type() {
+        return 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 JoinType.LEFT:
+                    out = 'left join';
+                    break;
+                case JoinType.LEFT_OUTER:
+                    out = 'left outer join';
+                    break;
+                case JoinType.RIGHT:
+                    out = 'right join';
+                    break;
+                case JoinType.RIGHT_OUTER:
+                    out = 'right outer join';
+                    break;
+                case JoinType.OUTER:
+                    out = 'outer join';
+                    break;
+                case JoinType.FULL_OUTER:
+                    out = 'full outer join';
+                    break;
+                default:
+                    out = 'inner join';
+                    break;
+            }
+            const lf = o.table.length > 40;
+            if (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(SerializationType.JOIN_CONDITIONS, s, () => s ? 'on ' + s : '');
+        }
+        return '';
+    }
+}

package/{dist/sql-objects/LowerStatement.d.ts → esm/sql-objects/lower-statement.d.ts}

@@ -1,6 +1,6 @@
-import { SerializationType } from '../enums';
-import { Serializable } from '../Serializable';
-import { SerializeContext } from '../SerializeContext';
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
 export declare class LowerStatement extends Serializable {
     _expression: any;
     _alias?: string;

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

@@ -0,0 +1,37 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class LowerStatement extends Serializable {
+    _expression;
+    _alias;
+    constructor(expression) {
+        super();
+        this._expression = expression;
+    }
+    get _type() {
+        return SerializationType.LOWER_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._expression)
+            return '';
+        const q = ctx.anyToSQL(this._expression);
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        return 'lower(' + o + ')' +
+            (this._alias ? ' ' + this._alias : '');
+    }
+}

package/esm/sql-objects/max-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 MaxStatement extends Serializable {
+    _expression: any;
+    _alias?: string;
+    constructor(expression: 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;
+}

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

@@ -0,0 +1,37 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class MaxStatement extends Serializable {
+    _expression;
+    _alias;
+    constructor(expression) {
+        super();
+        this._expression = expression;
+    }
+    get _type() {
+        return SerializationType.MAX_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._expression)
+            return '';
+        const q = ctx.anyToSQL(this._expression);
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        return 'max(' + o + ')' +
+            (this._alias ? ' ' + this._alias : '');
+    }
+}

package/esm/sql-objects/min-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 MinStatement extends Serializable {
+    _expression: any;
+    _alias?: string;
+    constructor(expression: 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;
+}

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

@@ -0,0 +1,37 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class MinStatement extends Serializable {
+    _expression;
+    _alias;
+    constructor(expression) {
+        super();
+        this._expression = expression;
+    }
+    get _type() {
+        return SerializationType.MIN_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._expression)
+            return '';
+        const q = ctx.anyToSQL(this._expression);
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        return 'min(' + o + ')' +
+            (this._alias ? ' ' + this._alias : '');
+    }
+}

package/{dist/sql-objects/Operator.d.ts → esm/sql-objects/operator.d.ts}

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

package/esm/sql-objects/operator.js

@@ -0,0 +1,3 @@
+import { Serializable } from '../serializable.js';
+export class Operator extends Serializable {
+}

package/{dist/sql-objects/operators/CompOperator.d.ts → esm/sql-objects/operators/comp-operator.d.ts}

@@ -1,7 +1,7 @@
-import { SerializationType } from '../../enums';
-import { Serializable } from '../../Serializable';
-import { SerializeContext } from '../../SerializeContext';
-import { Operator } from '../Operator';
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { Operator } from '../operator.js';
 export declare abstract class CompOperator extends Operator {
     _left: Serializable | string;
     _right?: any | Serializable;

package/esm/sql-objects/operators/comp-operator.js

@@ -0,0 +1,86 @@
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { Param } from '../../sqlobject.initializers.js';
+import { FieldExpression } from '../field-expression.js';
+import { Operator } from '../operator.js';
+import { ParamExpression } from '../param-expression.js';
+const EXPRESSION_PATTERN = /^([\w\\.$]+)(\[])?/;
+export class CompOperator extends Operator {
+    _left;
+    _right;
+    _symbol;
+    _isArray;
+    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 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) &&
+            (typeof x !== 'string' || isRight)) {
+            ctx.strictParamGenId = ctx.strictParamGenId || 0;
+            const name = 'strictParam$' + ++ctx.strictParamGenId;
+            ctx.params = ctx.params || {};
+            ctx.params[name] = x;
+            x = Param(name);
+        }
+        if (x instanceof Serializable) {
+            const expression = ctx.anyToSQL(x);
+            const result = {
+                expression
+            };
+            if (x instanceof FieldExpression) {
+                result.dataType = result._dataType;
+                result.isArray = x._isArray;
+            }
+            if (x instanceof 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;
+    }
+}

package/{dist/sql-objects/operators/LogicalOperator.d.ts → esm/sql-objects/operators/logical-operator.d.ts}

@@ -1,7 +1,7 @@
-import { SerializationType } from '../../enums';
-import { Serializable } from '../../Serializable';
-import { SerializeContext } from '../../SerializeContext';
-import { Operator } from '../Operator';
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { Operator } from '../operator.js';
 export declare const WrapOps: {};
 export declare abstract class LogicalOperator extends Operator {
     _items: Serializable[];

package/esm/sql-objects/operators/logical-operator.js

@@ -0,0 +1,79 @@
+import isPlainObject from 'putil-isplainobject';
+import { SerializationType } from '../../enums.js';
+import { printArray } from '../../helpers.js';
+import { isCompOperator, isLogicalOperator, isRawStatement } from '../../typeguards.js';
+import { Operator } from '../operator.js';
+export const WrapOps = {};
+// noinspection RegExpUnnecessaryNonCapturingGroup
+const COMPARE_LEFT_PATTERN = /^([\w\\.$]+(?:\[])?) *(.*)$/;
+export class LogicalOperator extends Operator {
+    _items = [];
+    constructor(...expressions) {
+        super();
+        this.add(...expressions);
+    }
+    get _type() {
+        return SerializationType.LOGICAL_EXPRESSION;
+    }
+    /**
+     * Adds operator(s) to item list
+     */
+    add(...expressions) {
+        for (const item of expressions) {
+            if (!item)
+                continue;
+            if (isLogicalOperator(item)) {
+                this._items.push(item);
+            }
+            else if (isRawStatement(item) || isCompOperator(item)) {
+                this._items.push(item);
+            }
+            else if (isPlainObject(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 = ctx.anyToSQL(t);
+            /* istanbul ignore else */
+            if (s)
+                arr.push(s);
+        }
+        return ctx.serialize(SerializationType.LOGICAL_EXPRESSION, arr, () => {
+            const s = printArray(arr, ' ' + String(this._operatorType));
+            return (s.indexOf('\n') > 0) ? s.replace('\n', '\n\t') + '\b' : s;
+        });
+    }
+    // noinspection JSMethodCanBeStatic
+    _wrapObject(obj) {
+        const result = [];
+        for (const n of Object.getOwnPropertyNames(obj)) {
+            let op;
+            const v = obj[n];
+            if (['and', 'or'].includes(n.toLowerCase())) {
+                op = 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(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 = WrapOps[m[2] || 'eq'];
+                if (!op)
+                    throw new Error(`Unknown operator "${m[2]}"`);
+                result.push(op(m[1], obj[n]));
+            }
+        }
+        return result;
+    }
+}

package/esm/sql-objects/operators/op-and.d.ts

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

package/esm/sql-objects/operators/op-and.js

@@ -0,0 +1,5 @@
+import { OperatorType } from '../../enums.js';
+import { LogicalOperator } from './logical-operator.js';
+export class OpAnd extends LogicalOperator {
+    _operatorType = OperatorType.and;
+}

package/{dist/sql-objects/operators/OpBetween.d.ts → esm/sql-objects/operators/op-between.d.ts}

@@ -1,7 +1,7 @@
-import { OperatorType } from '../../enums';
-import { Serializable } from '../../Serializable';
-import { SerializeContext } from '../../SerializeContext';
-import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { CompOperator } from './comp-operator.js';
 export declare class OpBetween extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

package/esm/sql-objects/operators/op-between.js

@@ -0,0 +1,31 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpBetween extends CompOperator {
+    _operatorType = OperatorType.between;
+    _symbol = 'between';
+    constructor(left, right) {
+        super(left, right);
+        if (right && right[1] == null)
+            right[1] = right[0];
+    }
+    _serialize(ctx) {
+        if (!(this._right && this._right.length > 0))
+            return '';
+        const left = this.__serializeItem(ctx, this._left);
+        const right = [
+            this.__serializeItem(ctx, this._right[0], true),
+            this.__serializeItem(ctx, this._right[1], true)
+        ];
+        const o = {
+            operatorType: this._operatorType,
+            symbol: this._symbol,
+            left,
+            right
+        };
+        return this.__serialize(ctx, o);
+    }
+    __defaultSerialize(ctx, o) {
+        return o.left.expression + ' ' + o.symbol + ' ' +
+            o.right[0].expression + ' and ' + o.right[1].expression;
+    }
+}

package/{dist/sql-objects/operators/OpEq.d.ts → esm/sql-objects/operators/op-eq.d.ts}

@@ -1,6 +1,6 @@
-import { OperatorType } from '../../enums';
-import { Serializable } from '../../Serializable';
-import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { CompOperator } from './comp-operator.js';
 export declare class OpEq extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

package/esm/sql-objects/operators/op-eq.js

@@ -0,0 +1,9 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpEq extends CompOperator {
+    _operatorType = OperatorType.eq;
+    _symbol = '=';
+    constructor(left, right) {
+        super(left, right);
+    }
+}