@sqb/builder 4.2.1 → 4.5.0

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;

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

@@ -0,0 +1,52 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class ParamExpression extends Serializable {
+    _name;
+    _dataType;
+    _isArray;
+    constructor(arg) {
+        super();
+        if (typeof arg === 'object') {
+            this._name = arg.name;
+            this._dataType = arg.dataType;
+            this._isArray = arg.isArray;
+        }
+        else
+            this._name = arg;
+    }
+    get _type() {
+        return SerializationType.EXTERNAL_PARAMETER;
+    }
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx) {
+        const o = {
+            name: this._name,
+            dataType: this._dataType,
+            isArray: this._isArray,
+        };
+        return ctx.serialize(this._type, o, () => this.__defaultSerialize(ctx, o));
+    }
+    __defaultSerialize(ctx, o) {
+        let prmValue = (ctx.params && ctx.params[o.name]) ?? null;
+        if (prmValue != null && o.isArray && !Array.isArray(prmValue))
+            prmValue = [prmValue];
+        ctx.preparedParams = ctx.preparedParams || {};
+        if (Array.isArray(ctx.preparedParams))
+            ctx.preparedParams.push(prmValue);
+        else
+            ctx.preparedParams[o.name] = prmValue;
+        const paramOps = {
+            dataType: this._dataType,
+            isArray: this._isArray,
+        };
+        ctx.paramOptions = ctx.paramOptions ||
+            (Array.isArray(ctx.preparedParams) ? [] : {});
+        if (Array.isArray(ctx.paramOptions))
+            ctx.paramOptions.push(paramOps);
+        else
+            ctx.paramOptions[o.name] = paramOps;
+        return ':' + o.name;
+    }
+}

package/{dist/sql-objects/RawStatement.d.ts → esm/sql-objects/raw-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 RawStatement extends Serializable {
     _text: string;
     constructor(str: string);

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

@@ -0,0 +1,15 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class RawStatement extends Serializable {
+    _text;
+    constructor(str) {
+        super();
+        this._text = str;
+    }
+    get _type() {
+        return SerializationType.RAW;
+    }
+    _serialize(ctx) {
+        return ctx.serialize(this._type, this._text, () => this._text);
+    }
+}

package/{dist/sql-objects/ReturningColumn.d.ts → esm/sql-objects/returning-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 ReturningColumn extends BaseField {
     _alias: string;
     constructor(field: string);

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

@@ -0,0 +1,29 @@
+import { SerializationType } from '../enums.js';
+import { BaseField } from './base-field.js';
+const RETURNING_COLUMN_PATTERN = /^([a-zA-Z]\w*) *(?:as)? *(\w+)?$/;
+export class ReturningColumn extends BaseField {
+    _alias;
+    constructor(field) {
+        super();
+        const m = field.match(RETURNING_COLUMN_PATTERN);
+        if (!m)
+            throw new TypeError(`"${field}" does not match returning column format`);
+        this._field = m[1];
+        this._alias = m[2];
+    }
+    get _type() {
+        return SerializationType.RETURNING_COLUMN;
+    }
+    _serialize(ctx) {
+        const o = {
+            field: this._field,
+            alias: this._alias
+        };
+        ctx.returningFields = ctx.returningFields || [];
+        ctx.returningFields.push(o);
+        return ctx.serialize(this._type, o, () => {
+            return ctx.escapeReserved(o.field) +
+                (o.alias ? ' as ' + ctx.escapeReserved(o.alias) : '');
+        });
+    }
+}

package/esm/sql-objects/sequence-getter-statement.d.ts

@@ -0,0 +1,24 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
+export declare class SequenceGetterStatement extends Serializable {
+    _expression: string;
+    _next: boolean;
+    _alias?: string;
+    constructor(expression: string, next?: boolean);
+    get _type(): SerializationType;
+    next(value: boolean): this;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}

package/esm/sql-objects/sequence-getter-statement.js

@@ -0,0 +1,47 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class SequenceGetterStatement extends Serializable {
+    _expression;
+    _next;
+    _alias;
+    constructor(expression, next) {
+        super();
+        this._expression = expression;
+        this._next = !!next;
+    }
+    get _type() {
+        return SerializationType.SEQUENCE_GETTER_STATEMENT;
+    }
+    next(value) {
+        this._next = 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._expression)
+            return '';
+        const q = {
+            genName: this._expression,
+            next: this._next,
+            alias: this._alias
+        };
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        return (o.next ? 'nextval' : 'currval') + '(\'' + o.genName + '\')' +
+            (o.alias ? ' ' + o.alias : '');
+    }
+}