@sqb/builder 4.26.1 → 5.0.1

package/sql/elements/param.d.ts

@@ -0,0 +1,36 @@
+import { DataType, SerializationType } from '../../enums.js';
+import { SqlElement } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+declare class ParamClass extends SqlElement {
+    _name: string;
+    _dataType?: DataType;
+    _isArray?: boolean;
+    get _type(): SerializationType;
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: {
+        name: string;
+        dataType?: DataType;
+        isArray?: boolean;
+    }): string;
+}
+interface ParamCtor {
+    new (arg: string | Param.Args): Param;
+    new (name: string, dataType?: DataType, isArray?: boolean): Param;
+    (arg: string | Param.Args): Param;
+    (name: string, dataType?: DataType, isArray?: boolean): Param;
+    prototype: Param;
+}
+export declare const Param: ParamCtor;
+export interface Param extends ParamClass {
+}
+export declare namespace Param {
+    interface Args {
+        name: string;
+        dataType?: DataType;
+        isArray?: boolean;
+    }
+}
+export {};

package/{sql-objects/param-expression.js → sql/elements/param.js}

@@ -1,19 +1,9 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class ParamExpression extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { SqlElement } from '../../serializable.js';
+class ParamClass extends SqlElement {
     _name;
     _dataType;
     _isArray;
-    constructor(arg) {
-        super();
-        if (typeof arg === 'object') {
-            this._name = arg.name;
-            this._dataType = arg.dataType;
-            this._isArray = arg.isArray;
-        }
-        else
-            this._name = arg;
-    }
     get _type() {
         return SerializationType.EXTERNAL_PARAMETER;
     }
@@ -50,3 +40,26 @@ export class ParamExpression extends Serializable {
         return ':' + o.name;
     }
 }
+export const Param = function (...varArgs) {
+    let args;
+    if (varArgs.length === 1 && typeof varArgs[0] === 'object') {
+        args = varArgs[0];
+    }
+    else {
+        args = {
+            name: varArgs[0],
+        };
+        if (varArgs.length > 1)
+            args.dataType = varArgs[1];
+        if (varArgs.length > 2)
+            args.isArray = varArgs[2];
+    }
+    if (!(this instanceof Param))
+        return new Param(args);
+    SqlElement.call(this);
+    this._name = args.name;
+    this._dataType = args.dataType;
+    this._isArray = args.isArray;
+};
+Param.prototype = ParamClass.prototype;
+Param.prototype.constructor = Param;

package/sql/elements/raw.d.ts

@@ -0,0 +1,17 @@
+import { SerializationType } from '../../enums.js';
+import { SqlElement } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+declare class RawClass extends SqlElement {
+    _text: string;
+    get _type(): SerializationType;
+    _serialize(ctx: SerializeContext): string;
+}
+interface RawCtor {
+    new (str: string): Raw;
+    (str: string): Raw;
+    prototype: Raw;
+}
+export declare const Raw: RawCtor;
+export interface Raw extends RawClass {
+}
+export {};

package/sql/elements/raw.js

@@ -0,0 +1,19 @@
+import { SerializationType } from '../../enums.js';
+import { SqlElement } from '../../serializable.js';
+class RawClass extends SqlElement {
+    _text;
+    get _type() {
+        return SerializationType.RAW;
+    }
+    _serialize(ctx) {
+        return ctx.serialize(this._type, this._text, () => this._text);
+    }
+}
+export const Raw = function (str) {
+    if (!(this instanceof Raw))
+        return new Raw(str);
+    SqlElement.call(this);
+    this._text = str;
+};
+Raw.prototype = RawClass.prototype;
+Raw.prototype.constructor = Raw;

package/sql/elements/returning-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 ReturningColumnClass extends BaseField {
+    _alias: string;
+    get _type(): SerializationType;
+    _serialize(ctx: SerializeContext): string;
+}
+interface ReturningColumnCtor {
+    new (field: string): ReturningColumn;
+    (field: string): ReturningColumn;
+    prototype: ReturningColumn;
+}
+export declare const ReturningColumn: ReturningColumnCtor;
+export interface ReturningColumn extends ReturningColumnClass {
+}
+export {};

package/sql/elements/returning-column.js

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

package/sql/elements/sequence.d.ts

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

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

