@sqb/builder 4.26.1 → 5.0.0

package/sql/operators/lt.js

@@ -0,0 +1,20 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+class LtClass extends CompOperator {
+}
+export const Lt = function (left, right) {
+    if (!(this instanceof Lt))
+        return new Lt(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.lt;
+    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];
+    }
+};
+Lt.prototype = LtClass.prototype;
+Lt.prototype.constructor = Lt;

package/sql/operators/lte.d.ts

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

package/sql/operators/lte.js

@@ -0,0 +1,20 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+class LteClass extends CompOperator {
+}
+export const Lte = function (left, right) {
+    if (!(this instanceof Lte))
+        return new Lte(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.lte;
+    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];
+    }
+};
+Lte.prototype = LteClass.prototype;
+Lte.prototype.constructor = Lte;

package/sql/operators/ne.d.ts

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

package/sql/operators/ne.js

@@ -0,0 +1,20 @@
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+class NeClass extends CompOperator {
+}
+export const Ne = function (left, right) {
+    if (!(this instanceof Ne))
+        return new Ne(left, right);
+    CompOperator.call(this, left, right);
+    this._operatorType = OperatorType.ne;
+    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];
+    }
+};
+Ne.prototype = NeClass.prototype;
+Ne.prototype.constructor = Ne;

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

@@ -0,0 +1,15 @@
+import { Serializable } from '../../serializable.js';
+import { Between } from './between.js';
+declare class NotBetweenClass extends Between {
+}
+interface NotBetweenCtor {
+    new (left: string | Serializable, right: any[] | Serializable): NotBetween;
+    new (left: string | Serializable, right1: any, right2: any): NotBetween;
+    (left: string | Serializable, right: any[] | Serializable): NotBetween;
+    (left: string | Serializable, right1: any, right2: any): NotBetween;
+    prototype: NotBetween;
+}
+export declare const NotBetween: NotBetweenCtor;
+export interface NotBetween extends NotBetweenClass {
+}
+export {};

package/sql/operators/not-between.js

@@ -0,0 +1,13 @@
+import { OperatorType } from '../../enums.js';
+import { Between } from './between.js';
+class NotBetweenClass extends Between {
+}
+export const NotBetween = function (left, right1, right2) {
+    if (!(this instanceof NotBetween))
+        return new NotBetween(left, right1, right2);
+    Between.call(this, left, right1, right2);
+    this._operatorType = OperatorType.notBetween;
+    this._symbol = 'not between';
+};
+NotBetween.prototype = NotBetweenClass.prototype;
+NotBetween.prototype.constructor = NotBetween;

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

@@ -0,0 +1,14 @@
+import type { Raw } from '../elements/index.js';
+import type { Select } from '../select.js';
+import { Exists } from './exists.js';
+declare class NotExistsClass extends Exists {
+}
+interface NotExistsCtor {
+    new (query: Select | Raw): NotExists;
+    (query: Select | Raw): NotExists;
+    prototype: NotExists;
+}
+export declare const NotExists: NotExistsCtor;
+export interface NotExists extends NotExistsClass {
+}
+export {};

package/sql/operators/not-exists.js

@@ -0,0 +1,13 @@
+import { OperatorType } from '../../enums.js';
+import { Exists } from './exists.js';
+class NotExistsClass extends Exists {
+}
+export const NotExists = function (query) {
+    if (!(this instanceof NotExists))
+        return new NotExists(query);
+    Exists.call(this, query);
+    this._operatorType = OperatorType.notExists;
+    this._symbol = 'not exists';
+};
+NotExists.prototype = NotExistsClass.prototype;
+NotExists.prototype.constructor = NotExists;

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

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

package/sql/operators/not-i-like.js

