@sqb/builder 4.26.1 → 5.0.0

package/{sql-objects → sql/elements}/group-column.js

@@ -1,20 +1,7 @@
-import { SerializationType } from '../enums.js';
+import { SerializationType } from '../../enums.js';
 import { BaseField } from './base-field.js';
 const GROUP_COLUMN_PATTERN = /^((?:[a-zA-Z][\w$]*\.){0,2})([\w$]*)$/;
-export class GroupColumn extends BaseField {
-    constructor(value) {
-        super();
-        const m = value.match(GROUP_COLUMN_PATTERN);
-        if (!m)
-            throw new TypeError(`"${value}" does not match group column format`);
-        this._field = m[2];
-        if (m[1]) {
-            const a = m[1].split(/\./g);
-            a.pop();
-            this._table = a.pop();
-            this._schema = a.pop();
-        }
-    }
+class GroupColumnClass extends BaseField {
     get _type() {
         return SerializationType.GROUP_COLUMN;
     }
@@ -30,3 +17,20 @@ export class GroupColumn extends BaseField {
             (o.isReservedWord ? '"' + this._field + '"' : this._field));
     }
 }
+export const GroupColumn = function (value) {
+    if (!(this instanceof GroupColumn))
+        return new GroupColumn(value);
+    BaseField.call(this);
+    const m = value.match(GROUP_COLUMN_PATTERN);
+    if (!m)
+        throw new TypeError(`"${value}" does not match group column format`);
+    this._field = m[2];
+    if (m[1]) {
+        const a = m[1].split(/\./g);
+        a.pop();
+        this._table = a.pop();
+        this._schema = a.pop();
+    }
+};
+GroupColumn.prototype = GroupColumnClass.prototype;
+GroupColumn.prototype.constructor = GroupColumn;

package/sql/elements/index.d.ts

@@ -0,0 +1,26 @@
+export * from './base-field.js';
+export * from './case.js';
+export * from './coalesce.js';
+export * from './count.js';
+export * from './field.js';
+export * from './group-column.js';
+export * from './join.js';
+export * from './join-cross.js';
+export * from './join-full-outer.js';
+export * from './join-inner.js';
+export * from './join-left.js';
+export * from './join-left-outer.js';
+export * from './join-outer.js';
+export * from './join-right.js';
+export * from './join-right-outer.js';
+export * from './lower.js';
+export * from './max.js';
+export * from './min.js';
+export * from './order-column.js';
+export * from './param.js';
+export * from './raw.js';
+export * from './returning-column.js';
+export * from './sequence.js';
+export * from './string-agg.js';
+export * from './table-name.js';
+export * from './upper.js';

package/sql/elements/index.js

@@ -0,0 +1,26 @@
+export * from './base-field.js';
+export * from './case.js';
+export * from './coalesce.js';
+export * from './count.js';
+export * from './field.js';
+export * from './group-column.js';
+export * from './join.js';
+export * from './join-cross.js';
+export * from './join-full-outer.js';
+export * from './join-inner.js';
+export * from './join-left.js';
+export * from './join-left-outer.js';
+export * from './join-outer.js';
+export * from './join-right.js';
+export * from './join-right-outer.js';
+export * from './lower.js';
+export * from './max.js';
+export * from './min.js';
+export * from './order-column.js';
+export * from './param.js';
+export * from './raw.js';
+export * from './returning-column.js';
+export * from './sequence.js';
+export * from './string-agg.js';
+export * from './table-name.js';
+export * from './upper.js';

package/sql/elements/join-cross.d.ts

@@ -0,0 +1,15 @@
+import type { Select } from '../select.js';
+import { Join } from './join.js';
+import type { Raw } from './raw.js';
+import { TableName } from './table-name.js';
+declare class CrossJoinClass extends Join {
+}
+interface CrossJoinCtor {
+    new (table: string | TableName | Select | Raw): CrossJoin;
+    (table: string | TableName | Select | Raw): CrossJoin;
+    prototype: CrossJoin;
+}
+export declare const CrossJoin: CrossJoinCtor;
+export interface CrossJoin extends CrossJoinClass {
+}
+export {};

package/sql/elements/join-cross.js

