@sqb/builder 4.26.1 → 5.0.0

package/index.d.ts

@@ -1,20 +1,10 @@
-export * as classes from './classes.ns.js';
 export * from './enums.js';
 export * from './extensions.js';
 export * from './helpers.js';
-export * from './op.initializers.js';
-export { op } from './op.initializers.js';
-export * from './query/delete-query.js';
-export * from './query/insert-query.js';
-export * from './query/query.js';
-export * from './query/select-query.js';
-export * from './query/update-query.js';
+export * from './op.ns.js';
 export * from './serializable.js';
 export * from './serialize-context.js';
-export * from './sql-objects/join-statement.js';
-export * from './sql-objects/operator.js';
-export * from './sql-objects/operators/comp-operator.js';
-export * from './sql-objects/operators/logical-operator.js';
-export * from './sqlobject.initializers.js';
-export * from './typeguards.js';
+export * as sql from './sql/index.js';
+export * from './sql/index.js';
+export * from './type-guards.js';
 export * from './types.js';

package/index.js

@@ -1,20 +1,10 @@
-export * as classes from './classes.ns.js';
 export * from './enums.js';
 export * from './extensions.js';
 export * from './helpers.js';
-export * from './op.initializers.js';
-export { op } from './op.initializers.js';
-export * from './query/delete-query.js';
-export * from './query/insert-query.js';
-export * from './query/query.js';
-export * from './query/select-query.js';
-export * from './query/update-query.js';
+export * from './op.ns.js';
 export * from './serializable.js';
 export * from './serialize-context.js';
-export * from './sql-objects/join-statement.js';
-export * from './sql-objects/operator.js';
-export * from './sql-objects/operators/comp-operator.js';
-export * from './sql-objects/operators/logical-operator.js';
-export * from './sqlobject.initializers.js';
-export * from './typeguards.js';
+export * as sql from './sql/index.js';
+export * from './sql/index.js';
+export * from './type-guards.js';
 export * from './types.js';

package/op.ns.d.ts

@@ -0,0 +1,64 @@
+import { And } from './sql/operators/and.js';
+import { Between } from './sql/operators/between.js';
+import { Eq } from './sql/operators/eq.js';
+import { Exists } from './sql/operators/exists.js';
+import { Gt } from './sql/operators/gt.js';
+import { Gte } from './sql/operators/gte.js';
+import { ILike } from './sql/operators/i-like.js';
+import { In } from './sql/operators/in.js';
+import { Is } from './sql/operators/is.js';
+import { IsNot } from './sql/operators/is-not.js';
+import { Like } from './sql/operators/like.js';
+import { Lt } from './sql/operators/lt.js';
+import { Lte } from './sql/operators/lte.js';
+import { Ne } from './sql/operators/ne.js';
+import { Not } from './sql/operators/not.js';
+import { NotBetween } from './sql/operators/not-between.js';
+import { NotExists } from './sql/operators/not-exists.js';
+import { NotILike } from './sql/operators/not-i-like.js';
+import { NotIn } from './sql/operators/not-in.js';
+import { NotLike } from './sql/operators/not-like.js';
+import { Or } from './sql/operators/or.js';
+export interface OperatorsMap {
+    and: typeof And;
+    or: typeof Or;
+    eq: typeof Eq;
+    '=': typeof Eq;
+    ne: typeof Ne;
+    '!=': typeof Ne;
+    gt: typeof Gt;
+    '>': typeof Gt;
+    gte: typeof Gte;
+    '>=': typeof Gte;
+    lt: typeof Lt;
+    '<': typeof Lt;
+    lte: typeof Lte;
+    '<=': typeof Lte;
+    between: typeof Between;
+    btw: typeof Between;
+    notBetween: typeof NotBetween;
+    nbtw: typeof NotBetween;
+    '!between': typeof NotBetween;
+    '!btw': typeof NotBetween;
+    in: typeof In;
+    notIn: typeof NotIn;
+    nin: typeof NotIn;
+    '!in': typeof NotIn;
+    like: typeof Like;
+    not: typeof Not;
+    notLike: typeof NotLike;
+    nlike: typeof NotLike;
+    '!like': typeof NotLike;
+    ilike: typeof ILike;
+    notILike: typeof NotILike;
+    nilike: typeof NotILike;
+    '!ilike': typeof NotILike;
+    is: typeof Is;
+    isNot: typeof IsNot;
+    '!is': typeof IsNot;
+    exists: typeof Exists;
+    notExists: typeof NotExists;
+    '!exists': typeof NotExists;
+}
+declare const Operators: OperatorsMap;
+export { Operators };

