@sqb/builder 4.26.0 → 5.0.0

package/{sql-objects/operators/op-between.js → sql/operators/between.js}

@@ -1,13 +1,6 @@
 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];
-    }
+class BetweenClass extends CompOperator {
     _serialize(ctx) {
         if (!(this._right && this._right.length > 0))
             return '';
@@ -34,3 +27,22 @@ export class OpBetween extends CompOperator {
             o.right[1].expression);
     }
 }
+export const Between = function (left, right1, right2) {
+    const right = Array.isArray(right1) ? right1 : [right1, right2];
+    if (!(this instanceof Between))
+        return new Between(left, right);
+    if (right && right[1] == null)
+        right[1] = right[0];
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.between;
+    this._symbol = 'between';
+    if (typeof left === 'string') {
+        const m = left.match(/^([\w\\.$]+)(\[])?/);
+        if (!m)
+            throw new TypeError(`"${left}" is not a valid expression definition`);
+        this._left = m[1];
+        this._isArray = !!m[2];
+    }
+};
+Between.prototype = BetweenClass.prototype;
+Between.prototype.constructor = Between;

package/sql/operators/comp-operator.d.ts

@@ -0,0 +1,24 @@
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { Operator } from './operator.js';
+declare class CompOperatorClass extends Operator {
+    _left: Serializable | string;
+    _right?: any | Serializable;
+    _symbol?: string;
+    _isArray?: boolean;
+    get _type(): SerializationType;
+    _serialize(ctx: SerializeContext): string;
+    __serializeItem(ctx: SerializeContext, x: string | Serializable, left?: any): any;
+    __serialize(ctx: SerializeContext, o: any): string;
+    __defaultSerialize(ctx: SerializeContext, o: any): string;
+}
+interface CompOperatorCtor {
+    new (left: string | Serializable, right?: any): CompOperator;
+    (left: string | Serializable, right?: any): CompOperator;
+    prototype: CompOperator;
+}
+export declare const CompOperator: CompOperatorCtor;
+export interface CompOperator extends CompOperatorClass {
+}
+export {};

package/{sql-objects → sql}/operators/comp-operator.js

@@ -1,28 +1,13 @@
 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';
+import { Field, Param } from '../elements/index.js';
+import { Operator } from './operator.js';
 const EXPRESSION_PATTERN = /^([\w\\.$]+)(\[])?/;
-export class CompOperator extends Operator {
+class CompOperatorClass 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;
     }
