@sqb/builder 4.0.1-beta.9 → 4.0.6

package/dist/Serializable.d.ts

@@ -1,6 +1,5 @@
-import { DefaultSerializeFunction, SerializeContext } from './types';
-import { SerializationType } from './enums';
-export declare const ReservedWords: string[];
+import type { SerializationType } from './enums';
+import type { SerializeContext } from './SerializeContext';
 export declare abstract class Serializable {
     abstract _type: SerializationType;
     /**
@@ -8,36 +7,3 @@ export declare abstract class Serializable {
      */
     abstract _serialize(ctx: SerializeContext): string;
 }
-/**
- * Performs a fallback mechanism, tries hook functions, extension than default function to serialize
- */
-export declare function serializeFallback(ctx: SerializeContext, type: string, o: any, defFn: DefaultSerializeFunction): string;
-/**
- * Serializes object
- */
-export declare function serializeObject(ctx: any, v: any): string;
-/**
- *
- */
-export declare function serializeStringValue(val: string): string;
-/**
- *
- */
-export declare function serializeBooleanValue(val: any): string;
-/**
- *
- */
-export declare function serializeNumberValue(val: any): string;
-/**
- *
- */
-export declare function serializeDateValue(date: Date): string;
-/**
- * Prints array with line feeding
- */
-export declare function printArray(arr: string[], sep?: string, lfLen?: number): string;
-/**
- * Check if a string value is a reserved word
- */
-export declare function isReservedWord(ctx: SerializeContext, s: string | undefined | null): boolean;
-export declare function escapeReserved(ctx: SerializeContext, s: string | undefined | null): string;

package/dist/Serializable.js

@@ -1,172 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeReserved = exports.isReservedWord = exports.printArray = exports.serializeDateValue = exports.serializeNumberValue = exports.serializeBooleanValue = exports.serializeStringValue = exports.serializeObject = exports.serializeFallback = exports.Serializable = exports.ReservedWords = void 0;
-const enums_1 = require("./enums");
-const extensions_1 = require("./extensions");
-exports.ReservedWords = [
-    'schema', 'table', 'field', 'index', 'foreign', 'key',
-    'select', 'insert', 'update', 'delete', 'with', 'merge',
-    'join', 'inner', 'outer', 'left', 'right', 'full',
-    'from', 'where', 'order', 'by', 'group', 'having',
-    'acs', 'ascending', 'dsc', 'descending', 'distinct',
-    'and', 'or', 'not', 'between', 'null', 'like', 'ilike',
-    'count', 'sum', 'average', 'avg', 'cascade', 'authorization',
-    'create', 'add', 'drop', 'alter', 'index', 'private', 'sequence',
-    'default', 'constraint', 'references', 'primary', 'foreign',
-    'user', 'password'
-];
+exports.Serializable = void 0;
 class Serializable {
 }
 exports.Serializable = Serializable;