@@ -0,0 +1,11 @@
+import { JoinType } from '../../enums.js';
+import { Join } from './join.js';
+class CrossJoinClass extends Join {
+}
+export const CrossJoin = function (table) {
+    if (!(this instanceof CrossJoin))
+        return new CrossJoin(table);
+    Join.call(this, JoinType.CROSS, table);
+};
+CrossJoin.prototype = CrossJoinClass.prototype;
+CrossJoin.prototype.constructor = CrossJoin;

package/sql/elements/join-full-outer.d.ts

@@ -0,0 +1,15 @@
+import type { Select } from '../select.js';
+import { Join } from './join.js';
+import type { Raw } from './raw.js';
+import { TableName } from './table-name.js';
+declare class FullOuterJoinClass extends Join {
+}
+interface FullOuterJoinCtor {
+    new (table: string | TableName | Select | Raw): FullOuterJoin;
+    (table: string | TableName | Select | Raw): FullOuterJoin;
+    prototype: FullOuterJoin;
+}
+export declare const FullOuterJoin: FullOuterJoinCtor;
+export interface FullOuterJoin extends FullOuterJoinClass {
+}
+export {};

package/sql/elements/join-full-outer.js

@@ -0,0 +1,11 @@
+import { JoinType } from '../../enums.js';
+import { Join } from './join.js';
+class FullOuterJoinClass extends Join {
+}
+export const FullOuterJoin = function (table) {
+    if (!(this instanceof FullOuterJoin))
+        return new FullOuterJoin(table);
+    Join.call(this, JoinType.FULL_OUTER, table);
+};
+FullOuterJoin.prototype = FullOuterJoinClass.prototype;
+FullOuterJoin.prototype.constructor = FullOuterJoin;

package/sql/elements/join-inner.d.ts

@@ -0,0 +1,15 @@
+import type { Select } from '../select.js';
+import { Join } from './join.js';
+import type { Raw } from './raw.js';
+import { TableName } from './table-name.js';
+declare class InnerJoinClass extends Join {
+}
+interface InnerJoinCtor {
+    new (table: string | TableName | Select | Raw): InnerJoin;
+    (table: string | TableName | Select | Raw): InnerJoin;
+    prototype: InnerJoin;
+}
+export declare const InnerJoin: InnerJoinCtor;
+export interface InnerJoin extends InnerJoinClass {
+}
+export {};

package/sql/elements/join-inner.js

@@ -0,0 +1,11 @@
+import { JoinType } from '../../enums.js';
+import { Join } from './join.js';
+class InnerJoinClass extends Join {
+}
+export const InnerJoin = function (table) {
+    if (!(this instanceof InnerJoin))
+        return new InnerJoin(table);
+    Join.call(this, JoinType.INNER, table);
+};
+InnerJoin.prototype = InnerJoinClass.prototype;
+InnerJoin.prototype.constructor = InnerJoin;

package/sql/elements/join-left-outer.d.ts

@@ -0,0 +1,15 @@
+import type { Select } from '../select.js';
+import { Join } from './join.js';
+import type { Raw } from './raw.js';
+import { TableName } from './table-name.js';
+declare class LeftOuterJoinClass extends Join {
+}
+interface LeftOuterJoinCtor {
+    new (table: string | TableName | Select | Raw): LeftOuterJoin;
+    (table: string | TableName | Select | Raw): LeftOuterJoin;
+    prototype: LeftOuterJoin;
+}
+export declare const LeftOuterJoin: LeftOuterJoinCtor;
+export interface LeftOuterJoin extends LeftOuterJoinClass {
+}
+export {};

package/sql/elements/join-left-outer.js

@@ -0,0 +1,11 @@
+import { JoinType } from '../../enums.js';
+import { Join } from './join.js';
+class LeftOuterJoinClass extends Join {
+}
+export const LeftOuterJoin = function (table) {
+    if (!(this instanceof LeftOuterJoin))
+        return new LeftOuterJoin(table);
+    Join.call(this, JoinType.LEFT_OUTER, table);
+};
+LeftOuterJoin.prototype = LeftOuterJoinClass.prototype;
+LeftOuterJoin.prototype.constructor = LeftOuterJoin;

package/sql/elements/join-left.d.ts