@@ -0,0 +1,13 @@
+import { OperatorType } from '../../enums.js';
+import { ILike } from './i-like.js';
+class NotILikeClass extends ILike {
+}
+export const NotILike = function (left, right) {
+    if (!(this instanceof NotILike))
+        return new NotILike(left, right);
+    ILike.call(this, left, right);
+    this._operatorType = OperatorType.notILike;
+    this._symbol = 'not ilike';
+};
+NotILike.prototype = NotILikeClass.prototype;
+NotILike.prototype.constructor = NotILike;

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

@@ -0,0 +1,13 @@
+import { Serializable } from '../../serializable.js';
+import { In } from './in.js';
+declare class NotInClass extends In {
+}
+interface NotInCtor {
+    new (left: string | Serializable, right: any[] | Serializable): NotIn;
+    (left: string | Serializable, right: any[] | Serializable): NotIn;
+    prototype: NotIn;
+}
+export declare const NotIn: NotInCtor;
+export interface NotIn extends NotInClass {
+}
+export {};

package/sql/operators/not-in.js

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

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

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

package/sql/operators/not-like.js

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

package/sql/operators/not.d.ts

@@ -0,0 +1,18 @@
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { Operator } from '../operators/operator.js';
+declare class NotClass extends Operator {
+    _expression: Serializable;
+    get _type(): SerializationType;
+    _serialize(ctx: SerializeContext): string;
+}
+interface NotCtor {
+    new (expression: Serializable): Not;
+    (expression: Serializable): Not;
+    prototype: Not;
+}
+export declare const Not: NotCtor;
+export interface Not extends NotClass {
+}
+export {};

package/sql/operators/not.js

@@ -0,0 +1,20 @@
+import { OperatorType, SerializationType } from '../../enums.js';
+import { Operator } from '../operators/operator.js';
+class NotClass extends Operator {
+    get _type() {
+        return SerializationType.NEGATIVE_EXPRESSION;
+    }
+    _serialize(ctx) {
+        const expression = ctx.anyToSQL(this._expression);
+        return ctx.serialize(this._type, expression, () => expression ? 'not ' + expression : '');
+    }
+}
+export const Not = function (expression) {
+    if (!(this instanceof Not))
+        return new Not(expression);
+    Operator.call(this);
+    this._operatorType = OperatorType.not;
+    this._expression = expression;
+};
+Not.prototype = NotClass.prototype;
+Not.prototype.constructor = Not;

package/sql/operators/operator.d.ts

@@ -0,0 +1,12 @@
+import { OperatorType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+export interface Operator extends Serializable {
+    _operatorType: OperatorType;
+}
+interface OperatorCtor {
+    new (): Operator;
+    (): Operator;
+    prototype: Operator;
+}
+export declare const Operator: OperatorCtor;
+export {};

package/sql/operators/operator.js

@@ -0,0 +1,11 @@
+import { Serializable } from '../../serializable.js';
+export const Operator = function () {
+    if (!(this instanceof Operator))
+        return new Operator();
+    if (this.constructor === Operator) {
+        throw new TypeError('Operator is abstract and cannot be instantiated');
+    }
+    Serializable.call(this);
+};
+Operator.prototype = Object.create(Serializable.prototype);
+Operator.prototype.constructor = Operator;

package/sql/operators/or.d.ts

@@ -0,0 +1,12 @@
+import { LogicalOperator } from './logical-operator.js';
+declare class OrClass extends LogicalOperator {
+}
+interface OrCtor {
+    new (...items: any[]): Or;
+    (...items: any[]): Or;
+    prototype: Or;
+}
+export declare const Or: OrCtor;
+export interface Or extends OrClass {
+}
+export {};

package/sql/operators/or.js

@@ -0,0 +1,12 @@
+import { OperatorType } from '../../enums.js';
+import { LogicalOperator } from './logical-operator.js';
+class OrClass extends LogicalOperator {
+}
+export const Or = function (...items) {
+    if (!(this instanceof Or))
+        return new Or(...items);
+    LogicalOperator.call(this, ...items);
+    this._operatorType = OperatorType.or;
+};
+Or.prototype = OrClass.prototype;
+Or.prototype.constructor = Or;

package/sql/query.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter } from 'events';
+import { Serializable } from '../serializable.js';
+import type { GenerateOptions, GenerateResult } from '../types.js';
+declare interface QueryClass extends EventEmitter {
+}
+declare class QueryClass extends Serializable {
+    protected _comment: Query.Comment[];
+    protected _params?: Record<string, any>;
+    /**
+     * Generates Sql script
+     */
+    generate(options?: GenerateOptions): GenerateResult;
+    values(obj: any): this;
+    comment(args: Query.Comment): this;
+    comment(text: string, dialect?: string[]): this;
+}
+interface QueryCtor {
+    new (): Query;
+    (): Query;
+    prototype: Query;
+}
+export declare const Query: QueryCtor;
+export interface Query extends QueryClass, EventEmitter {
+}
+export declare namespace Query {
+    interface Comment {
+        comment: string;
+        dialect?: string[];
+    }
+}
+export {};