-/**
- * Performs a fallback mechanism, tries hook functions, extension than default function to serialize
- */
-function serializeFallback(ctx, type, o, defFn) {
-    if (ctx.serializeHooks) {
-        for (const hook of ctx.serializeHooks) {
-            const s = hook(ctx, type, o, defFn);
-            if (s != null)
-                return s;
-        }
-    }
-    for (const ext of extensions_1.serializers) {
-        if (ext.dialect === ctx.dialect && ext.serialize) {
-            const s = ext.serialize(ctx, type, o, defFn);
-            if (s != null)
-                return s;
-        }
-    }
-    return defFn(ctx, o);
-}
-exports.serializeFallback = serializeFallback;
-/**
- * Serializes object
- */
-function serializeObject(ctx, v) {
-    if (v == null)
-        return 'null';
-    if (Array.isArray(v)) {
-        let s = '';
-        for (const [i, t] of v.entries()) {
-            s += (i ? ',' : '') + serializeObject(ctx, t);
-        }
-        return '(' + s + ')';
-    }
-    if (typeof v === 'object') {
-        if (v.isSerializable) {
-            const s = v._serialize(ctx);
-            return s ? (v.isQuery ? '(' + s + ')' : s) :
-                /* istanbul ignore next */
-                'null';
-        }
-        if (v instanceof Date) {
-            return serializeFallback(ctx, enums_1.SerializationType.DATE_VALUE, v, () => serializeDateValue(v));
-        }
-    }
-    if (typeof v === 'string') {
-        return serializeFallback(ctx, enums_1.SerializationType.STRING_VALUE, v, () => serializeStringValue(v));
-    }
-    if (typeof v === 'boolean') {
-        return serializeFallback(ctx, enums_1.SerializationType.BOOLEAN_VALUE, v, () => serializeBooleanValue(v));
-    }
-    if (typeof v === 'number') {
-        return serializeFallback(ctx, enums_1.SerializationType.NUMBER_VALUE, v, () => serializeNumberValue(v));
-    }
-    if (v instanceof Serializable)
-        return v._serialize(ctx);
-    return v;
-}
-exports.serializeObject = serializeObject;
-/**
- *
- */
-function serializeStringValue(val) {
-    return '\'' + String(val).replace(/'/g, '\'\'') + '\'';
-}
-exports.serializeStringValue = serializeStringValue;
-/**
- *
- */
-function serializeBooleanValue(val) {
-    return val ? 'true' : 'false';
-}
-exports.serializeBooleanValue = serializeBooleanValue;
-/**
- *
- */
-function serializeNumberValue(val) {
-    return '' + val;
-}
-exports.serializeNumberValue = serializeNumberValue;
-/**
- *
- */
-function serializeDateValue(date) {
-    const d = date.getUTCDate();
-    const m = date.getUTCMonth() + 1;
-    const y = date.getUTCFullYear();
-    const h = date.getUTCHours();
-    const n = date.getUTCMinutes();
-    const s = date.getUTCSeconds();
-    let str = y + '-' + (m <= 9 ? '0' + m : m) + '-' + (d <= 9 ? '0' + d : d);
-    /* istanbul ignore else */
-    if (h + n + s)
-        str += ' ' + (h <= 9 ? '0' + h : h) + ':' +
-            (n <= 9 ? '0' + n : n) + ':' +
-            (s <= 9 ? '0' + s : s);
-    return '\'' + str + '\'';
-}
-exports.serializeDateValue = serializeDateValue;
-/**
- * Prints array with line feeding
- */
-function printArray(arr, sep, lfLen) {
-    let out = '';
-    let line = '';
-    let k = 0;
-    lfLen = lfLen || 60;
-    sep = sep || ',';
-    for (const s of arr) {
-        /* istanbul ignore next */
-        if (s === undefined)
-            continue;
-        line += (k > 0 ? sep : '');
-        if (line.length > lfLen) {
-            out += (out ? '\n' : '') + line;
-            line = '';
-        }
-        else
-            line += line ? ' ' : '';
-        line += s;
-        k++;
-    }
-    if (line)
-        out += (out ? '\n' : '') + line;
-    return out;
-}
-exports.printArray = printArray;
-/**
- * Check if a string value is a reserved word
- */
-function isReservedWord(ctx, s) {
-    if (!s)
-        return false;
-    if (exports.ReservedWords.includes(s.toLowerCase()))
-        return true;
-    for (const ext of extensions_1.serializers) {
-        if (ext.dialect === ctx.dialect && ext.isReservedWord) {
-            if (ext.isReservedWord(ctx, s))
-                return true;
-        }
-    }
-    return false;
-}
-exports.isReservedWord = isReservedWord;
-function escapeReserved(ctx, s) {
-    if (!s)
-        return '';
-    if (isReservedWord(ctx, s))
-        return '"' + s + '"';
-    return s;
-}
-exports.escapeReserved = escapeReserved;

package/dist/SerializeContext.d.ts

