@sqb/builder 4.0.9 → 4.0.10

package/dist/op.initializers.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotExists = exports.Exists = exports.IsNot = exports.Is = exports.Nilike = exports.NotILike = exports.Ilike = exports.NLike = exports.NotLike = exports.Like = exports.Nin = exports.NotIn = exports.In = exports.NotBetween = exports.Between = exports.LowerAndEqualTo = exports.Lte = exports.LowerThan = exports.Lt = exports.GreaterAnEqualTo = exports.Gte = exports.GreaterThan = exports.Gt = exports.NotEqual = exports.Ne = exports.Equal = exports.Eq = exports.Or = exports.And = exports.op = void 0;
+const OpAnd_1 = require("./sql-objects/operators/OpAnd");
+const OpOr_1 = require("./sql-objects/operators/OpOr");
+const OpEq_1 = require("./sql-objects/operators/OpEq");
+const OpGt_1 = require("./sql-objects/operators/OpGt");
+const OpGte_1 = require("./sql-objects/operators/OpGte");
+const OpLt_1 = require("./sql-objects/operators/OpLt");
+const OpLte_1 = require("./sql-objects/operators/OpLte");
+const OpBetween_1 = require("./sql-objects/operators/OpBetween");
+const OpIn_1 = require("./sql-objects/operators/OpIn");
+const OpIs_1 = require("./sql-objects/operators/OpIs");
+const OpIsNot_1 = require("./sql-objects/operators/OpIsNot");
+const OpLike_1 = require("./sql-objects/operators/OpLike");
+const OpILike_1 = require("./sql-objects/operators/OpILike");
+const OpNe_1 = require("./sql-objects/operators/OpNe");
+const OpNotBetween_1 = require("./sql-objects/operators/OpNotBetween");
+const OpNotIn_1 = require("./sql-objects/operators/OpNotIn");
+const OpNotLike_1 = require("./sql-objects/operators/OpNotLike");
+const OpNotILike_1 = require("./sql-objects/operators/OpNotILike");
+const OpExists_1 = require("./sql-objects/operators/OpExists");
+const OpNotExists_1 = require("./sql-objects/operators/OpNotExists");
+// Avoids circular reference
+const LogicalOperator_1 = require("./sql-objects/operators/LogicalOperator");
+function And(...args) {
+    return new OpAnd_1.OpAnd(...args);
+}
+exports.And = And;
+function Or(...args) {
+    return new OpOr_1.OpOr(...args);
+}
+exports.Or = Or;
+function Eq(expression, value) {
+    return new OpEq_1.OpEq(expression, value);
+}
+exports.Eq = Eq;
+exports.Equal = Eq;
+function Ne(expression, value) {
+    return new OpNe_1.OpNe(expression, value);
+}
+exports.Ne = Ne;
+exports.NotEqual = Ne;
+function Gt(expression, value) {
+    return new OpGt_1.OpGt(expression, value);
+}
+exports.Gt = Gt;
+exports.GreaterThan = Gt;
+function Gte(expression, value) {
+    return new OpGte_1.OpGte(expression, value);
+}
+exports.Gte = Gte;
+exports.GreaterAnEqualTo = Gte;
+function Lt(expression, value) {
+    return new OpLt_1.OpLt(expression, value);
+}
+exports.Lt = Lt;
+exports.LowerThan = Lt;
+function Lte(expression, value) {
+    return new OpLte_1.OpLte(expression, value);
+}
+exports.Lte = Lte;
+exports.LowerAndEqualTo = Lte;
+function Between(expression, value1, value2) {
+    const values = Array.isArray(value1) ? value1 : [value1, value2];
+    return new OpBetween_1.OpBetween(expression, values);
+}
+exports.Between = Between;
+function NotBetween(expression, value1, value2) {
+    const values = Array.isArray(value1) ? value1 : [value1, value2];
+    return new OpNotBetween_1.OpNotBetween(expression, values);
+}
+exports.NotBetween = NotBetween;
+function In(expression, value) {
+    return new OpIn_1.OpIn(expression, value);
+}
+exports.In = In;
+function NotIn(expression, value) {
+    return new OpNotIn_1.OpNotIn(expression, value);
+}
+exports.NotIn = NotIn;
+exports.Nin = NotIn;
+function Like(expression, value) {
+    return new OpLike_1.OpLike(expression, value);
+}
+exports.Like = Like;
+function NotLike(expression, value) {
+    return new OpNotLike_1.OpNotLike(expression, value);
+}
+exports.NotLike = NotLike;
+exports.NLike = NotLike;
+function Ilike(expression, value) {
+    return new OpILike_1.OpILike(expression, value);
+}
+exports.Ilike = Ilike;
+function NotILike(expression, value) {
+    return new OpNotILike_1.OpNotILike(expression, value);
+}
+exports.NotILike = NotILike;
+exports.Nilike = NotILike;
+function Is(expression, value) {
+    return new OpIs_1.OpIs(expression, value);
+}
+exports.Is = Is;
+function IsNot(expression, value) {
+    return new OpIsNot_1.OpIsNot(expression, value);
+}
+exports.IsNot = IsNot;
+function Exists(expression) {
+    return new OpExists_1.OpExists(expression);
+}
+exports.Exists = Exists;
+function NotExists(expression) {
+    return new OpNotExists_1.OpNotExists(expression);
+}
+exports.NotExists = NotExists;
+const op = {
+    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,
+    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
+};
+exports.op = op;
+Object.assign(LogicalOperator_1.WrapOps, op);