package/{query → sql}/query.js

@@ -3,13 +3,7 @@ import flattenText from 'putil-flattentext';
 import merge from 'putil-merge';
 import { Serializable } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
-export class Query extends Serializable {
-    _comment = [];
-    _params;
-    constructor() {
-        super();
-        EventEmitter.call(this);
-    }
+class QueryClass extends Serializable {
     /**
      * Generates Sql script
      */
@@ -59,4 +53,16 @@ export class Query extends Serializable {
         return this;
     }
 }
+export const Query = function () {
+    if (!(this instanceof Query))
+        return new Query();
+    if (this.constructor === Query) {
+        throw new TypeError('Query is abstract and cannot be instantiated');
+    }
+    Serializable.call(this);
+    EventEmitter.call(this);
+    this._comment = [];
+};
+Query.prototype = QueryClass.prototype;
 merge(Query.prototype, EventEmitter.prototype, { descriptor: true });
+Query.prototype.constructor = Query;

package/sql/returning-query.d.ts

@@ -0,0 +1,23 @@
+import { SerializeContext } from '../serialize-context.js';
+import { ReturningColumn } from './elements/returning-column.js';
+import { Query } from './query.js';
+declare class ReturningQueryClass extends Query {
+    _returningColumns?: ReturningColumn[];
+    /**
+     *
+     */
+    returning(...columns: string[]): this;
+    /**
+     *
+     */
+    protected __serializeReturning(ctx: SerializeContext): string;
+}
+interface ReturningQueryCtor {
+    new (): ReturningQuery;
+    (): ReturningQuery;
+    prototype: ReturningQuery;
+}
+export declare const ReturningQuery: ReturningQueryCtor;
+export interface ReturningQuery extends ReturningQueryClass {
+}
+export {};

package/{query → sql}/returning-query.js

@@ -1,8 +1,8 @@
 import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
-import { ReturningColumn } from '../sql-objects/returning-column.js';
+import { ReturningColumn } from './elements/returning-column.js';
 import { Query } from './query.js';
-export class ReturningQuery extends Query {
+class ReturningQueryClass extends Query {
     _returningColumns;
     /**
      *
@@ -14,7 +14,7 @@ export class ReturningQuery extends Query {
         this._returningColumns = columns.length
             ? columns.reduce((a, v) => {
                 if (v)
-                    a.push(new ReturningColumn(v));
+                    a.push(ReturningColumn(v));
                 return a;
             }, [])
             : undefined;
@@ -40,3 +40,13 @@ export class ReturningQuery extends Query {
         });
     }
 }
+export const ReturningQuery = function () {
+    if (!(this instanceof ReturningQuery))
+        return new ReturningQuery();
+    if (this.constructor === ReturningQuery) {
+        throw new TypeError('ReturningQuery is abstract and cannot be instantiated');
+    }
+    Query.call(this);
+};
+ReturningQuery.prototype = ReturningQueryClass.prototype;
+ReturningQuery.prototype.constructor = ReturningQuery;

package/{query/select-query.d.ts → sql/select.d.ts}

@@ -1,18 +1,18 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
-import { GroupColumn } from '../sql-objects/group-column.js';
-import { JoinStatement } from '../sql-objects/join-statement.js';
-import { LogicalOperator } from '../sql-objects/operators/logical-operator.js';
-import { OrderColumn } from '../sql-objects/order-column.js';
-import { RawStatement } from '../sql-objects/raw-statement.js';
-import { TableName } from '../sql-objects/table-name.js';
+import { GroupColumn } from './elements/group-column.js';
+import { Join } from './elements/join.js';
+import { OrderColumn } from './elements/order-column.js';
+import { Raw } from './elements/raw.js';
+import { TableName } from './elements/table-name.js';
+import { LogicalOperator } from './operators/logical-operator.js';
 import { Query } from './query.js';
-import type { UnionQuery } from './union-query.js';
-export declare class SelectQuery extends Query {
+import type { Union } from './union.js';
+declare class SelectClass extends Query {
     _tables?: Serializable[];
     _columns?: Serializable[];
-    _joins?: JoinStatement[];
+    _joins?: Join[];
     _where?: LogicalOperator;
     _groupBy?: (GroupColumn | Serializable)[];
     _orderBy?: (OrderColumn | Serializable)[];
@@ -20,7 +20,6 @@ export declare class SelectQuery extends Query {
     _offset?: number;
     _alias?: string;
     _distinct?: boolean;
-    constructor(...column: (string | string[] | Serializable)[]);
     get _type(): SerializationType;
     /**
      * Adds columns to query.
@@ -29,11 +28,11 @@ export declare class SelectQuery extends Query {
     /**
      * Defines "from" part of  query.
      */
-    from(...table: (string | TableName | RawStatement | SelectQuery | UnionQuery)[]): this;
+    from(...table: (string | TableName | Raw | SelectClass | Union)[]): this;
     /**
      * Adds "join" statements to query
      */
-    join(...join: JoinStatement[]): this;
+    join(...join: Join[]): this;
     /**
      * Defines "where" part of query
      */
@@ -90,3 +89,12 @@ export declare class SelectQuery extends Query {
     protected __serializeGroupColumns(ctx: SerializeContext): string;
     protected __serializeOrderColumns(ctx: SerializeContext): string;
 }
+interface SelectCtor {
+    new (...column: (string | string[] | Serializable)[]): Select;
+    (...column: (string | string[] | Serializable)[]): Select;
+    prototype: Select;
+}
+export declare const Select: SelectCtor;
+export interface Select extends SelectClass {
+}
+export {};

package/{query/select-query.js → sql/select.js}

@@ -2,14 +2,14 @@ import { splitString } from 'fast-tokenizer';
 import { coerceToInt } from 'putil-varhelpers';
 import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
-import { FieldExpression } from '../sql-objects/field-expression.js';
-import { GroupColumn } from '../sql-objects/group-column.js';
-import { OpAnd } from '../sql-objects/operators/op-and.js';
-import { OrderColumn } from '../sql-objects/order-column.js';
-import { TableName } from '../sql-objects/table-name.js';
-import { isJoinStatement } from '../typeguards.js';
+import { isJoin } from '../type-guards.js';
+import { Field } from './elements/field.js';
+import { GroupColumn } from './elements/group-column.js';
+import { OrderColumn } from './elements/order-column.js';
+import { TableName } from './elements/table-name.js';
+import { And } from './operators/and.js';
 import { Query } from './query.js';
-export class SelectQuery extends Query {
+class SelectClass extends Query {
     _tables;
     _columns;
     _joins;
@@ -20,11 +20,6 @@ export class SelectQuery extends Query {
     _offset;
     _alias;
     _distinct;
-    constructor(...column) {
-        super();
-        if (column.length)
-            this.addColumn(...column);
-    }
     get _type() {
         return SerializationType.SELECT_QUERY;
     }
@@ -49,7 +44,7 @@ export class SelectQuery extends Query {
                         keepBrackets: true,
                     });
                     items.forEach(item => {
-                        this._columns.push(new FieldExpression(item));
+                        this._columns.push(Field(item));
                     });
                 }
                 else
@@ -82,7 +77,7 @@ export class SelectQuery extends Query {
         for (const arg of join) {
             if (!arg)
                 continue;
-            if (!isJoinStatement(arg))
+            if (!isJoin(arg))
                 throw new TypeError('Join statement required');
             this._joins.push(arg);
         }
@@ -92,7 +87,7 @@ export class SelectQuery extends Query {
      * Defines "where" part of query
      */
     where(...condition) {
-        this._where = this._where || new OpAnd();
+        this._where = this._where || new And();
         this._where.add(...condition);
         return this;
     }
@@ -217,7 +212,7 @@ export class SelectQuery extends Query {
                 const s = ctx.anyToSQL(t);
                 // t._serialize(ctx);
                 if (s) {
-                    if (t instanceof SelectQuery) {
+                    if (t instanceof SelectClass) {
                         if (!t._alias)
                             throw new TypeError('Alias required for sub-select in columns');
                         arr.push(s + ' ' + t._alias);
@@ -239,7 +234,7 @@ export class SelectQuery extends Query {
                 const s = t._serialize(ctx);
                 /* istanbul ignore else */
                 if (s) {
-                    if (t instanceof SelectQuery) {
+                    if (t instanceof SelectClass) {
                         if (!t._alias)
                             throw new TypeError('Alias required for sub-select in "from"');
                         arr.push({
@@ -320,3 +315,12 @@ export class SelectQuery extends Query {
         });
     }
 }
+export const Select = function (...column) {
+    if (!(this instanceof Select))
+        return new Select(...column);
+    Query.call(this);
+    if (column.length)
+        this.addColumn(...column);
+};
+Select.prototype = SelectClass.prototype;
+Select.prototype.constructor = Select;

package/{query/union-query.d.ts → sql/union.d.ts}

@@ -2,10 +2,9 @@ import { SerializationType } from '../enums.js';
 import { SerializeContext } from '../serialize-context.js';
 import { Query } from './query.js';
 export type UnionQueryType = 'all';
-export declare class UnionQuery extends Query {
+declare class UnionClass extends Query {
     _queries: Query[];
     _unionType?: UnionQueryType;
-    constructor(queries: Query[], unionType?: UnionQueryType);
     get _type(): SerializationType;
     /**
      * Performs serialization
@@ -13,3 +12,12 @@ export declare class UnionQuery extends Query {
     _serialize(ctx: SerializeContext): string;
     protected __defaultSerialize(ctx: SerializeContext, o: any): string;
 }
+interface UnionCtor {
+    new (queries: Query[], unionType?: UnionQueryType): Union;
+    (queries: Query[], unionType?: UnionQueryType): Union;
+    prototype: Union;
+}
+export declare const Union: UnionCtor;
+export interface Union extends UnionClass {
+}
+export {};

package/{query/union-query.js → sql/union.js}

@@ -1,13 +1,8 @@
 import { SerializationType } from '../enums.js';
 import { Query } from './query.js';
-export class UnionQuery extends Query {
+class UnionClass extends Query {
     _queries;
     _unionType;
-    constructor(queries, unionType) {
-        super();
-        this._queries = queries;
-        this._unionType = unionType;
-    }
     get _type() {
         return SerializationType.UNION_QUERY;
     }
@@ -26,3 +21,12 @@ export class UnionQuery extends Query {
         return o.queries.join(o.unionType === 'all' ? '\nUNION ALL\n' : '\nUNION\n');
     }
 }
+export const Union = function (queries, unionType) {
+    if (!(this instanceof Union))
+        return new Union(queries, unionType);
+    Query.call(this);
+    this._queries = queries;
+    this._unionType = unionType;
+};
+Union.prototype = UnionClass.prototype;
+Union.prototype.constructor = Union;