@sqb/builder 4.26.1 → 5.0.0

package/sql-objects/operators/op-not.js

@@ -1,17 +0,0 @@
-import { OperatorType, SerializationType } from '../../enums.js';
-import { Operator } from '../operator.js';
-export class OpNot extends Operator {
-    _operatorType = OperatorType.not;
-    _expression;
-    constructor(expression) {
-        super();
-        this._expression = expression;
-    }
-    get _type() {
-        return SerializationType.NEGATIVE_EXPRESSION;
-    }
-    _serialize(ctx) {
-        const expression = ctx.anyToSQL(this._expression);
-        return ctx.serialize(this._type, expression, () => expression ? 'not ' + expression : '');
-    }
-}

package/sql-objects/operators/op-or.d.ts

@@ -1,5 +0,0 @@
-import { OperatorType } from '../../enums.js';
-import { LogicalOperator } from './logical-operator.js';
-export declare class OpOr extends LogicalOperator {
-    _operatorType: OperatorType;
-}

package/sql-objects/operators/op-or.js

@@ -1,5 +0,0 @@
-import { OperatorType } from '../../enums.js';
-import { LogicalOperator } from './logical-operator.js';
-export class OpOr extends LogicalOperator {
-    _operatorType = OperatorType.or;
-}

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

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

package/sql-objects/order-column.js

@@ -1,39 +0,0 @@
-import { SerializationType } from '../enums.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;
-export class OrderColumn extends BaseField {
-    _descending;
-    constructor(value) {
-        super();
-        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())));
-    }
-    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' : ''));
-    }
-}

package/sql-objects/param-expression.d.ts

@@ -1,23 +0,0 @@
-import { DataType, SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { SerializeContext } from '../serialize-context.js';
-export declare class ParamExpression extends Serializable {
-    _name: string;
-    _dataType?: DataType;
-    _isArray?: boolean;
-    constructor(arg: string | {
-        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;
-}

package/sql-objects/raw-statement.d.ts

@@ -1,9 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { SerializeContext } from '../serialize-context.js';
-export declare class RawStatement extends Serializable {
-    _text: string;
-    constructor(str: string);
-    get _type(): SerializationType;
-    _serialize(ctx: SerializeContext): string;
-}

package/sql-objects/raw-statement.js

@@ -1,15 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class RawStatement extends Serializable {
-    _text;
-    constructor(str) {
-        super();
-        this._text = str;
-    }
-    get _type() {
-        return SerializationType.RAW;
-    }
-    _serialize(ctx) {
-        return ctx.serialize(this._type, this._text, () => this._text);
-    }
-}

package/sql-objects/returning-column.d.ts

@@ -1,9 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { SerializeContext } from '../serialize-context.js';
-import { BaseField } from './base-field.js';
-export declare class ReturningColumn extends BaseField {
-    _alias: string;
-    constructor(field: string);
-    get _type(): SerializationType;
-    _serialize(ctx: SerializeContext): string;
-}

package/sql-objects/returning-column.js

@@ -1,27 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { BaseField } from './base-field.js';
-const RETURNING_COLUMN_PATTERN = /^([a-zA-Z_]\w*) *(?:as)? *(\w+)?$/;
-export class ReturningColumn extends BaseField {
-    _alias;
-    constructor(field) {
-        super();
-        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];
-    }
-    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) : ''));
-    }
-}

package/sql-objects/sequence-getter-statement.d.ts

@@ -1,24 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { SerializeContext } from '../serialize-context.js';
-export declare class SequenceGetterStatement extends Serializable {
-    _expression: string;
-    _next: boolean;
-    _alias?: string;
-    constructor(expression: string, next?: boolean);
-    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;
-}

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