@@ -0,0 +1,47 @@
+import { DefaultSerializeFunction, GenerateOptions, ParamOptions } from './types';
+export declare class SerializeContext implements GenerateOptions {
+    readonly reservedWords: string[];
+    dialect?: string;
+    prettyPrint?: boolean;
+    params?: Record<string, any>;
+    dialectVersion?: string;
+    strictParams?: boolean;
+    serializeHooks?: Function[];
+    paramOptions?: Record<string, ParamOptions> | ParamOptions[];
+    preparedParams?: Record<string, any> | any[];
+    returningFields?: {
+        field: string;
+        alias?: string;
+    }[];
+    strictParamGenId?: number;
+    constructor(opts?: GenerateOptions);
+    /**
+     * Performs a fallback mechanism, tries hook functions, extensions than default function to serialize
+     */
+    serialize(type: string, o: any, fallback: DefaultSerializeFunction): string;
+    /**
+     * Serializes object
+     */
+    anyToSQL(v: any): string;
+    /**
+     *
+     */
+    stringToSQL(val: string): string;
+    /**
+     *
+     */
+    booleanToSQL(val: any): string;
+    /**
+     *
+     */
+    numberToSQL(val: any): string;
+    /**
+     *
+     */
+    dateToSQL(date: Date): string;
+    /**
+     * Check if a string value is a reserved word
+     */
+    isReservedWord(s: string | undefined | null): boolean;
+    escapeReserved(s: string | undefined | null): string;
+}

package/dist/SerializeContext.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeContext = void 0;
+const enums_1 = require("./enums");
+const Serializable_1 = require("./Serializable");
+const extensions_1 = require("./extensions");
+class SerializeContext {
+    constructor(opts) {
+        this.reservedWords = [
+            'schema', 'table', 'field', 'index', 'foreign', 'key',
+            'select', 'insert', 'update', 'delete', 'with', 'merge',
+            'join', 'inner', 'outer', 'left', 'right', 'full',
+            'from', 'where', 'order', 'by', 'group', 'having',
+            'acs', 'ascending', 'dsc', 'descending', 'distinct',
+            'and', 'or', 'not', 'between', 'null', 'like', 'ilike',
+            'count', 'sum', 'average', 'avg', 'cascade', 'authorization',
+            'create', 'add', 'drop', 'alter', 'index', 'private', 'sequence',
+            'default', 'constraint', 'references', 'primary', 'foreign',
+            'user', 'password'
+        ];
+        if (opts)
+            Object.assign(this, opts);
+    }
+    /**
+     * Performs a fallback mechanism, tries hook functions, extensions than default function to serialize
+     */
+    serialize(type, o, fallback) {
+        if (this.serializeHooks) {
+            for (const hook of this.serializeHooks) {
+                const s = hook(this, type, o, fallback);
+                if (s != null)
+                    return s;
+            }
+        }
+        for (const ext of extensions_1.serializers) {
+            if (ext.dialect === this.dialect && ext.serialize) {
+                const s = ext.serialize(this, type, o, fallback);
+                if (s != null)
+                    return s;
+            }
+        }
+        return fallback(this, o);
+    }
+    /**
+     * Serializes object
+     */
+    anyToSQL(v) {
+        if (v == null)
+            return 'null';
+        if (Array.isArray(v)) {
+            const vv = v.map(x => this.anyToSQL(x));
+            return this.serialize(enums_1.SerializationType.ARRAY, vv, () => '(' + v.join(',')) + ')';
+        }
+        if (typeof v === 'object') {
+            if (v.isSerializable) {
+                const s = v._serialize(this);
+                return s ? (v.isQuery ? '(' + s + ')' : s) :
+                    /* istanbul ignore next */
+                    'null';
+            }
+            if (v instanceof Date) {
+                return this.serialize(enums_1.SerializationType.DATE_VALUE, v, () => this.dateToSQL(v));
+            }
+        }
+        if (typeof v === 'string') {
+            return this.serialize(enums_1.SerializationType.STRING_VALUE, v, () => this.stringToSQL(v));
+        }
+        if (typeof v === 'boolean') {
+            return this.serialize(enums_1.SerializationType.BOOLEAN_VALUE, v, () => this.booleanToSQL(v));
+        }
+        if (typeof v === 'number') {
+            return this.serialize(enums_1.SerializationType.NUMBER_VALUE, v, () => this.numberToSQL(v));
+        }
+        if (v instanceof Serializable_1.Serializable)
+            return v._serialize(this);
+        return v;
+    }
+    /**
+     *
+     */
+    stringToSQL(val) {
+        return '\'' + String(val).replace(/'/g, '\'\'') + '\'';
+    }
+    /**
+     *
+     */
+    booleanToSQL(val) {
+        return val ? 'true' : 'false';
+    }
+    /**
+     *
+     */
+    numberToSQL(val) {
+        return '' + val;
+    }
+    /**
+     *
+     */
+    dateToSQL(date) {
+        const d = date.getUTCDate();
+        const m = date.getUTCMonth() + 1;
+        const y = date.getUTCFullYear();
+        const h = date.getUTCHours();
+        const n = date.getUTCMinutes();
+        const s = date.getUTCSeconds();
+        let str = y + '-' + (m <= 9 ? '0' + m : m) + '-' + (d <= 9 ? '0' + d : d);
+        /* istanbul ignore else */
+        if (h + n + s)
+            str += ' ' + (h <= 9 ? '0' + h : h) + ':' +
+                (n <= 9 ? '0' + n : n) + ':' +
+                (s <= 9 ? '0' + s : s);
+        return '\'' + str + '\'';
+    }
+    /**
+     * Check if a string value is a reserved word
+     */
+    isReservedWord(s) {
+        if (!s)
+            return false;
+        if (this.reservedWords.includes(s.toLowerCase()))
+            return true;
+        for (const ext of extensions_1.serializers) {
+            if (ext.dialect === this.dialect && ext.isReservedWord) {
+                if (ext.isReservedWord(this, s))
+                    return true;
+            }
+        }
+        return false;
+    }
+    escapeReserved(s) {
+        if (!s)
+            return '';
+        if (this.isReservedWord(s))
+            return '"' + s + '"';
+        return s;
+    }
+}
+exports.SerializeContext = SerializeContext;