@@ -0,0 +1,15 @@
+import type { Select } from '../select.js';
+import { Join } from './join.js';
+import type { Raw } from './raw.js';
+import { TableName } from './table-name.js';
+declare class LeftJoinClass extends Join {
+}
+interface LeftJoinCtor {
+    new (table: string | TableName | Select | Raw): LeftJoin;
+    (table: string | TableName | Select | Raw): LeftJoin;
+    prototype: LeftJoin;
+}
+export declare const LeftJoin: LeftJoinCtor;
+export interface LeftJoin extends LeftJoinClass {
+}
+export {};

package/sql/elements/join-left.js

@@ -0,0 +1,11 @@
+import { JoinType } from '../../enums.js';
+import { Join } from './join.js';
+class LeftJoinClass extends Join {
+}
+export const LeftJoin = function (table) {
+    if (!(this instanceof LeftJoin))
+        return new LeftJoin(table);
+    Join.call(this, JoinType.LEFT, table);
+};
+LeftJoin.prototype = LeftJoinClass.prototype;
+LeftJoin.prototype.constructor = LeftJoin;

package/sql/elements/join-outer.d.ts

@@ -0,0 +1,15 @@
+import type { Select } from '../select.js';
+import { Join } from './join.js';
+import type { Raw } from './raw.js';
+import { TableName } from './table-name.js';
+declare class OuterJoinClass extends Join {
+}
+interface OuterJoinCtor {
+    new (table: string | TableName | Select | Raw): OuterJoin;
+    (table: string | TableName | Select | Raw): OuterJoin;
+    prototype: OuterJoin;
+}
+export declare const OuterJoin: OuterJoinCtor;
+export interface OuterJoin extends OuterJoinClass {
+}
+export {};

package/sql/elements/join-outer.js

@@ -0,0 +1,11 @@
+import { JoinType } from '../../enums.js';
+import { Join } from './join.js';
+class OuterJoinClass extends Join {
+}
+export const OuterJoin = function (table) {
+    if (!(this instanceof OuterJoin))
+        return new OuterJoin(table);
+    Join.call(this, JoinType.OUTER, table);
+};
+OuterJoin.prototype = OuterJoinClass.prototype;
+OuterJoin.prototype.constructor = OuterJoin;

package/sql/elements/join-right-outer.d.ts

@@ -0,0 +1,15 @@
+import type { Select } from '../select.js';
+import { Join } from './join.js';
+import type { Raw } from './raw.js';
+import { TableName } from './table-name.js';
+declare class RightOuterJoinClass extends Join {
+}
+interface RightOuterJoinCtor {
+    new (table: string | TableName | Select | Raw): RightOuterJoin;
+    (table: string | TableName | Select | Raw): RightOuterJoin;
+    prototype: RightOuterJoin;
+}
+export declare const RightOuterJoin: RightOuterJoinCtor;
+export interface RightOuterJoin extends RightOuterJoinClass {
+}
+export {};

package/sql/elements/join-right-outer.js

@@ -0,0 +1,11 @@
+import { JoinType } from '../../enums.js';
+import { Join } from './join.js';
+class RightOuterJoinClass extends Join {
+}
+export const RightOuterJoin = function (table) {
+    if (!(this instanceof RightOuterJoin))
+        return new RightOuterJoin(table);
+    Join.call(this, JoinType.RIGHT_OUTER, table);
+};
+RightOuterJoin.prototype = RightOuterJoinClass.prototype;
+RightOuterJoin.prototype.constructor = RightOuterJoin;

package/sql/elements/join-right.d.ts

@@ -0,0 +1,15 @@
+import type { Select } from '../select.js';
+import { Join } from './join.js';
+import type { Raw } from './raw.js';
+import { TableName } from './table-name.js';
+declare class RightJoinClass extends Join {
+}
+interface RightJoinCtor {
+    new (table: string | TableName | Select | Raw): RightJoin;
+    (table: string | TableName | Select | Raw): RightJoin;
+    prototype: RightJoin;
+}
+export declare const RightJoin: RightJoinCtor;
+export interface RightJoin extends RightJoinClass {
+}
+export {};

package/sql/elements/join-right.js

@@ -0,0 +1,11 @@
+import { JoinType } from '../../enums.js';
+import { Join } from './join.js';
+class RightJoinClass extends Join {
+}
+export const RightJoin = function (table) {
+    if (!(this instanceof RightJoin))
+        return new RightJoin(table);
+    Join.call(this, JoinType.RIGHT, table);
+};
+RightJoin.prototype = RightJoinClass.prototype;
+RightJoin.prototype.constructor = RightJoin;