@@ -1,22 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { SerializeContext } from '../serialize-context.js';
-export interface OptimizerHintArgs {
-    hint: string;
-    dialect?: string[];
-}
-export interface TableNameArgs {
-    schema?: string;
-    table: string;
-    alias?: string;
-    optimizerHint?: string | string[] | OptimizerHintArgs | OptimizerHintArgs[];
-}
-export declare class TableName extends Serializable {
-    schema?: string;
-    table?: string;
-    alias?: string;
-    optimizerHint?: OptimizerHintArgs[];
-    constructor(tableName: string | TableNameArgs);
-    get _type(): SerializationType;
-    _serialize(ctx: SerializeContext): string;
-}

package/sql-objects/table-name.js

@@ -1,55 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class TableName extends Serializable {
-    schema;
-    table;
-    alias;
-    optimizerHint;
-    constructor(tableName) {
-        super();
-        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),
-                    });
-                }
-            }
-        }
-    }
-    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 : ''));
-    }
-}

package/sql-objects/upper-statement.d.ts

@@ -1,22 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { SerializeContext } from '../serialize-context.js';
-export declare class UpperStatement extends Serializable {
-    _expression: any;
-    _alias?: string;
-    constructor(expression: any);
-    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;
-}

package/sqlobject.initializers.d.ts

@@ -1,61 +0,0 @@
-import { DataType } from './enums.js';
-import { DeleteQuery } from './query/delete-query.js';
-import { InsertQuery } from './query/insert-query.js';
-import { Query } from './query/query.js';
-import { SelectQuery } from './query/select-query.js';
-import { UnionQuery } from './query/union-query.js';
-import { UpdateQuery } from './query/update-query.js';
-import { Serializable } from './serializable.js';
-import { CaseStatement } from './sql-objects/case-statement.js';
-import { CoalesceStatement } from './sql-objects/coalesce-statement.js';
-import { CountStatement } from './sql-objects/count-statement.js';
-import { FieldExpression } from './sql-objects/field-expression.js';
-import { JoinStatement } from './sql-objects/join-statement.js';
-import { LowerStatement } from './sql-objects/lower-statement.js';
-import { MaxStatement } from './sql-objects/max-statement.js';
-import { MinStatement } from './sql-objects/min-statement.js';
-import { ParamExpression } from './sql-objects/param-expression.js';
-import { RawStatement } from './sql-objects/raw-statement.js';
-import { SequenceGetterStatement } from './sql-objects/sequence-getter-statement.js';
-import { StringAGGStatement } from './sql-objects/string-agg-statement.js';
-import { TableName as TableNameClass, TableNameArgs } from './sql-objects/table-name.js';
-import { UpperStatement } from './sql-objects/upper-statement.js';
-export declare function Raw(text: string): RawStatement;
-export declare function Select(...column: (string | string[] | Serializable)[]): SelectQuery;
-export declare function Insert(tableName: string | RawStatement, input: any): InsertQuery;
-export declare function Update(tableName: string | TableNameClass | RawStatement, input: any): UpdateQuery;
-export declare function Delete(tableName: string | TableNameClass | RawStatement): DeleteQuery;
-export declare function Union(...queries: Query[]): UnionQuery;
-export declare function UnionAll(...queries: Query[]): UnionQuery;
-export declare function TableName(tableName: string | TableNameArgs): TableNameClass;
-export declare function Join(table: string | SelectQuery | RawStatement): JoinStatement;
-export declare function InnerJoin(table: string | SelectQuery | RawStatement): JoinStatement;
-export declare function LeftJoin(table: string | SelectQuery | RawStatement): JoinStatement;
-export declare function LeftOuterJoin(table: string | SelectQuery | RawStatement): JoinStatement;
-export declare function RightJoin(table: string | SelectQuery | RawStatement): JoinStatement;
-export declare function RightOuterJoin(table: string | SelectQuery | RawStatement): JoinStatement;
-export declare function OuterJoin(table: string | SelectQuery | RawStatement): JoinStatement;
-export declare function FullOuterJoin(table: string | SelectQuery | RawStatement): JoinStatement;
-export declare function CrossJoin(table: string | SelectQuery | RawStatement): JoinStatement;
-export declare function Case(): CaseStatement;
-export declare function Coalesce(...expressions: any[]): CoalesceStatement;
-export declare function Lower(expression: any): LowerStatement;
-export declare function Upper(expression: any): UpperStatement;
-export declare function Min(expression: any): MinStatement;
-export declare function Max(expression: any): MaxStatement;
-export declare function StringAGG(field: any): StringAGGStatement;
-export declare function Count(): CountStatement;
-export declare function SequenceNext(expression: string): SequenceGetterStatement;
-export declare function SequenceCurr(expression: string): SequenceGetterStatement;
-export declare function Param(name: string, dataType?: DataType, isArray?: boolean): ParamExpression;
-export declare function Param(args: {
-    name: string;
-    dataType?: DataType;
-    isArray?: boolean;
-}): ParamExpression;
-export declare function Field(name: string, dataType?: DataType, isArray?: boolean): FieldExpression;
-export declare function Field(args: {
-    name: string;
-    dataType?: DataType;
-    isArray?: boolean;
-}): FieldExpression;