package/dist/classes.d.ts

@@ -4,11 +4,11 @@ export * from './query/SelectQuery';
 export * from './query/InsertQuery';
 export * from './query/UpdateQuery';
 export * from './query/DeleteQuery';
-export * from './sql-objects/SelectColumn';
+export * from './sql-objects/FieldExpression';
 export * from './sql-objects/TableName';
 export * from './sql-objects/OrderColumn';
 export * from './sql-objects/GroupColumn';
-export * from './sql-objects/Column';
+export * from './sql-objects/BaseField';
 export * from './sql-objects/Operator';
 export * from './sql-objects/CaseStatement';
 export * from './sql-objects/JoinStatement';

package/dist/classes.js

@@ -16,11 +16,11 @@ __exportStar(require("./query/SelectQuery"), exports);
 __exportStar(require("./query/InsertQuery"), exports);
 __exportStar(require("./query/UpdateQuery"), exports);
 __exportStar(require("./query/DeleteQuery"), exports);
-__exportStar(require("./sql-objects/SelectColumn"), exports);
+__exportStar(require("./sql-objects/FieldExpression"), exports);
 __exportStar(require("./sql-objects/TableName"), exports);
 __exportStar(require("./sql-objects/OrderColumn"), exports);
 __exportStar(require("./sql-objects/GroupColumn"), exports);
-__exportStar(require("./sql-objects/Column"), exports);
+__exportStar(require("./sql-objects/BaseField"), exports);
 __exportStar(require("./sql-objects/Operator"), exports);
 __exportStar(require("./sql-objects/CaseStatement"), exports);
 __exportStar(require("./sql-objects/JoinStatement"), exports);

package/dist/enums.d.ts