package/sql/elements/join.d.ts

@@ -0,0 +1,25 @@
+import { JoinType, SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import type { SerializeContext } from '../../serialize-context.js';
+import type { LogicalOperator } from '../operators/logical-operator.js';
+import type { Select } from '../select.js';
+import type { Raw } from './raw.js';
+import { TableName } from './table-name.js';
+declare class JoinClass extends Serializable {
+    _joinType: JoinType;
+    _table: TableName | Select | Raw;
+    _conditions: LogicalOperator;
+    get _type(): SerializationType;
+    on(...conditions: Serializable[]): this;
+    _serialize(ctx: SerializeContext): string;
+    protected __serializeConditions(ctx: any, join: JoinClass): any;
+}
+interface JoinCtor {
+    new (joinType: JoinType, table: string | TableName | Select | Raw): Join;
+    (joinType: JoinType, table: string | TableName | Select | Raw): Join;
+    prototype: Join;
+}
+export declare const Join: JoinCtor;
+export interface Join extends JoinClass {
+}
+export {};

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

@@ -1,24 +1,12 @@
-import { JoinType, SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { isRawStatement, isSelectQuery, isTableName } from '../typeguards.js';
-import { OpAnd } from './operators/op-and.js';
+import { JoinType, SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { isRaw, isSelect, isTableName } from '../../type-guards.js';
+import { And } from '../operators/and.js';
 import { TableName } from './table-name.js';
-export class JoinStatement extends Serializable {
+class JoinClass extends Serializable {
     _joinType;
     _table;
-    _conditions = new OpAnd();
-    constructor(joinType, table) {
-        super();
-        // noinspection SuspiciousTypeOfGuard
-        if (!(isSelectQuery(table) ||
-            isRawStatement(table) ||
-            isTableName(table) ||
-            typeof table === 'string')) {
-            throw new TypeError('Table name, select query or raw object required for Join');
-        }
-        this._joinType = joinType;
-        this._table = typeof table === 'string' ? new TableName(table) : table;
-    }
+    _conditions = new And();
     get _type() {
         return SerializationType.JOIN;
     }
@@ -61,7 +49,7 @@ export class JoinStatement extends Serializable {
                     break;
             }
             const lf = o.table.length > 40;
-            if (isSelectQuery(this._table)) {
+            if (isSelect(this._table)) {
                 const alias = this._table._alias;
                 if (!alias)
                     throw new Error('Alias required for sub-select in Join');
@@ -88,3 +76,20 @@ export class JoinStatement extends Serializable {
         return '';
     }
 }
+export const Join = function (joinType, table) {
+    if (!(this instanceof Join))
+        return new Join(joinType, table);
+    Serializable.call(this);
+    // noinspection SuspiciousTypeOfGuard
+    if (!(isSelect(table) ||
+        isRaw(table) ||
+        isTableName(table) ||
+        typeof table === 'string')) {
+        throw new TypeError('Table name, select query or raw object required for Join');
+    }
+    this._joinType = joinType;
+    this._table = typeof table === 'string' ? TableName(table) : table;
+    this._conditions = new And();
+};
+Join.prototype = JoinClass.prototype;
+Join.prototype.constructor = Join;

package/sql/elements/lower.d.ts

@@ -0,0 +1,30 @@
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+declare class LowerClass extends Serializable {
+    _expression: 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 LowerCtor {
+    new (expression: any): Lower;
+    (expression: any): Lower;
+    prototype: Lower;
+}
+export declare const Lower: LowerCtor;
+export interface Lower extends LowerClass {
+}
+export {};

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

@@ -1,12 +1,8 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class LowerStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+class LowerClass extends Serializable {
     _expression;
     _alias;
-    constructor(expression) {
-        super();
-        this._expression = expression;
-    }
     get _type() {
         return SerializationType.LOWER_STATEMENT;
     }
@@ -34,3 +30,11 @@ export class LowerStatement extends Serializable {
         return 'lower(' + o + ')' + (this._alias ? ' ' + this._alias : '');
     }
 }
+export const Lower = function (expression) {
+    if (!(this instanceof Lower))
+        return new Lower(expression);
+    Serializable.call(this);
+    this._expression = expression;
+};
+Lower.prototype = LowerClass.prototype;
+Lower.prototype.constructor = Lower;

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

@@ -1,10 +1,9 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { SerializeContext } from '../serialize-context.js';
-export declare class MinStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+declare class MaxClass extends Serializable {
     _expression: any;
     _alias?: string;
-    constructor(expression: any);
     get _type(): SerializationType;
     /**
      * Sets alias to case expression.
@@ -20,3 +19,12 @@ export declare class MinStatement extends Serializable {
     _serialize(ctx: SerializeContext): string;
     protected __defaultSerialize(ctx: SerializeContext, o: any): string;
 }
+interface MaxCtor {
+    new (expression: any): Max;
+    (expression: any): Max;
+    prototype: Max;
+}
+export declare const Max: MaxCtor;
+export interface Max extends MaxClass {
+}
+export {};

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

@@ -1,12 +1,8 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class MaxStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+class MaxClass extends Serializable {
     _expression;
     _alias;
-    constructor(expression) {
-        super();
-        this._expression = expression;
-    }
     get _type() {
         return SerializationType.MAX_STATEMENT;
     }
@@ -34,3 +30,11 @@ export class MaxStatement extends Serializable {
         return 'max(' + o + ')' + (this._alias ? ' ' + this._alias : '');
     }
 }
+export const Max = function (expression) {
+    if (!(this instanceof Max))
+        return new Max(expression);
+    Serializable.call(this);
+    this._expression = expression;
+};
+Max.prototype = MaxClass.prototype;
+Max.prototype.constructor = Max;

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

@@ -1,7 +1,7 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { SerializeContext } from '../serialize-context.js';
-export declare class LowerStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+declare class MinClass extends Serializable {
     _expression: any;
     _alias?: string;
     constructor(expression: any);
@@ -20,3 +20,12 @@ export declare class LowerStatement extends Serializable {
     _serialize(ctx: SerializeContext): string;
     protected __defaultSerialize(ctx: SerializeContext, o: any): string;
 }
+interface MinCtor {
+    new (expression: any): Min;
+    (expression: any): Min;
+    prototype: Min;
+}
+export declare const Min: MinCtor;
+export interface Min extends MinClass {
+}
+export {};

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

@@ -1,6 +1,6 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class MinStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.js';
+class MinClass extends Serializable {
     _expression;
     _alias;
     constructor(expression) {
@@ -34,3 +34,10 @@ export class MinStatement extends Serializable {
         return 'min(' + o + ')' + (this._alias ? ' ' + this._alias : '');
     }
 }
+export const Min = function (expression) {
+    if (!(this instanceof Min))
+        return new Min(expression);
+    this._expression = expression;
+};
+Min.prototype = MinClass.prototype;
+Min.prototype.constructor = Min;

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

@@ -0,0 +1,17 @@
+import { SerializationType } from '../../enums.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { BaseField } from './base-field.js';
+declare class OrderColumnClass extends BaseField {
+    _descending?: boolean;
+    get _type(): SerializationType;
+    _serialize(ctx: SerializeContext): string;
+}
+interface OrderColumnCtor {
+    new (value: string): OrderColumn;
+    (value: string): OrderColumn;
+    prototype: OrderColumn;
+}
+export declare const OrderColumn: OrderColumnCtor;
+export interface OrderColumn extends OrderColumnClass {
+}
+export {};

package/sql/elements/order-column.js

@@ -0,0 +1,43 @@
+import { SerializationType } from '../../enums.js';
+import { Serializable } from '../../serializable.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;
+class OrderColumnClass extends BaseField {
+    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, () => (o.schema ? o.schema + '.' : '') +
+            (o.table ? o.table + '.' : '') +
+            (o.isReservedWord ? '"' + o.field + '"' : o.field) +
+            (o.descending ? ' desc' : ''));
+    }
+}
+export const OrderColumn = function (value) {
+    if (!(this instanceof OrderColumn))
+        return new OrderColumn(value);
+    Serializable.call(this);
+    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())));
+};
+OrderColumn.prototype = OrderColumnClass.prototype;
+OrderColumn.prototype.constructor = OrderColumn;