package/sqlobject.initializers.js

@@ -1,115 +0,0 @@
-import { JoinType } from './enums.js';
-import { DeleteQuery } from './query/delete-query.js';
-import { InsertQuery } from './query/insert-query.js';
-import { SelectQuery } from './query/select-query.js';
-import { UnionQuery } from './query/union-query.js';
-import { UpdateQuery } from './query/update-query.js';
-import { CaseStatement } from './sql-objects/case-statement.js';
-import { CoalesceStatement } from './sql-objects/coalesce-statement.js';
-import { CountStatement } from './sql-objects/count-statement.js';
-import { FieldExpression } from './sql-objects/field-expression.js';
-import { JoinStatement } from './sql-objects/join-statement.js';
-import { LowerStatement } from './sql-objects/lower-statement.js';
-import { MaxStatement } from './sql-objects/max-statement.js';
-import { MinStatement } from './sql-objects/min-statement.js';
-import { ParamExpression } from './sql-objects/param-expression.js';
-import { RawStatement } from './sql-objects/raw-statement.js';
-import { SequenceGetterStatement } from './sql-objects/sequence-getter-statement.js';
-import { StringAGGStatement } from './sql-objects/string-agg-statement.js';
-import { TableName as TableNameClass, } from './sql-objects/table-name.js';
-import { UpperStatement } from './sql-objects/upper-statement.js';
-export function Raw(text) {
-    return new RawStatement(text);
-}
-export function Select(...column) {
-    return new SelectQuery(...column);
-}
-export function Insert(tableName, input) {
-    return new InsertQuery(tableName, input);
-}
-export function Update(tableName, input) {
-    return new UpdateQuery(tableName, input);
-}
-export function Delete(tableName) {
-    return new DeleteQuery(tableName);
-}
-export function Union(...queries) {
-    return new UnionQuery(queries);
-}
-export function UnionAll(...queries) {
-    return new UnionQuery(queries, 'all');
-}
-export function TableName(tableName) {
-    return new TableNameClass(tableName);
-}
-export function Join(table) {
-    return new JoinStatement(JoinType.INNER, table);
-}
-export function InnerJoin(table) {
-    return new JoinStatement(JoinType.INNER, table);
-}
-export function LeftJoin(table) {
-    return new JoinStatement(JoinType.LEFT, table);
-}
-export function LeftOuterJoin(table) {
-    return new JoinStatement(JoinType.LEFT_OUTER, table);
-}
-export function RightJoin(table) {
-    return new JoinStatement(JoinType.RIGHT, table);
-}
-export function RightOuterJoin(table) {
-    return new JoinStatement(JoinType.RIGHT_OUTER, table);
-}
-export function OuterJoin(table) {
-    return new JoinStatement(JoinType.OUTER, table);
-}
-export function FullOuterJoin(table) {
-    return new JoinStatement(JoinType.FULL_OUTER, table);
-}
-export function CrossJoin(table) {
-    return new JoinStatement(JoinType.CROSS, table);
-}
-export function Case() {
-    return new CaseStatement();
-}
-export function Coalesce(...expressions) {
-    return new CoalesceStatement(...expressions);
-}
-export function Lower(expression) {
-    return new LowerStatement(expression);
-}
-export function Upper(expression) {
-    return new UpperStatement(expression);
-}
-export function Min(expression) {
-    return new MinStatement(expression);
-}
-export function Max(expression) {
-    return new MaxStatement(expression);
-}
-export function StringAGG(field) {
-    return new StringAGGStatement(field);
-}
-export function Count() {
-    return new CountStatement();
-}
-export function SequenceNext(expression) {
-    return new SequenceGetterStatement(expression, true);
-}
-export function SequenceCurr(expression) {
-    return new SequenceGetterStatement(expression, false);
-}
-export function Param(arg0, arg1, arg2) {
-    if (typeof arg0 === 'object')
-        return new ParamExpression(arg0);
-    return new ParamExpression({
-        name: arg0,
-        dataType: arg1,
-        isArray: arg2,
-    });
-}
-export function Field(arg0, arg1, arg2) {
-    if (typeof arg0 === 'object')
-        return new FieldExpression(arg0);
-    return new FieldExpression(arg0, arg1, arg2);
-}