@@ -38,7 +38,8 @@ export declare enum SerializationType {
     STRING_VALUE = "string_value",
     BOOLEAN_VALUE = "boolean_value",
     NUMBER_VALUE = "number_value",
-    EXTERNAL_PARAMETER = "external_parameter"
+    EXTERNAL_PARAMETER = "external_parameter",
+    ARRAY = "array"
 }
 export declare enum OperatorType {
     and = "and",
@@ -78,5 +79,6 @@ export declare enum DataType {
     TIME = "TIME",
     BINARY = "BINARY",
     TEXT = "TEXT",
-    GUID = "GUID"
+    GUID = "GUID",
+    JSON = "JSON"
 }

package/dist/enums.js

@@ -44,6 +44,7 @@ var SerializationType;
     SerializationType["BOOLEAN_VALUE"] = "boolean_value";
     SerializationType["NUMBER_VALUE"] = "number_value";
     SerializationType["EXTERNAL_PARAMETER"] = "external_parameter";
+    SerializationType["ARRAY"] = "array";
 })(SerializationType = exports.SerializationType || (exports.SerializationType = {}));
 var OperatorType;
 (function (OperatorType) {
@@ -86,4 +87,5 @@ var DataType;
     DataType["BINARY"] = "BINARY";
     DataType["TEXT"] = "TEXT";
     DataType["GUID"] = "GUID";
+    DataType["JSON"] = "JSON";
 })(DataType = exports.DataType || (exports.DataType = {}));

package/dist/helpers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Prints array with line feeding
+ */
+export declare function printArray(arr: string[], sep?: string, lfLen?: number): string;

package/dist/helpers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printArray = void 0;
+/**
+ * Prints array with line feeding
+ */
+function printArray(arr, sep, lfLen) {
+    let out = '';
+    let line = '';
+    let k = 0;
+    lfLen = lfLen || 60;
+    sep = sep || ',';
+    for (const s of arr) {
+        /* istanbul ignore next */
+        if (s === undefined)
+            continue;
+        line += (k > 0 ? sep : '');
+        if (line.length > lfLen) {
+            out += (out ? '\n' : '') + line;
+            line = '';
+        }
+        else
+            line += line ? ' ' : '';
+        line += s;
+        k++;
+    }
+    if (line)
+        out += (out ? '\n' : '') + line;
+    return out;
+}
+exports.printArray = printArray;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { registerSerializer, unRegisterSerializer } from './extensions';
-export { escapeReserved, isReservedWord, printArray } from './Serializable';
+export * from './helpers';
 export * from './Serializable';
+export * from './SerializeContext';
 export * from './query/Query';
 export * from './query/SelectQuery';
 export * from './query/InsertQuery';
@@ -10,10 +11,10 @@ export * from './sql-objects/Operator';
 export * from './sql-objects/operators/LogicalOperator';
 export * from './sql-objects/operators/CompOperator';
 export * from './sql-objects/JoinStatement';
-export * as classes from './classes';
 export * from './types';
 export * from './enums';
-export * from './sql-objects/sqlobject.initializers';
-export * from './sql-objects/op.initializers';
-export { op } from './sql-objects/op.initializers';
+export * from './sqlobject.initializers';
+export * from './op.initializers';
 export * from './typeguards';
+export { op } from './op.initializers';
+export * as classes from './classes';

package/dist/index.js

@@ -22,15 +22,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.op = exports.classes = exports.printArray = exports.isReservedWord = exports.escapeReserved = exports.unRegisterSerializer = exports.registerSerializer = void 0;
+exports.classes = exports.op = exports.unRegisterSerializer = exports.registerSerializer = void 0;
 var extensions_1 = require("./extensions");
 Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return extensions_1.registerSerializer; } });
 Object.defineProperty(exports, "unRegisterSerializer", { enumerable: true, get: function () { return extensions_1.unRegisterSerializer; } });
-var Serializable_1 = require("./Serializable");
-Object.defineProperty(exports, "escapeReserved", { enumerable: true, get: function () { return Serializable_1.escapeReserved; } });
-Object.defineProperty(exports, "isReservedWord", { enumerable: true, get: function () { return Serializable_1.isReservedWord; } });
-Object.defineProperty(exports, "printArray", { enumerable: true, get: function () { return Serializable_1.printArray; } });
+__exportStar(require("./helpers"), exports);
 __exportStar(require("./Serializable"), exports);
+__exportStar(require("./SerializeContext"), exports);
 __exportStar(require("./query/Query"), exports);
 __exportStar(require("./query/SelectQuery"), exports);
 __exportStar(require("./query/InsertQuery"), exports);