package/dist/query/DeleteQuery.d.ts

@@ -0,0 +1,24 @@
+import { Query } from './Query';
+import { RawStatement } from '../sql-objects/RawStatement';
+import { SerializationType } from '../enums';
+import { TableName } from '../sql-objects/TableName';
+import { LogicalOperator } from '../sql-objects/operators/LogicalOperator';
+import { SerializeContext } from '../SerializeContext';
+export declare class DeleteQuery extends Query {
+    _table: TableName | RawStatement;
+    _where?: LogicalOperator;
+    constructor(tableName: string | RawStatement);
+    get _type(): SerializationType;
+    /**
+     * Defines "where" part of query
+     */
+    where(...operator: any[]): this;
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    _serializeWhere(ctx: SerializeContext): string;
+}

package/dist/query/DeleteQuery.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteQuery = void 0;
+const Query_1 = require("./Query");
+const enums_1 = require("../enums");
+const TableName_1 = require("../sql-objects/TableName");
+const OpAnd_1 = require("../sql-objects/operators/OpAnd");
+const typeguards_1 = require("../typeguards");
+class DeleteQuery extends Query_1.Query {
+    constructor(tableName) {
+        super();
+        if (!tableName || !(typeof tableName === 'string' || (0, typeguards_1.isRawStatement)(tableName)))
+            throw new TypeError('String or Raw instance required as first argument (tableName) for UpdateQuery');
+        this._table = typeof tableName === 'string' ? new TableName_1.TableName(tableName) : tableName;
+    }
+    get _type() {
+        return enums_1.SerializationType.DELETE_QUERY;
+    }
+    /**
+     * Defines "where" part of query
+     */
+    where(...operator) {
+        this._where = this._where || new OpAnd_1.OpAnd();
+        this._where.add(...operator);
+        return this;
+    }
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx) {
+        const o = {
+            table: this._table._serialize(ctx),
+            where: this._serializeWhere(ctx)
+        };
+        let out = 'delete from ' + o.table;
+        if (o.where)
+            out += '\n' + o.where;
+        return out;
+    }
+    /**
+     *
+     */
+    _serializeWhere(ctx) {
+        if (!this._where)
+            return '';
+        const s = this._where._serialize(ctx);
+        return ctx.serialize(enums_1.SerializationType.CONDITIONS_BLOCK, s, () => {
+            /* istanbul ignore next */
+            return s ? 'where ' + s : '';
+        });
+    }
+}
+exports.DeleteQuery = DeleteQuery;

package/dist/query/InsertQuery.d.ts