package/typeguards.d.ts

@@ -1,37 +0,0 @@
-import type { DeleteQuery } from './query/delete-query.js';
-import type { InsertQuery } from './query/insert-query.js';
-import type { Query } from './query/query.js';
-import type { SelectQuery } from './query/select-query.js';
-import type { UpdateQuery } from './query/update-query.js';
-import type { Serializable } from './serializable.js';
-import type { CaseStatement } from './sql-objects/case-statement.js';
-import type { CountStatement } from './sql-objects/count-statement.js';
-import type { FieldExpression } from './sql-objects/field-expression.js';
-import type { GroupColumn } from './sql-objects/group-column.js';
-import type { JoinStatement } from './sql-objects/join-statement.js';
-import type { CompOperator } from './sql-objects/operators/comp-operator.js';
-import type { LogicalOperator } from './sql-objects/operators/logical-operator.js';
-import type { OrderColumn } from './sql-objects/order-column.js';
-import type { ParamExpression } from './sql-objects/param-expression.js';
-import type { RawStatement } from './sql-objects/raw-statement.js';
-import type { ReturningColumn } from './sql-objects/returning-column.js';
-import type { TableName } from './sql-objects/table-name.js';
-export declare function isSerializable(value: any): value is Serializable;
-export declare function isQuery(value: any): value is Query;
-export declare function isRawStatement(value: any): value is RawStatement;
-export declare function isSelectQuery(value: any): value is SelectQuery;
-export declare function isInsertQuery(value: any): value is InsertQuery;
-export declare function isIUpdateQuery(value: any): value is UpdateQuery;
-export declare function isDeleteQuery(value: any): value is DeleteQuery;
-export declare function isJoinStatement(value: any): value is JoinStatement;
-export declare function isCaseStatement(value: any): value is CaseStatement;
-export declare function isCountStatement(value: any): value is CountStatement;
-export declare function isParamExpression(value: any): value is ParamExpression;
-export declare function isLogicalOperator(value: any): value is LogicalOperator;
-export declare function isCompOperator(value: any): value is CompOperator;
-export declare function isNotOperator(value: any): value is CompOperator;
-export declare function isSelectColumn(value: any): value is FieldExpression;
-export declare function isOrderColumn(value: any): value is OrderColumn;
-export declare function isGroupColumn(value: any): value is GroupColumn;
-export declare function isReturningColumn(value: any): value is ReturningColumn;
-export declare function isTableName(value: any): value is TableName;