@@ -40,11 +38,11 @@ __exportStar(require("./sql-objects/Operator"), exports);
 __exportStar(require("./sql-objects/operators/LogicalOperator"), exports);
 __exportStar(require("./sql-objects/operators/CompOperator"), exports);
 __exportStar(require("./sql-objects/JoinStatement"), exports);
-exports.classes = __importStar(require("./classes"));
 __exportStar(require("./types"), exports);
 __exportStar(require("./enums"), exports);
-__exportStar(require("./sql-objects/sqlobject.initializers"), exports);
-__exportStar(require("./sql-objects/op.initializers"), exports);
-var op_initializers_1 = require("./sql-objects/op.initializers");
-Object.defineProperty(exports, "op", { enumerable: true, get: function () { return op_initializers_1.op; } });
+__exportStar(require("./sqlobject.initializers"), exports);
+__exportStar(require("./op.initializers"), exports);
 __exportStar(require("./typeguards"), exports);
+var op_initializers_1 = require("./op.initializers");
+Object.defineProperty(exports, "op", { enumerable: true, get: function () { return op_initializers_1.op; } });
+exports.classes = __importStar(require("./classes"));

package/dist/{sql-objects/op.initializers.d.ts → op.initializers.d.ts}

@@ -1,25 +1,25 @@
-import { OpAnd } from './operators/OpAnd';
-import { OpOr } from './operators/OpOr';
-import { OpEq } from './operators/OpEq';
-import { OpGt } from './operators/OpGt';
-import { OpGte } from './operators/OpGte';
-import { OpLt } from './operators/OpLt';
-import { OpLte } from './operators/OpLte';
-import { OpIn } from './operators/OpIn';
-import { OpIs } from './operators/OpIs';
-import { OpIsNot } from './operators/OpIsNot';
-import { OpLike } from './operators/OpLike';
-import { OpILike } from './operators/OpILike';
-import { OpNe } from './operators/OpNe';
-import { OpNotIn } from './operators/OpNotIn';
-import { OpNotLike } from './operators/OpNotLike';
-import { OpNotILike } from './operators/OpNotILike';
-import { OpExists } from './operators/OpExists';
-import { OpNotExists } from './operators/OpNotExists';
-import { Operator } from './Operator';
-import { RawStatement } from './RawStatement';
-import { Serializable } from '../Serializable';
-import { SelectQuery } from '../query/SelectQuery';
+import { OpAnd } from './sql-objects/operators/OpAnd';
+import { OpOr } from './sql-objects/operators/OpOr';
+import { OpEq } from './sql-objects/operators/OpEq';
+import { OpGt } from './sql-objects/operators/OpGt';
+import { OpGte } from './sql-objects/operators/OpGte';
+import { OpLt } from './sql-objects/operators/OpLt';
+import { OpLte } from './sql-objects/operators/OpLte';
+import { OpIn } from './sql-objects/operators/OpIn';
+import { OpIs } from './sql-objects/operators/OpIs';
+import { OpIsNot } from './sql-objects/operators/OpIsNot';
+import { OpLike } from './sql-objects/operators/OpLike';
+import { OpILike } from './sql-objects/operators/OpILike';
+import { OpNe } from './sql-objects/operators/OpNe';
+import { OpNotIn } from './sql-objects/operators/OpNotIn';
+import { OpNotLike } from './sql-objects/operators/OpNotLike';
+import { OpNotILike } from './sql-objects/operators/OpNotILike';
+import { OpExists } from './sql-objects/operators/OpExists';
+import { OpNotExists } from './sql-objects/operators/OpNotExists';
+import { Operator } from './sql-objects/Operator';
+import { RawStatement } from './sql-objects/RawStatement';
+import { Serializable } from './Serializable';
+import { SelectQuery } from './query/SelectQuery';
 declare function And(...args: (Operator | RawStatement)[]): OpAnd;
 declare function Or(...args: (Operator | RawStatement)[]): OpOr;
 declare function Eq(expression: string | Serializable, value: any): OpEq;