@@ -0,0 +1,23 @@
+import { ReturningQuery } from './ReturningQuery';
+import { SerializationType } from '../enums';
+import { TableName } from '../sql-objects/TableName';
+import type { RawStatement } from '../sql-objects/RawStatement';
+import { SerializeContext } from '../SerializeContext';
+export declare class InsertQuery extends ReturningQuery {
+    _table: TableName | RawStatement;
+    _input: any;
+    constructor(tableName: string | RawStatement, input: any);
+    get _type(): SerializationType;
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeColumns(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeValues(ctx: SerializeContext): string;
+}

package/dist/query/InsertQuery.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertQuery = void 0;
+const ReturningQuery_1 = require("./ReturningQuery");
+const enums_1 = require("../enums");
+const TableName_1 = require("../sql-objects/TableName");
+const typeguards_1 = require("../typeguards");
+const helpers_1 = require("../helpers");
+class InsertQuery extends ReturningQuery_1.ReturningQuery {
+    constructor(tableName, input) {
+        super();
+        if (!tableName || !(typeof tableName === 'string' || (0, typeguards_1.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_1.TableName(tableName) : tableName;
+        this._input = input;
+    }
+    get _type() {
+        return enums_1.SerializationType.INSERT_QUERY;
+    }
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx) {
+        const o = {
+            table: this._table._serialize(ctx),
+            columns: this.__serializeColumns(ctx),
+            values: this.__serializeValues(ctx),
+            returning: this.__serializeReturning(ctx)
+        };
+        let out = 'insert into ' + o.table + '\n\t(' +
+            o.columns + ')\n\bvalues\n\t(' + o.values + ')\b';
+        if (o.returning)
+            out += '\n' + o.returning;
+        return out;
+    }
+    /**
+     *
+     */
+    __serializeColumns(ctx) {
+        let arr;
+        if ((0, typeguards_1.isSelectQuery)(this._input)) {
+            arr = [];
+            const cols = this._input._columns;
+            if (cols) {
+                for (const col of cols) {
+                    if (col._alias)
+                        arr.push(col._alias);
+                    else if (col._field)
+                        arr.push(col._field);
+                }
+            }
+        }
+        else
+            arr = Object.keys(this._input);
+        return ctx.serialize(enums_1.SerializationType.INSERT_QUERY_COLUMNS, arr, () => (0, helpers_1.printArray)(arr));
+    }
+    /**
+     *
+     */
+    __serializeValues(ctx) {
+        if ((0, typeguards_1.isSerializable)(this._input))
+            return this._input._serialize(ctx);
+        const arr = [];
+        const allValues = this._input;
+        for (const n of Object.keys(allValues)) {
+            const s = ctx.anyToSQL(allValues[n]);
+            if (s)
+                arr.push((0, typeguards_1.isSelectQuery)(allValues[n]) ? '(' + s + ')' : s);
+        }
+        return ctx.serialize(enums_1.SerializationType.INSERT_QUERY_VALUES, arr, () => (0, helpers_1.printArray)(arr));
+    }
+}
+exports.InsertQuery = InsertQuery;

package/dist/query/Query.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Serializable } from '../Serializable';
+import { GenerateOptions, GenerateResult } from '../types';
+export declare interface Query extends EventEmitter {
+}
+export declare abstract class Query extends Serializable {
+    protected _params?: Record<string, any>;
+    constructor();
+    /**
+     * Generates Sql script
+     */
+    generate(options?: GenerateOptions): GenerateResult;
+    values(obj: any): this;
+}

package/dist/query/Query.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+const tslib_1 = require("tslib");
+const events_1 = require("events");
+const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const putil_flattentext_1 = tslib_1.__importDefault(require("putil-flattentext"));
+const Serializable_1 = require("../Serializable");
+const SerializeContext_1 = require("../SerializeContext");
+class Query extends Serializable_1.Serializable {
+    constructor() {
+        super();
+        events_1.EventEmitter.call(this);
+    }
+    /**
+     * Generates Sql script
+     */
+    generate(options) {
+        const ctx = new SerializeContext_1.SerializeContext(options);
+        if (this._params)
+            ctx.params = { ...ctx.params, ...this._params };
+        ctx.serializeHooks = this.listeners('serialize');
+        /* generate output */
+        const sql = this._serialize(ctx);
+        return {
+            sql: (0, putil_flattentext_1.default)(sql, { noWrap: !ctx.prettyPrint }),
+            params: ctx.preparedParams,
+            paramOptions: ctx.paramOptions,
+            returningFields: ctx.returningFields
+        };
+    }
+    values(obj) {
+        if (typeof obj !== 'object' || Array.isArray(obj))
+            throw new TypeError('Invalid argument');
+        this._params = obj;
+        return this;
+    }
+}
+exports.Query = Query;
+(0, putil_merge_1.default)(Query.prototype, events_1.EventEmitter.prototype, { descriptor: true });

package/dist/query/ReturningQuery.d.ts

@@ -0,0 +1,14 @@
+import { Query } from './Query';
+import { ReturningColumn } from '../sql-objects/ReturningColumn';
+import { SerializeContext } from '../SerializeContext';
+export declare abstract class ReturningQuery extends Query {
+    _returningColumns?: ReturningColumn[];
+    /**
+     *
+     */
+    returning(...columns: string[]): this;
+    /**
+     *
+     */
+    protected __serializeReturning(ctx: SerializeContext): string;
+}

package/dist/query/ReturningQuery.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturningQuery = void 0;
+const Query_1 = require("./Query");
+const enums_1 = require("../enums");
+const ReturningColumn_1 = require("../sql-objects/ReturningColumn");
+const helpers_1 = require("../helpers");
+class ReturningQuery extends Query_1.Query {
+    /**
+     *
+     */
+    returning(...columns) {
+        if (!columns)
+            return this;
+        // noinspection JSMismatchedCollectionQueryUpdate
+        this._returningColumns = columns.length ?
+            columns.reduce((a, v) => {
+                if (v)
+                    a.push(new ReturningColumn_1.ReturningColumn(v));
+                return a;
+            }, []) : undefined;
+        return this;
+    }
+    /**
+     *
+     */
+    __serializeReturning(ctx) {
+        if (!(this._returningColumns && this._returningColumns.length))
+            return '';
+        const arr = [];
+        ctx.returningFields = [];
+        for (const t of this._returningColumns) {
+            const s = t._serialize(ctx);
+            /* istanbul ignore else */
+            if (s)
+                arr.push(s);
+        }
+        return ctx.serialize(enums_1.SerializationType.RETURNING_BLOCK, arr, () => {
+            const s = (0, helpers_1.printArray)(arr);
+            return s ? 'returning ' + s : '';
+        });
+    }
+}
+exports.ReturningQuery = ReturningQuery;

package/dist/query/SelectQuery.d.ts

@@ -0,0 +1,90 @@
+import { Query } from './Query';
+import { RawStatement } from '../sql-objects/RawStatement';
+import { SerializationType } from '../enums';
+import { JoinStatement } from '../sql-objects/JoinStatement';
+import { LogicalOperator } from '../sql-objects/operators/LogicalOperator';
+import { GroupColumn } from '../sql-objects/GroupColumn';
+import { OrderColumn } from '../sql-objects/OrderColumn';
+import { Serializable } from '../Serializable';
+import { SerializeContext } from '../SerializeContext';
+export declare class SelectQuery extends Query {
+    _tables?: Serializable[];
+    _columns?: Serializable[];
+    _joins?: JoinStatement[];
+    _where?: LogicalOperator;
+    _groupBy?: (GroupColumn | RawStatement)[];
+    _orderBy?: (OrderColumn | RawStatement)[];
+    _limit?: number;
+    _offset?: number;
+    _alias?: string;
+    _distinct?: boolean;
+    constructor(...column: (string | string[] | Serializable)[]);
+    get _type(): SerializationType;
+    /**
+     * Adds columns to query.
+     */
+    addColumn(...column: (string | string[] | Serializable)[]): this;
+    /**
+     * Defines "from" part of  query.
+     */
+    from(...table: (string | RawStatement | SelectQuery)[]): this;
+    /**
+     * Adds "join" statements to query
+     */
+    join(...join: JoinStatement[]): this;
+    /**
+     * Defines "where" part of query
+     */
+    where(...condition: (Serializable | Object)[]): this;
+    /**
+     * Defines "where" part of query
+     */
+    groupBy(...field: (string | RawStatement)[]): this;
+    /**
+     * Defines "order by" part of query.
+     */
+    orderBy(...field: (string | RawStatement)[]): this;
+    /**
+     * Sets alias for sub-select queries
+     */
+    as(alias: any): this;
+    /**
+     * Sets limit for query
+     */
+    limit(limit: number): this;
+    /**
+     * Sets offset for query
+     */
+    offset(offset: number): this;
+    /**
+     * Enables distinct mode
+     */
+    distinct(): this;
+    onFetch(listener: (...args: any[]) => void): this;
+    onceFetch(listener: (...args: any[]) => void): this;
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeSelectColumns(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeFrom(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeJoins(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeWhere(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeGroupColumns(ctx: SerializeContext): string;
+    protected __serializeOrderColumns(ctx: SerializeContext): string;
+}