@@ -46,18 +31,22 @@ export class CompOperator extends Operator {
             const name = 'P$_' + ++ctx.strictParamGenId;
             ctx.params = ctx.params || {};
             ctx.params[name] = x;
-            x = Param(name, left?.dataType, left?.isArray || Array.isArray(x));
+            x = Param({
+                name,
+                dataType: left?.dataType,
+                isArray: left?.isArray || Array.isArray(x),
+            });
         }
         if (x instanceof Serializable) {
             const expression = ctx.anyToSQL(x);
             const result = {
                 expression,
             };
-            if (x instanceof FieldExpression) {
+            if (x instanceof Field) {
                 result.dataType = x._dataType;
                 result.isArray = x._isArray;
             }
-            if (x instanceof ParamExpression) {
+            if (x instanceof Param) {
                 let value = ctx.params ? ctx.params[x._name] : undefined;
                 if (x._isArray && value != null && !Array.isArray(value))
                     value = [value];
@@ -83,3 +72,20 @@ export class CompOperator extends Operator {
         return o.left.expression + ' ' + o.symbol + ' ' + o.right.expression;
     }
 }
+export const CompOperator = function (left, right) {
+    if (!(this instanceof CompOperator))
+        return new CompOperator(left, right);
+    Operator.call(this);
+    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;
+};
+CompOperator.prototype = CompOperatorClass.prototype;
+CompOperator.prototype.constructor = CompOperator;

package/sql/operators/eq.d.ts

@@ -0,0 +1,13 @@
+import { Serializable } from '../../serializable.js';
+import { CompOperator } from './comp-operator.js';
+declare class EqClass extends CompOperator {
+}
+interface EqCtor {
+    new (left: string | Serializable, right: any): Eq;
+    (left: string | Serializable, right: any): Eq;
+    prototype: Eq;
+}
+export declare const Eq: EqCtor;
+export interface Eq extends EqClass {
+}
+export {};

package/sql/operators/eq.js

@@ -0,0 +1,23 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+class EqClass extends CompOperator {
+}
+export const Eq = function (left, right) {
+    if (!(this instanceof Eq))
+        return new Eq(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.eq;
+    this._symbol = '=';
+    if (typeof left === 'string') {
+        const m = left.match(/^([\w\\.$]+)(\[])?/);
+        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;
+};
+Eq.prototype = EqClass.prototype;
+Eq.prototype.constructor = Eq;

package/sql/operators/exists.d.ts

@@ -0,0 +1,17 @@
+import { SerializeContext } from '../../serialize-context.js';
+import type { Raw } from '../elements/index.js';
+import type { Select } from '../select.js';
+import { CompOperator } from './comp-operator.js';
+declare class ExistsClass extends CompOperator {
+    _serialize(ctx: SerializeContext): string;
+    __defaultSerialize(ctx: SerializeContext, o: any): string;
+}
+interface ExistsCtor {
+    new (query: Select | Raw): Exists;
+    (query: Select | Raw): Exists;
+    prototype: Exists;
+}
+export declare const Exists: ExistsCtor;
+export interface Exists extends ExistsClass {
+}
+export {};

package/sql/operators/exists.js

@@ -0,0 +1,31 @@
+import { OperatorType } from '../../enums.js';
+import { isRaw, isSelect } from '../../type-guards.js';
+import { CompOperator } from './comp-operator.js';
+class ExistsClass extends CompOperator {
+    _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 : '';
+    }
+}
+export const Exists = function (query) {
+    if (!(this instanceof Exists))
+        return new Exists(query);
+    CompOperator.call(this, query);
+    this._operatorType = OperatorType.exists;
+    this._symbol = 'exists';
+    if (!(typeof query === 'object' && (isSelect(query) || isRaw(query)))) {
+        throw new TypeError('You must provide a Select or Raw in `exists()`');
+    }
+};
+Exists.prototype = ExistsClass.prototype;
+Exists.prototype.constructor = Exists;

package/sql/operators/gt.d.ts

@@ -0,0 +1,13 @@
+import { Serializable } from '../../serializable.js';
+import { CompOperator } from './comp-operator.js';
+declare class GtClass extends CompOperator {
+}
+interface GtCtor {
+    new (left: string | Serializable, right?: any): Gt;
+    (left: string | Serializable, right?: any): Gt;
+    prototype: Gt;
+}
+export declare const Gt: GtCtor;
+export interface Gt extends GtClass {
+}
+export {};

package/sql/operators/gt.js

@@ -0,0 +1,20 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+class GtClass extends CompOperator {
+}
+export const Gt = function (left, right) {
+    if (!(this instanceof Gt))
+        return new Gt(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.gt;
+    this._symbol = '>';
+    if (typeof left === 'string') {
+        const m = left.match(/^([\w\\.$]+)(\[])?/);
+        if (!m)
+            throw new TypeError(`"${left}" is not a valid expression definition`);
+        this._left = m[1];
+        this._isArray = !!m[2];
+    }
+};
+Gt.prototype = GtClass.prototype;
+Gt.prototype.constructor = Gt;

package/sql/operators/gte.d.ts

@@ -0,0 +1,13 @@
+import { Serializable } from '../../serializable.js';
+import { CompOperator } from './comp-operator.js';
+declare class GteClass extends CompOperator {
+}
+interface GteCtor {
+    new (left: string | Serializable, right?: any): Gte;
+    (left: string | Serializable, right?: any): Gte;
+    prototype: Gte;
+}
+export declare const Gte: GteCtor;
+export interface Gte extends GteClass {
+}
+export {};

package/sql/operators/gte.js

@@ -0,0 +1,20 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+class GteClass extends CompOperator {
+}
+export const Gte = function (left, right) {
+    if (!(this instanceof Gte))
+        return new Gte(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.gte;
+    this._symbol = '>=';
+    if (typeof left === 'string') {
+        const m = left.match(/^([\w\\.$]+)(\[])?/);
+        if (!m)
+            throw new TypeError(`"${left}" is not a valid expression definition`);
+        this._left = m[1];
+        this._isArray = !!m[2];
+    }
+};
+Gte.prototype = GteClass.prototype;
+Gte.prototype.constructor = Gte;

package/sql/operators/i-like.d.ts

@@ -0,0 +1,13 @@
+import { Serializable } from '../../serializable.js';
+import { Like } from './like.js';
+declare class ILikeClass extends Like {
+}
+interface ILikeCtor {
+    new (left: string | Serializable, right?: string | Serializable): ILike;
+    (left: string | Serializable, right?: string | Serializable): ILike;
+    prototype: ILike;
+}
+export declare const ILike: ILikeCtor;
+export interface ILike extends ILikeClass {
+}
+export {};

package/sql/operators/i-like.js

@@ -0,0 +1,21 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+import { Like } from './like.js';
+class ILikeClass extends Like {
+}
+export const ILike = function (left, right) {
+    if (!(this instanceof ILike))
+        return new ILike(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.iLike;
+    this._symbol = 'ilike';
+    if (typeof left === 'string') {
+        const m = left.match(/^([\w\\.$]+)(\[])?/);
+        if (!m)
+            throw new TypeError(`"${left}" is not a valid expression definition`);
+        this._left = m[1];
+        this._isArray = !!m[2];
+    }
+};
+ILike.prototype = ILikeClass.prototype;
+ILike.prototype.constructor = ILike;

package/sql/operators/in.d.ts

@@ -0,0 +1,15 @@
+import type { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { CompOperator } from './comp-operator.js';
+declare class InClass extends CompOperator {
+    _serialize(ctx: SerializeContext): string;
+}
+interface InCtor {
+    new (left: string | Serializable, right: any[] | Serializable): In;
+    (left: string | Serializable, right: any[] | Serializable): In;
+    prototype: In;
+}
+export declare const In: InCtor;
+export interface In extends InClass {
+}
+export {};

package/sql/operators/in.js

@@ -0,0 +1,27 @@
+import { OperatorType } from '../../enums.js';
+import { isSerializable } from '../../type-guards.js';
+import { CompOperator } from './comp-operator.js';
+class InClass extends CompOperator {
+    _serialize(ctx) {
+        if (Array.isArray(this._right) && !this._right.length)
+            return '';
+        return super._serialize(ctx);
+    }
+}
+export const In = function (left, right) {
+    if (!(this instanceof In))
+        return new In(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.in;
+    this._symbol = 'in';
+    if (typeof left === 'string') {
+        const m = left.match(/^([\w\\.$]+)(\[])?/);
+        if (!m)
+            throw new TypeError(`"${left}" is not a valid expression definition`);
+        this._left = m[1];
+        this._isArray = !!m[2];
+    }
+    this._right = Array.isArray(right) || isSerializable(right) ? right : [right];
+};
+In.prototype = InClass.prototype;
+In.prototype.constructor = In;

package/sql/operators/index.d.ts

@@ -0,0 +1,24 @@
+export * from './and.js';
+export * from './between.js';
+export * from './comp-operator.js';
+export * from './eq.js';
+export * from './exists.js';
+export * from './gt.js';
+export * from './gte.js';
+export * from './i-like.js';
+export * from './in.js';
+export * from './is.js';
+export * from './is-not.js';
+export * from './like.js';
+export * from './logical-operator.js';
+export * from './lt.js';
+export * from './lte.js';
+export * from './ne.js';
+export * from './not.js';
+export * from './not-between.js';
+export * from './not-exists.js';
+export * from './not-i-like.js';
+export * from './not-in.js';
+export * from './not-like.js';
+export * from './operator.js';
+export * from './or.js';

package/sql/operators/index.js

@@ -0,0 +1,24 @@
+export * from './and.js';
+export * from './between.js';
+export * from './comp-operator.js';
+export * from './eq.js';
+export * from './exists.js';
+export * from './gt.js';
+export * from './gte.js';
+export * from './i-like.js';
+export * from './in.js';
+export * from './is.js';
+export * from './is-not.js';
+export * from './like.js';
+export * from './logical-operator.js';
+export * from './lt.js';
+export * from './lte.js';
+export * from './ne.js';
+export * from './not.js';
+export * from './not-between.js';
+export * from './not-exists.js';
+export * from './not-i-like.js';
+export * from './not-in.js';
+export * from './not-like.js';
+export * from './operator.js';
+export * from './or.js';

package/sql/operators/is-not.d.ts

@@ -0,0 +1,13 @@
+import { Serializable } from '../../serializable.js';
+import { Is } from './is.js';
+declare class IsNotClass extends Is {
+}
+interface IsNotCtor {
+    new (left: string | Serializable, right?: any): IsNot;
+    (left: string | Serializable, right?: any): IsNot;
+    prototype: IsNot;
+}
+export declare const IsNot: IsNotCtor;
+export interface IsNot extends IsNotClass {
+}
+export {};

package/sql/operators/is-not.js

@@ -0,0 +1,13 @@
+import { OperatorType } from '../../enums.js';
+import { Is } from './is.js';
+class IsNotClass extends Is {
+}
+export const IsNot = function (left, right) {
+    if (!(this instanceof IsNot))
+        return new IsNot(left, right);
+    Is.call(this, left, right);
+    this._operatorType = OperatorType.isNot;
+    this._symbol = 'is not';
+};
+IsNot.prototype = IsNotClass.prototype;
+IsNot.prototype.constructor = IsNot;

package/sql/operators/is.d.ts

@@ -0,0 +1,13 @@
+import { Serializable } from '../../serializable.js';
+import { CompOperator } from './comp-operator.js';
+declare class IsClass extends CompOperator {
+}
+interface IsCtor {
+    new (left: string | Serializable, right?: any): Is;
+    (left: string | Serializable, right?: any): Is;
+    prototype: Is;
+}
+export declare const Is: IsCtor;
+export interface Is extends IsClass {
+}
+export {};

package/sql/operators/is.js

@@ -0,0 +1,20 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+class IsClass extends CompOperator {
+}
+export const Is = function (left, right) {
+    if (!(this instanceof Is))
+        return new Is(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.is;
+    this._symbol = 'is';
+    if (typeof left === 'string') {
+        const m = left.match(/^([\w\\.$]+)(\[])?/);
+        if (!m)
+            throw new TypeError(`"${left}" is not a valid expression definition`);
+        this._left = m[1];
+        this._isArray = !!m[2];
+    }
+};
+Is.prototype = IsClass.prototype;
+Is.prototype.constructor = Is;

package/sql/operators/like.d.ts

@@ -0,0 +1,15 @@
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { CompOperator } from './comp-operator.js';
+declare class LikeClass extends CompOperator {
+    __serialize(ctx: SerializeContext, o: any): string;
+}
+interface LikeCtor {
+    new (left: string | Serializable, right?: string | Serializable): Like;
+    (left: string | Serializable, right?: string | Serializable): Like;
+    prototype: Like;
+}
+export declare const Like: LikeCtor;
+export interface Like extends LikeClass {
+}
+export {};

package/sql/operators/like.js

@@ -0,0 +1,27 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+class LikeClass extends CompOperator {
+    __serialize(ctx, o) {
+        if (!o.right.expression)
+            return '';
+        if (o.right && typeof o.right.expression !== 'string')
+            o.right.expression = String(o.right.expression);
+        return ctx.serialize(this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
+    }
+}
+export const Like = function (left, right) {
+    if (!(this instanceof Like))
+        return new Like(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.like;
+    this._symbol = 'like';
+    if (typeof left === 'string') {
+        const m = left.match(/^([\w\\.$]+)(\[])?/);
+        if (!m)
+            throw new TypeError(`"${left}" is not a valid expression definition`);
+        this._left = m[1];
+        this._isArray = !!m[2];
+    }
+};
+Like.prototype = LikeClass.prototype;
+Like.prototype.constructor = Like;

package/sql/operators/logical-operator.d.ts

@@ -0,0 +1,15 @@
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { Operator } from './operator.js';
+export interface LogicalOperator extends Operator {
+    _items: Serializable[];
+    add(...expressions: (LogicalOperator | any)[]): this;
+    _serialize(ctx: SerializeContext): string;
+}
+interface LogicalOperatorCtor {
+    new (...expressions: any[]): LogicalOperator;
+    (...expressions: any[]): LogicalOperator;
+    prototype: LogicalOperator;
+}
+export declare const LogicalOperator: LogicalOperatorCtor;
+export {};

package/sql/operators/logical-operator.js

@@ -0,0 +1,86 @@
+import isPlainObject from 'putil-isplainobject';
+import { SerializationType } from '../../enums.js';
+import { printArray } from '../../helpers.js';
+import { isCompOperator, isLogicalOperator, isNot, isRaw, } from '../../type-guards.js';
+import { Operator } from './operator.js';
+// noinspection RegExpUnnecessaryNonCapturingGroup
+const COMPARE_LEFT_PATTERN = /^([\w\\.$]+(?:\[])?) *(.*)$/;
+function wrapObject(obj) {
+    const registeredOperators = LogicalOperator.Operators;
+    const result = [];
+    for (const n of Object.getOwnPropertyNames(obj)) {
+        let fn;
+        const v = obj[n];
+        if (['and', 'or'].includes(n.toLowerCase())) {
+            fn = registeredOperators[n.toLowerCase()];
+            if (!fn)
+                throw new Error(`Unknown operator "${n}"`);
+            result.push(Array.isArray(v) ? fn(...v) : fn(v));
+            continue;
+        }
+        if (['exists', '!exists'].includes(n)) {
+            fn = registeredOperators[n];
+            const inst = fn(obj[n]);
+            result.push(inst);
+        }
+        else {
+            const m = n.match(COMPARE_LEFT_PATTERN);
+            if (!m)
+                throw new TypeError(`"${n}" is not a valid expression definition`);
+            fn = registeredOperators[m[2] || 'eq'];
+            if (!fn)
+                throw new Error(`Unknown operator "${m[2]}"`);
+            const inst = fn(m[1], obj[n]);
+            result.push(inst);
+        }
+    }
+    return result;
+}
+export const LogicalOperator = function (...expressions) {
+    if (!(this instanceof LogicalOperator))
+        return new LogicalOperator(...expressions);
+    if (this.constructor === LogicalOperator) {
+        throw new TypeError('LogicalOperator is abstract and cannot be instantiated');
+    }
+    Operator.call(this);
+    this._items = [];
+    this.add(...expressions);
+};
+LogicalOperator.prototype = Object.create(Operator.prototype);
+LogicalOperator.prototype.constructor = LogicalOperator;
+Object.defineProperty(LogicalOperator.prototype, '_type', {
+    get() {
+        return SerializationType.LOGICAL_EXPRESSION;
+    },
+});
+LogicalOperator.prototype.add = function (...expressions) {
+    for (const item of expressions) {
+        if (!item)
+            continue;
+        if (isLogicalOperator(item)) {
+            this._items.push(item);
+        }
+        else if (isRaw(item) || isCompOperator(item) || isNot(item)) {
+            this._items.push(item);
+        }
+        else if (isPlainObject(item)) {
+            this.add(...wrapObject(item));
+        }
+        else
+            throw new TypeError('Operator or Raw type required');
+    }
+    return this;
+};
+LogicalOperator.prototype._serialize = function (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;
+    });
+};

package/sql/operators/lt.d.ts

@@ -0,0 +1,13 @@
+import { Serializable } from '../../serializable.js';
+import { CompOperator } from './comp-operator.js';
+declare class LtClass extends CompOperator {
+}
+interface LtCtor {
+    new (left: string | Serializable, right?: any): Lt;
+    (left: string | Serializable, right?: any): Lt;
+    prototype: Lt;
+}
+export declare const Lt: LtCtor;
+export interface Lt extends LtClass {
+}
+export {};