@sqb/builder 4.1.5 → 4.5.0

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);
+    }
+}

package/{dist/sql-objects/operators/OpExists.d.ts → esm/sql-objects/operators/op-exists.d.ts}

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

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

@@ -0,0 +1,26 @@
+import { OperatorType } from '../../enums.js';
+import { isSelectQuery } from '../../typeguards.js';
+import { CompOperator } from './comp-operator.js';
+export class OpExists extends CompOperator {
+    _operatorType = OperatorType.exists;
+    _symbol = 'exists';
+    constructor(query) {
+        super(query);
+        if (!(typeof query === 'object' && isSelectQuery(query)))
+            throw new TypeError('You must provide a SelectQuery in `exists()`');
+    }
+    _serialize(ctx) {
+        const left = this.__serializeItem(ctx, this._left);
+        if (this._isArray)
+            left.isArray = true;
+        const o = {
+            operatorType: this._operatorType,
+            symbol: this._symbol,
+            left
+        };
+        return this.__serialize(ctx, o);
+    }
+    __defaultSerialize(ctx, o) {
+        return o.left.expression ? o.symbol + ' ' + o.left.expression : '';
+    }
+}

package/{dist/sql-objects/operators/OpGt.d.ts → esm/sql-objects/operators/op-gt.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 OpGt extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

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

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

package/{dist/sql-objects/operators/OpGte.d.ts → esm/sql-objects/operators/op-gte.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 OpGte extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

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

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

package/{dist/sql-objects/operators/OpILike.d.ts → esm/sql-objects/operators/op-ilike.d.ts}

@@ -1,5 +1,5 @@
-import { OperatorType } from '../../enums';
-import { OpLike } from './OpLike';
+import { OperatorType } from '../../enums.js';
+import { OpLike } from './op-like.js';
 export declare class OpILike extends OpLike {
     _operatorType: OperatorType;
     _symbol: string;

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

@@ -0,0 +1,6 @@
+import { OperatorType } from '../../enums.js';
+import { OpLike } from './op-like.js';
+export class OpILike extends OpLike {
+    _operatorType = OperatorType.iLike;
+    _symbol = 'ilike';
+}

package/{dist/sql-objects/operators/OpIn.d.ts → esm/sql-objects/operators/op-in.d.ts}

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

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

@@ -0,0 +1,15 @@
+import { OperatorType } from '../../enums.js';
+import { isSerializable } from '../../typeguards.js';
+import { CompOperator } from './comp-operator.js';
+export class OpIn extends CompOperator {
+    _operatorType = OperatorType.in;
+    _symbol = 'in';
+    constructor(left, right) {
+        super(left, Array.isArray(right) || isSerializable(right) ? right : [right]);
+    }
+    _serialize(ctx) {
+        if (Array.isArray(this._right) && !this._right.length)
+            return '';
+        return super._serialize(ctx);
+    }
+}

package/{dist/sql-objects/operators/OpIsNot.d.ts → esm/sql-objects/operators/op-is-not.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 OpIsNot extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

package/esm/sql-objects/operators/op-is-not.js

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

package/{dist/sql-objects/operators/OpIs.d.ts → esm/sql-objects/operators/op-is.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 OpIs extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

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

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

package/{dist/sql-objects/operators/OpLike.d.ts → esm/sql-objects/operators/op-like.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 OpLike extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

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

@@ -0,0 +1,18 @@
+import { OperatorType } from '../../enums.js';
+import { isSerializable } from '../../typeguards.js';
+import { CompOperator } from './comp-operator.js';
+export class OpLike extends CompOperator {
+    _operatorType = OperatorType.like;
+    _symbol = 'like';
+    constructor(left, right) {
+        super(left, right);
+    }
+    __serialize(ctx, o) {
+        if (o.right && typeof o.right !== 'string' && !isSerializable(o.right))
+            o.right = ctx.anyToSQL(o.right);
+        if (!o.right)
+            return '';
+        o.right = ctx.anyToSQL(o.right);
+        return ctx.serialize(this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
+    }
+}

package/{dist/sql-objects/operators/OpLt.d.ts → esm/sql-objects/operators/op-lt.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 OpLt extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

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

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

package/{dist/sql-objects/operators/OpLte.d.ts → esm/sql-objects/operators/op-lte.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 OpLte extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

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

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

package/{dist/sql-objects/operators/OpNe.d.ts → esm/sql-objects/operators/op-ne.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 OpNe extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

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

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

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

@@ -1,5 +1,5 @@
-import { OperatorType } from '../../enums';
-import { OpBetween } from './OpBetween';
+import { OperatorType } from '../../enums.js';
+import { OpBetween } from './op-between.js';
 export declare class OpNotBetween extends OpBetween {
     _operatorType: OperatorType;
     _symbol: string;

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

@@ -0,0 +1,6 @@
+import { OperatorType } from '../../enums.js';
+import { OpBetween } from './op-between.js';
+export class OpNotBetween extends OpBetween {
+    _operatorType = OperatorType.notBetween;
+    _symbol = 'not between';
+}

package/{dist/sql-objects/operators/OpNotExists.d.ts → esm/sql-objects/operators/op-not-exists.d.ts}

@@ -1,5 +1,5 @@
-import { OperatorType } from '../../enums';
-import { OpExists } from './OpExists';
+import { OperatorType } from '../../enums.js';
+import { OpExists } from './op-exists.js';
 export declare class OpNotExists extends OpExists {
     _operatorType: OperatorType;
     _symbol: string;

package/esm/sql-objects/operators/op-not-exists.js

@@ -0,0 +1,6 @@
+import { OperatorType } from '../../enums.js';
+import { OpExists } from './op-exists.js';
+export class OpNotExists extends OpExists {
+    _operatorType = OperatorType.notExists;
+    _symbol = 'not exists';
+}

package/{dist/sql-objects/operators/OpNotILike.d.ts → esm/sql-objects/operators/op-not-ilike.d.ts}

@@ -1,5 +1,5 @@
-import { OperatorType } from '../../enums';
-import { OpILike } from './OpILike';
+import { OperatorType } from '../../enums.js';
+import { OpILike } from './op-ilike.js';
 export declare class OpNotILike extends OpILike {
     _operatorType: OperatorType;
     _symbol: string;

package/esm/sql-objects/operators/op-not-ilike.js

@@ -0,0 +1,6 @@
+import { OperatorType } from '../../enums.js';
+import { OpILike } from './op-ilike.js';
+export class OpNotILike extends OpILike {
+    _operatorType = OperatorType.notILike;
+    _symbol = 'not ilike';
+}

package/{dist/sql-objects/operators/OpNotIn.d.ts → esm/sql-objects/operators/op-not-in.d.ts}

@@ -1,5 +1,5 @@
-import { OperatorType } from '../../enums';
-import { OpIn } from './OpIn';
+import { OperatorType } from '../../enums.js';
+import { OpIn } from './op-in.js';
 export declare class OpNotIn extends OpIn {
     _operatorType: OperatorType;
     _symbol: string;

package/esm/sql-objects/operators/op-not-in.js

@@ -0,0 +1,6 @@
+import { OperatorType } from '../../enums.js';
+import { OpIn } from './op-in.js';
+export class OpNotIn extends OpIn {
+    _operatorType = OperatorType.notIn;
+    _symbol = 'not in';
+}

package/{dist/sql-objects/operators/OpNotLike.d.ts → esm/sql-objects/operators/op-not-like.d.ts}

@@ -1,5 +1,5 @@
-import { OperatorType } from '../../enums';
-import { OpLike } from './OpLike';
+import { OperatorType } from '../../enums.js';
+import { OpLike } from './op-like.js';
 export declare class OpNotLike extends OpLike {
     _operatorType: OperatorType;
     _symbol: string;

package/esm/sql-objects/operators/op-not-like.js

@@ -0,0 +1,6 @@
+import { OperatorType } from '../../enums.js';
+import { OpLike } from './op-like.js';
+export class OpNotLike extends OpLike {
+    _operatorType = OperatorType.notLike;
+    _symbol = 'not like';
+}

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

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

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

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

package/{dist/sql-objects/OrderColumn.d.ts → esm/sql-objects/order-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 OrderColumn extends BaseField {
     _descending?: boolean;
     constructor(value: string);

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

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

package/{dist/sql-objects/ParamExpression.d.ts → esm/sql-objects/param-expression.d.ts}

@@ -1,6 +1,6 @@
-import { DataType, SerializationType } from '../enums';
-import { Serializable } from '../Serializable';
-import { SerializeContext } from '../SerializeContext';
+import { DataType, SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
 export declare class ParamExpression extends Serializable {
     _name: string;
     _dataType?: DataType;