package/op.ns.js

@@ -0,0 +1,65 @@
+import { LogicalOperator } from './sql/index.js';
+import { And } from './sql/operators/and.js';
+import { Between } from './sql/operators/between.js';
+import { Eq } from './sql/operators/eq.js';
+import { Exists } from './sql/operators/exists.js';
+import { Gt } from './sql/operators/gt.js';
+import { Gte } from './sql/operators/gte.js';
+import { ILike } from './sql/operators/i-like.js';
+import { In } from './sql/operators/in.js';
+import { Is } from './sql/operators/is.js';
+import { IsNot } from './sql/operators/is-not.js';
+import { Like } from './sql/operators/like.js';
+import { Lt } from './sql/operators/lt.js';
+import { Lte } from './sql/operators/lte.js';
+import { Ne } from './sql/operators/ne.js';
+import { Not } from './sql/operators/not.js';
+import { NotBetween } from './sql/operators/not-between.js';
+import { NotExists } from './sql/operators/not-exists.js';
+import { NotILike } from './sql/operators/not-i-like.js';
+import { NotIn } from './sql/operators/not-in.js';
+import { NotLike } from './sql/operators/not-like.js';
+import { Or } from './sql/operators/or.js';
+const Operators = {
+    and: And,
+    or: Or,
+    eq: Eq,
+    '=': Eq,
+    ne: Ne,
+    '!=': Ne,
+    gt: Gt,
+    '>': Gt,
+    gte: Gte,
+    '>=': Gte,
+    lt: Lt,
+    '<': Lt,
+    lte: Lte,
+    '<=': Lte,
+    between: Between,
+    btw: Between,
+    notBetween: NotBetween,
+    nbtw: NotBetween,
+    '!between': NotBetween,
+    '!btw': NotBetween,
+    in: In,
+    notIn: NotIn,
+    nin: NotIn,
+    '!in': NotIn,
+    like: Like,
+    not: Not,
+    notLike: NotLike,
+    nlike: NotLike,
+    '!like': NotLike,
+    ilike: ILike,
+    notILike: NotILike,
+    nilike: NotILike,
+    '!ilike': NotILike,
+    is: Is,
+    isNot: IsNot,
+    '!is': IsNot,
+    exists: Exists,
+    notExists: NotExists,
+    '!exists': NotExists,
+};
+LogicalOperator.Operators = Operators;
+export { Operators };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/builder",
   "description": "Extensible multi-dialect SQL query builder written with TypeScript",