@@ -1,14 +1,9 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class SequenceGetterStatement extends Serializable {
+import { SerializationType } from '../../enums.js';
+import { SqlElement } from '../../serializable.js';
+class SequenceClass extends SqlElement {
     _expression;
     _next;
     _alias;
-    constructor(expression, next) {
-        super();
-        this._expression = expression;
-        this._next = !!next;
-    }
     get _type() {
         return SerializationType.SEQUENCE_GETTER_STATEMENT;
     }
@@ -48,3 +43,12 @@ export class SequenceGetterStatement extends Serializable {
             (o.alias ? ' ' + o.alias : ''));
     }
 }
+export const Sequence = function (expression, next) {
+    if (!(this instanceof Sequence))
+        return new Sequence(expression, next);
+    SqlElement.call(this);
+    this._expression = expression;
+    this._next = !!next;
+};
+Sequence.prototype = SequenceClass.prototype;
+Sequence.prototype.constructor = Sequence;

package/sql/elements/string-agg.d.ts

@@ -0,0 +1,39 @@
+import { SerializationType } from '../../enums.js';
+import { SqlElement } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { OrderColumn } from './order-column.js';
+declare class StringAggClass extends SqlElement {
+    _field: SqlElement;
+    _delimiter: string;
+    _orderBy?: (OrderColumn | SqlElement)[];
+    _alias?: string;
+    get _type(): SerializationType;
+    delimiter(value: string): this;
+    /**
+     * Defines "order by" part of StringAGG.
+     */
+    orderBy(...field: (string | SqlElement)[]): this;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __serializeOrderColumns(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}
+interface StringAggCtor {
+    new (field: string | SqlElement, delimiter?: string): StringAgg;
+    (field: string | SqlElement, delimiter?: string): StringAgg;
+    prototype: StringAgg;
+}
+export declare const StringAgg: StringAggCtor;
+export interface StringAgg extends StringAggClass {
+}
+export {};

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

@@ -1,19 +1,13 @@
-import { SerializationType } from '../enums.js';
-import { printArray } from '../helpers.js';
-import { Serializable } from '../serializable.js';
-import { FieldExpression } from './field-expression.js';
+import { SerializationType } from '../../enums.js';
+import { printArray } from '../../helpers.js';
+import { SqlElement } from '../../serializable.js';
+import { Field } from './field.js';
 import { OrderColumn } from './order-column.js';
-export class StringAGGStatement extends Serializable {
+class StringAggClass extends SqlElement {
     _field;
     _delimiter;
     _orderBy;
     _alias;
-    constructor(field, delimiter) {
-        super();
-        this._field =
-            typeof field === 'string' ? new FieldExpression(field) : field;
-        this._delimiter = delimiter || ',';
-    }
     get _type() {
         return SerializationType.STRINGAGG_STATEMENT;
     }
@@ -29,7 +23,7 @@ export class StringAGGStatement extends Serializable {
         for (const arg of field) {
             if (!arg)
                 continue;
-            this._orderBy.push(typeof arg === 'string' ? new OrderColumn(arg) : arg);
+            this._orderBy.push(typeof arg === 'string' ? OrderColumn(arg) : arg);
         }
         return this;
     }
@@ -82,3 +76,12 @@ export class StringAGGStatement extends Serializable {
             (o.alias ? ' ' + o.alias : ''));
     }
 }
+export const StringAgg = function (field, delimiter) {
+    if (!(this instanceof StringAgg))
+        return new StringAgg(field, delimiter);
+    SqlElement.call(this);
+    this._field = typeof field === 'string' ? new Field(field) : field;
+    this._delimiter = delimiter || ',';
+};
+StringAgg.prototype = StringAggClass.prototype;
+StringAgg.prototype.constructor = StringAgg;

package/sql/elements/table-name.d.ts

@@ -0,0 +1,32 @@
+import { SerializationType } from '../../enums.js';
+import { SqlElement } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+declare class TableNameClass extends SqlElement {
+    schema?: string;
+    table?: string;
+    alias?: string;
+    optimizerHint?: TableName.OptimizerHint[];
+    get _type(): SerializationType;
+    _serialize(ctx: SerializeContext): string;
+}
+interface TableNameCtor {
+    new (tableName: string | TableName.Args): TableName;
+    (tableName: string | TableName.Args): TableName;
+    prototype: TableName;
+}
+export declare const TableName: TableNameCtor;
+export interface TableName extends TableNameClass {
+}
+export declare namespace TableName {
+    interface OptimizerHint {
+        hint: string;
+        dialect?: string[];
+    }
+    interface Args {
+        schema?: string;
+        table: string;
+        alias?: string;
+        optimizerHint?: string | string[] | OptimizerHint | OptimizerHint[];
+    }
+}
+export {};

package/sql/elements/table-name.js

@@ -0,0 +1,59 @@
+import { SerializationType } from '../../enums.js';
+import { SqlElement } from '../../serializable.js';
+class TableNameClass extends SqlElement {
+    schema;
+    table;
+    alias;
+    optimizerHint;
+    get _type() {
+        return SerializationType.TABLE_NAME;
+    }
+    _serialize(ctx) {
+        return ctx.serialize(this._type, {
+            schema: this.schema,
+            table: this.table,
+            alias: this.alias,
+            optimizerHint: this.optimizerHint,
+        }, () => (this.schema ? this.schema + '.' : '') +
+            this.table +
+            (this.alias ? ' ' + this.alias : ''));
+    }
+}
+export const TableName = function (tableName) {
+    if (!(this instanceof TableName))
+        return new TableName(tableName);
+    SqlElement.call(this);
+    if (typeof tableName === 'string') {
+        const m = tableName.match(/^(?:([a-zA-Z][\w$]*)\.)? *([a-zA-Z][\w$]*) *(?:as)? *(\w+)?$/);
+        if (!m)
+            throw new TypeError(`(${tableName}) does not match table name format`);
+        if (m[1])
+            this.schema = m[1];
+        if (m[2])
+            this.table = m[2];
+        if (m[3])
+            this.alias = m[3];
+    }
+    else {
+        this.schema = tableName.schema;
+        this.table = tableName.table;
+        this.alias = tableName.alias;
+        if (tableName.optimizerHint) {
+            const arg0 = tableName.optimizerHint;
+            this.optimizerHint = [];
+            if (typeof arg0 === 'object' && !Array.isArray(arg0)) {
+                this.optimizerHint.push({
+                    hint: String(arg0.hint),
+                    dialect: Array.isArray(arg0.dialect) ? arg0.dialect : undefined,
+                });
+            }
+            else {
+                this.optimizerHint.push({
+                    hint: String(arg0),
+                });
+            }
+        }
+    }
+};
+TableName.prototype = TableNameClass.prototype;
+TableName.prototype.constructor = TableName;

package/sql/elements/upper.d.ts

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

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

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

package/sql/index.d.ts

@@ -0,0 +1,9 @@
+export * from './delete.js';
+export * from './elements/index.js';
+export * from './insert.js';
+export * from './operators/index.js';
+export * from './query.js';
+export * from './returning-query.js';
+export * from './select.js';
+export * from './union.js';
+export * from './update.js';

package/sql/index.js

@@ -0,0 +1,9 @@
+export * from './delete.js';
+export * from './elements/index.js';
+export * from './insert.js';
+export * from './operators/index.js';
+export * from './query.js';
+export * from './returning-query.js';
+export * from './select.js';
+export * from './union.js';
+export * from './update.js';

package/sql/insert.d.ts

@@ -0,0 +1,37 @@
+import { SerializationType } from '../enums.js';
+import { SerializeContext } from '../serialize-context.js';
+import { Raw } from './elements/raw.js';
+import { TableName } from './elements/table-name.js';
+import { ReturningQuery } from './returning-query.js';
+import { Select } from './select.js';
+declare class InsertClass extends ReturningQuery {
+    _table: TableName | Raw;
+    _input: any;
+    get _type(): SerializationType;
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeColumns(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeValues(ctx: SerializeContext): string;
+}
+interface InsertCtor {
+    new (tableName: string | Raw, input: Record<string, any> | Select | Raw): Insert;
+    (tableName: string | Raw, input: Record<string, any> | Select | Raw): Insert;
+    prototype: Insert;
+}
+export declare const Insert: InsertCtor;
+export interface Insert extends InsertClass {
+}
+/**
+ * Type guard for Insert
+ * @param value
+ */
+export declare function isInsertQuery(value: any): value is Insert;
+export {};

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

@@ -1,25 +1,13 @@
 import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
-import { TableName } from '../sql-objects/table-name.js';
-import { isRawStatement, isSelectQuery, isSerializable, } from '../typeguards.js';
+import { SqlElement } from '../serializable.js';
+import { isRaw, isSelect, isSerializable } from '../type-guards.js';
+import { TableName } from './elements/table-name.js';
+import { Query } from './query.js';
 import { ReturningQuery } from './returning-query.js';
-export class InsertQuery extends ReturningQuery {
+class InsertClass extends ReturningQuery {
     _table;
     _input;
-    constructor(tableName, input) {
-        super();
-        if (!tableName ||
-            !(typeof tableName === 'string' || isRawStatement(tableName))) {
-            throw new TypeError('String or Raw instance required as first argument (tableName) for InsertQuery');
-        }
-        if (!input ||
-            !((typeof input === 'object' && !Array.isArray(input)) || input.isSelect)) {
-            throw new TypeError('Object or SelectQuery instance required as second argument (input) for InsertQuery');
-        }
-        this._table =
-            typeof tableName === 'string' ? new TableName(tableName) : tableName;
-        this._input = input;
-    }
     get _type() {
         return SerializationType.INSERT_QUERY;
     }
@@ -49,7 +37,7 @@ export class InsertQuery extends ReturningQuery {
      */
     __serializeColumns(ctx) {
         let arr;
-        if (isSelectQuery(this._input)) {
+        if (isSelect(this._input)) {
             arr = [];
             const cols = this._input._columns;
             if (cols) {
@@ -80,3 +68,30 @@ export class InsertQuery extends ReturningQuery {
         return ctx.serialize(SerializationType.INSERT_QUERY_VALUES, arr, () => printArray(arr));
     }
 }
+export const Insert = function (tableName, input) {
+    if (!(this instanceof Insert))
+        return new Insert(tableName, input);
+    Query.call(this);
+    if (!tableName || !(typeof tableName === 'string' || isRaw(tableName))) {
+        throw new TypeError('String or Raw instance required as first argument (tableName) for Insert');
+    }
+    if (!input ||
+        !((typeof input === 'object' && !Array.isArray(input)) ||
+            (input instanceof SqlElement &&
+                (input._type === SerializationType.SELECT_QUERY ||
+                    input._type === SerializationType.RAW)))) {
+        throw new TypeError('Object or Select instance required as second argument (input) for Insert');
+    }
+    this._table =
+        typeof tableName === 'string' ? TableName(tableName) : tableName;
+    this._input = input;
+};
+Insert.prototype = InsertClass.prototype;
+Insert.prototype.constructor = Insert;
+/**
+ * Type guard for Insert
+ * @param value
+ */
+export function isInsertQuery(value) {
+    return (isSerializable(value) && value._type === SerializationType.INSERT_QUERY);
+}

package/sql/operators/and.d.ts

@@ -0,0 +1,14 @@
+import { OperatorType } from '../../enums.js';
+import { LogicalOperator } from './logical-operator.js';
+declare class AndClass extends LogicalOperator {
+    _operatorType: OperatorType;
+}
+interface AndCtor {
+    new (...items: any[]): And;
+    (...items: any[]): And;
+    prototype: And;
+}
+export declare const And: AndCtor;
+export interface And extends AndClass {
+}
+export {};

package/sql/operators/and.js

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

package/sql/operators/between.d.ts

@@ -0,0 +1,18 @@
+import type { SqlElement } from '../../serializable.js';
+import { SerializeContext } from '../../serialize-context.js';
+import { CompOperator } from './comp-operator.js';
+declare class BetweenClass extends CompOperator {
+    _serialize(ctx: SerializeContext): string;
+    __defaultSerialize(ctx: SerializeContext, o: any): string;
+}
+interface BetweenCtor {
+    new (left: string | SqlElement, right: any[] | SqlElement): Between;
+    new (left: string | SqlElement, right1: any, right2: any): Between;
+    (left: string | SqlElement, right: any[] | SqlElement): Between;
+    (left: string | SqlElement, right1: any, right2: any): Between;
+    prototype: Between;
+}
+export declare const Between: BetweenCtor;
+export interface Between extends BetweenClass {
+}
+export {};