-  "version": "4.26.1",
+  "version": "5.0.0",
   "author": "Panates",
   "license": "Apache-2.0",
   "dependencies": {

package/serializable.d.ts

@@ -1,9 +1,16 @@
 import type { SerializationType } from './enums.js';
 import type { SerializeContext } from './serialize-context.js';
-export declare abstract class Serializable {
-    abstract _type: SerializationType;
+export interface Serializable {
+    _type: SerializationType;
     /**
      * Performs serialization
      */
-    abstract _serialize(ctx: SerializeContext): string;
+    _serialize(ctx: SerializeContext): string;
 }
+interface SerializableCtor {
+    new (): Serializable;
+    (): Serializable;
+    prototype: Serializable;
+}
+export declare const Serializable: SerializableCtor;
+export {};

package/serializable.js

@@ -1,2 +1,7 @@
-export class Serializable {
-}
+export const Serializable = function () {
+    if (!this)
+        return new Serializable();
+    if (this.constructor === Serializable) {
+        throw new TypeError('Serializable is abstract and cannot be instantiated');
+    }
+};

package/serialize-context.d.ts

@@ -1,5 +1,5 @@
-import type { Query } from './query/query.js';
-import { DefaultSerializeFunction, GenerateOptions, ParamOptions } from './types.js';
+import { Query } from './sql/index.js';
+import type { DefaultSerializeFunction, GenerateOptions, ParamOptions } from './types.js';
 export declare class SerializeContext implements GenerateOptions {
     readonly rootQuery: Query;
     readonly reservedWords: string[];

package/serialize-context.js

@@ -1,7 +1,7 @@
 import { SerializationType } from './enums.js';
 import { SerializerRegistry } from './extensions.js';
 import { Serializable } from './serializable.js';
-import { isLogicalOperator, isQuery, isSerializable } from './typeguards.js';
+import { isLogicalOperator, isQuery, isSerializable } from './type-guards.js';
 export class SerializeContext {
     rootQuery;
     reservedWords = [

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

@@ -1,13 +1,12 @@
 import { SerializationType } from '../enums.js';
 import { SerializeContext } from '../serialize-context.js';
-import { LogicalOperator } from '../sql-objects/operators/logical-operator.js';
-import { RawStatement } from '../sql-objects/raw-statement.js';
-import { TableName } from '../sql-objects/table-name.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';
-export declare class DeleteQuery extends Query {
-    _table: TableName | RawStatement;
+declare class DeleteClass extends Query {
+    _table: TableName | Raw;
     _where?: LogicalOperator;
-    constructor(tableName: string | TableName | RawStatement);
     get _type(): SerializationType;
     /**
      * Defines "where" part of query
@@ -23,3 +22,12 @@ export declare class DeleteQuery extends Query {
      */
     _serializeWhere(ctx: SerializeContext): string;
 }
+interface DeleteCtor {
+    new (tableName: string | TableName | Raw): Delete;
+    (tableName: string | TableName | Raw): Delete;
+    prototype: Delete;
+}
+export declare const Delete: DeleteCtor;
+export interface Delete extends DeleteClass {
+}
+export {};

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

@@ -1,26 +1,11 @@
 import { SerializationType } from '../enums.js';
-import { OpAnd } from '../sql-objects/operators/op-and.js';
-import { TableName } from '../sql-objects/table-name.js';
-import { isRawStatement } from '../typeguards.js';
+import { isRaw } from '../type-guards.js';
+import { TableName } from './elements/table-name.js';
+import { And } from './operators/and.js';
 import { Query } from './query.js';
-export class DeleteQuery extends Query {
+class DeleteClass extends Query {
     _table;
     _where;
-    constructor(tableName) {
-        super();
-        if (!(tableName &&
-            (tableName instanceof TableName ||
-                typeof tableName === 'string' ||
-                isRawStatement(tableName)))) {
-            throw new TypeError('String or Raw instance required as first argument (tableName) for UpdateQuery');
-        }
-        this._table =
-            tableName instanceof TableName
-                ? tableName
-                : typeof tableName === 'string'
-                    ? new TableName(tableName)
-                    : tableName;
-    }
     get _type() {
         return SerializationType.DELETE_QUERY;
     }
@@ -28,7 +13,7 @@ export class DeleteQuery extends Query {
      * Defines "where" part of query
      */
     where(...operator) {
-        this._where = this._where || new OpAnd();
+        this._where = this._where || new And();
         this._where.add(...operator);
         return this;
     }
@@ -57,3 +42,22 @@ export class DeleteQuery extends Query {
         s ? 'where ' + s : '');
     }
 }
+export const Delete = function (tableName) {
+    if (!(this instanceof Delete))
+        return new Delete(tableName);
+    Query.call(this);
+    if (!(tableName &&
+        (tableName instanceof TableName ||
+            typeof tableName === 'string' ||
+            isRaw(tableName)))) {
+        throw new TypeError('String or Raw instance required as first argument (tableName) for Delete');
+    }
+    this._table =
+        tableName instanceof TableName
+            ? tableName
+            : typeof tableName === 'string'
+                ? TableName(tableName)
+                : tableName;
+};
+Delete.prototype = DeleteClass.prototype;
+Delete.prototype.constructor = Delete;

package/sql/elements/base-field.d.ts

@@ -0,0 +1,18 @@
+import { DataType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+export interface BaseField extends Serializable {
+    _dataType?: DataType;
+    _isArray?: boolean;
+    _isDataSet?: boolean;
+    _field: string;
+    _schema?: string;
+    _table?: string;
+    _descending?: boolean;
+}
+interface BaseFieldCtor {
+    new (): BaseField;
+    (): BaseField;
+    prototype: BaseField;
+}
+export declare const BaseField: BaseFieldCtor;
+export {};

package/sql/elements/base-field.js

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

package/{sql-objects/case-statement.d.ts → sql/elements/case.d.ts}

@@ -1,10 +1,10 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { SerializeContext } from '../serialize-context.js';
-import { Operator } from './operator.js';
-import { LogicalOperator } from './operators/logical-operator.js';
-import { RawStatement } from './raw-statement.js';
-export declare class CaseStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { LogicalOperator } from '../operators/logical-operator.js';
+import { Operator } from '../operators/operator.js';
+import { Raw } from './raw.js';
+declare class CaseClass extends Serializable {
     _expressions: {
         condition: Serializable;
         value: any;
@@ -12,12 +12,11 @@ export declare class CaseStatement extends Serializable {
     _elseValue: any;
     _condition?: LogicalOperator;
     _alias?: string;
-    constructor();
     get _type(): SerializationType;
     /**
      * Defines "when" part of Case expression.
      */
-    when(...condition: (Operator | RawStatement)[]): this;
+    when(...condition: (Operator | Raw)[]): this;
     /**
      * Defines "then" part of Case expression.
      */
@@ -40,3 +39,12 @@ export declare class CaseStatement extends Serializable {
     _serialize(ctx: SerializeContext): string;
     protected __defaultSerialize(ctx: SerializeContext, o: any): string;
 }
+interface CaseCtor {
+    new (): Case;
+    (): Case;
+    prototype: Case;
+}
+export declare const Case: CaseCtor;
+export interface Case extends CaseClass {
+}
+export {};

package/{sql-objects/case-statement.js → sql/elements/case.js}

@@ -1,15 +1,11 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { OpAnd } from './operators/op-and.js';
-export class CaseStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { And } from '../operators/and.js';
+class CaseClass extends Serializable {
     _expressions;
     _elseValue;
     _condition;
     _alias;
-    constructor() {
-        super();
-        this._expressions = [];
-    }
     get _type() {
         return SerializationType.CASE_STATEMENT;
     }
@@ -18,7 +14,7 @@ export class CaseStatement extends Serializable {
      */
     when(...condition) {
         if (condition.length)
-            this._condition = new OpAnd(...condition);
+            this._condition = new And(...condition);
         else
             this._condition = undefined;
         return this;
@@ -85,3 +81,11 @@ export class CaseStatement extends Serializable {
         return out;
     }
 }
+export const Case = function () {
+    if (!(this instanceof Case))
+        return new Case();
+    Serializable.call(this);
+    this._expressions = [];
+};
+Case.prototype = CaseClass.prototype;
+Case.prototype.constructor = Case;

package/sql/elements/coalesce.d.ts

@@ -0,0 +1,30 @@
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+declare class CoalesceClass extends Serializable {
+    _expressions: any[];
+    _alias?: string;
+    get _type(): SerializationType;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}
+interface CoalesceCtor {
+    new (...expressions: any[]): Coalesce;
+    (...expressions: any[]): Coalesce;
+    prototype: Coalesce;
+}
+export declare const Coalesce: CoalesceCtor;
+export interface Coalesce extends CoalesceClass {
+}
+export {};

package/{sql-objects/coalesce-statement.js → sql/elements/coalesce.js}

@@ -1,12 +1,8 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class CoalesceStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+class CoalesceClass extends Serializable {
     _expressions;
     _alias;
-    constructor(...expressions) {
-        super();
-        this._expressions = expressions;
-    }
     get _type() {
         return SerializationType.COALESCE_STATEMENT;
     }
@@ -42,3 +38,11 @@ export class CoalesceStatement extends Serializable {
             (this._alias ? ' ' + this._alias : ''));
     }
 }
+export const Coalesce = function (...expressions) {
+    if (!(this instanceof Coalesce))
+        return new Coalesce(...expressions);
+    Serializable.call(this);
+    this._expressions = expressions;
+};
+Coalesce.prototype = CoalesceClass.prototype;
+Coalesce.prototype.constructor = Coalesce;

package/sql/elements/count.d.ts

@@ -0,0 +1,29 @@
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+declare class CountClass extends Serializable {
+    _alias?: string;
+    get _type(): SerializationType;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}
+interface CountCtor {
+    new (): Count;
+    (): Count;
+    prototype: Count;
+}
+export declare const Count: CountCtor;
+export interface Count extends CountClass {
+}
+export {};

package/{sql-objects/count-statement.js → sql/elements/count.js}

@@ -1,6 +1,6 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class CountStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+class CountClass extends Serializable {
     _alias;
     get _type() {
         return SerializationType.COUNT_STATEMENT;
@@ -31,3 +31,10 @@ export class CountStatement extends Serializable {
         return 'count(*)';
     }
 }
+export const Count = function () {
+    if (!(this instanceof Count))
+        return new Count();
+    Serializable.call(this);
+};
+Count.prototype = CountClass.prototype;
+Count.prototype.constructor = Count;

package/sql/elements/field.d.ts

@@ -0,0 +1,27 @@
+import { DataType, SerializationType } from '../../enums.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { BaseField } from './base-field.js';
+declare class FieldClass extends BaseField {
+    _alias?: string;
+    get _type(): SerializationType;
+    _serialize(ctx: SerializeContext): string;
+}
+interface FieldCtor {
+    new (expression: string, dataType?: DataType, isArray?: boolean): Field;
+    new (args: {
+        expression: string;
+        dataType?: DataType;
+        isArray?: boolean;
+    }): Field;
+    (expression: string, dataType?: DataType, isArray?: boolean): Field;
+    (args: {
+        expression: string;
+        dataType?: DataType;
+        isArray?: boolean;
+    }): Field;
+    prototype: Field;
+}
+export declare const Field: FieldCtor;
+export interface Field extends FieldClass {
+}
+export {};

package/sql/elements/field.js

@@ -0,0 +1,54 @@
+import { SerializationType } from '../../enums.js';
+import { BaseField } from './base-field.js';
+const TABLE_COLUMN_PATTERN = /^ *((?:[a-zA-Z_][\w$_]*\.){0,2}) *([0-9a-zA-Z_][\w$_]*|\*) *(?:as)? *([a-zA-Z_][\w$_]*)?$/;
+class FieldClass extends BaseField {
+    _alias;
+    get _type() {
+        return SerializationType.FIELD_NAME;
+    }
+    _serialize(ctx) {
+        const o = {
+            schema: this._schema,
+            table: this._table,
+            field: this._field,
+            alias: this._alias,
+            isReservedWord: !!(this._field && ctx.isReservedWord(this._field)),
+        };
+        return ctx.serialize(this._type, o, () => {
+            const prefix = ctx.escapeReserved(this._schema ? this._schema + '.' : '') +
+                (this._table ? this._table + '.' : '');
+            return (prefix +
+                (!prefix && o.isReservedWord ? '"' + this._field + '"' : this._field) +
+                (this._alias ? ' as ' + this._alias : ''));
+        });
+    }
+}
+export const Field = function (arg0, arg1, arg2) {
+    if (!(this instanceof Field))
+        return new Field(arg0, arg1, arg2);
+    BaseField.call(this);
+    let expression;
+    if (typeof arg0 === 'object') {
+        expression = arg0.expression;
+        this._dataType = arg0.dataType;
+        this._isArray = arg0.isArray;
+    }
+    else {
+        expression = arg0;
+        this._dataType = arg1;
+        this._isArray = arg2;
+    }
+    const m = expression?.match(TABLE_COLUMN_PATTERN);
+    if (!m)
+        throw new TypeError(`"${expression}" does not match table column format`);
+    this._field = m[2]?.trim();
+    if (m[1]) {
+        const a = m[1].split(/\./g);
+        a.pop();
+        this._table = a.pop()?.trim();
+        this._schema = a.pop()?.trim();
+    }
+    this._alias = this._field !== '*' ? m[3]?.trim() : '';
+};
+Field.prototype = FieldClass.prototype;
+Field.prototype.constructor = Field;

package/sql/elements/group-column.d.ts

@@ -0,0 +1,16 @@
+import { SerializationType } from '../../enums.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { BaseField } from './base-field.js';
+declare class GroupColumnClass extends BaseField {
+    get _type(): SerializationType;
+    _serialize(ctx: SerializeContext): string;
+}
+interface GroupColumnCtor {
+    new (value: string): GroupColumn;
+    (value: string): GroupColumn;
+    prototype: GroupColumn;
+}
+export declare const GroupColumn: GroupColumnCtor;
+export interface GroupColumn extends GroupColumnClass {
+}
+export {};