@sqb/builder 5.0.4 → 5.0.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/builder",
   "description": "Extensible multi-dialect SQL query builder written with TypeScript",
-  "version": "5.0.4",
+  "version": "5.0.6",
   "author": "Panates",
   "license": "Apache-2.0",
   "dependencies": {

package/serialize-context.d.ts

@@ -6,6 +6,7 @@ export declare class SerializeContext implements GenerateOptions {
     dialect?: string;
     prettyPrint?: boolean;
     params?: Record<string, any>;
+    orgParams?: Record<string, any>;
     dialectVersion?: string;
     strictParams?: boolean;
     serializeHooks?: Function[];

package/serialize-context.js

@@ -1,8 +1,7 @@
 import { SerializationType } from './enums.js';
 import { SerializerRegistry } from './extensions.js';
-import { SqlElement } from './serializable.js';
 import { Query } from './sql/index.js';
-import { isLogicalOperator, isQuery, isSerializable } from './type-guards.js';
+import { isLogicalOperator, isQuery, isSqlElement } from './type-guards.js';
 export class SerializeContext {
     rootQuery;
     reservedWords = [
@@ -66,6 +65,7 @@ export class SerializeContext {
     dialect;
     prettyPrint;
     params;
+    orgParams;
     dialectVersion;
     strictParams;
     serializeHooks;
@@ -110,7 +110,7 @@ export class SerializeContext {
                 ')');
         }
         if (typeof v === 'object') {
-            if (isSerializable(v)) {
+            if (isSqlElement(v)) {
                 const s = v._serialize(this);
                 return s
                     ? isQuery(v) || isLogicalOperator(v)
@@ -132,7 +132,7 @@ export class SerializeContext {
         if (typeof v === 'number') {
             return this.serialize(SerializationType.NUMBER_VALUE, v, () => this.numberToSQL(v));
         }
-        if (v instanceof SqlElement)
+        if (isSqlElement(v))
             return v._serialize(this);
         return v;
     }

package/sql/delete.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../enums.js';
 import { SerializeContext } from '../serialize-context.js';
-import { isRaw } from '../type-guards.js';
+import { isRaw, isSqlElement } from '../type-guards.js';
 import { Raw } from './elements/raw.js';
 import { TableName } from './elements/table-name.js';
 import { And } from './operators/and.js';
@@ -50,17 +50,16 @@ export const Delete = function (tableName) {
         return new Delete(tableName);
     Query.call(this);
     if (!(tableName &&
-        (tableName instanceof TableName ||
+        (isSqlElement(tableName, SerializationType.TABLE_NAME) ||
             typeof tableName === 'string' ||
             isRaw(tableName)))) {
         throw new TypeError('String or Raw instance required as first argument (tableName) for Delete');
     }
-    this._table =
-        tableName instanceof TableName
-            ? tableName
-            : typeof tableName === 'string'
-                ? TableName(tableName)
-                : tableName;
+    this._table = isSqlElement(tableName, SerializationType.TABLE_NAME)
+        ? tableName
+        : typeof tableName === 'string'
+            ? TableName(tableName)
+            : tableName;
 };
 Delete.prototype = DeleteClass.prototype;
 Delete.prototype.constructor = Delete;

package/sql/insert.js

@@ -1,8 +1,7 @@
 import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
-import { SqlElement } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
-import { isRaw, isSelect, isSerializable } from '../type-guards.js';
+import { isRaw, isSelect, isSqlElement } from '../type-guards.js';
 import { Raw } from './elements/raw.js';
 import { TableName } from './elements/table-name.js';
 import { Query } from './query.js';
@@ -60,7 +59,7 @@ class InsertClass extends ReturningQuery {
      *
      */
     __serializeValues(ctx) {
-        if (isSerializable(this._input))
+        if (isSqlElement(this._input))
             return this._input._serialize(ctx);
         const arr = [];
         const allValues = this._input;
@@ -80,9 +79,8 @@ export const Insert = function (tableName, input) {
     }
     if (!input ||
         !((typeof input === 'object' && !Array.isArray(input)) ||
-            (input instanceof SqlElement &&
-                (input._type === SerializationType.SELECT_QUERY ||
-                    input._type === SerializationType.RAW)))) {
+            isSelect(input) ||
+            isRaw(input))) {
         throw new TypeError('Object or Select instance required as second argument (input) for Insert');
     }
     this._table =
@@ -96,5 +94,5 @@ Insert.prototype.constructor = Insert;
  * @param value
  */
 export function isInsertQuery(value) {
-    return (isSerializable(value) && value._type === SerializationType.INSERT_QUERY);
+    return isSqlElement(value, SerializationType.INSERT_QUERY);
 }

package/sql/operators/comp-operator.js

@@ -1,7 +1,8 @@
 import { SerializationType } from '../../enums.js';
 import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-import { Field, Param } from '../elements/index.js';
+import { isFieldName, isParam, isSqlElement } from '../../type-guards.js';
+import { Param } from '../elements/index.js';
 import { Operator } from './operator.js';
 const EXPRESSION_PATTERN = /^([\w\\.$]+)(\[])?/;
 class CompOperatorClass extends Operator {
@@ -22,38 +23,42 @@ class CompOperatorClass extends Operator {
             symbol: this._symbol,
             left,
             right,
+            orgLeft: this._left,
+            orgRight: this._right,
         };
         return this.__serialize(ctx, o);
     }
     __serializeItem(ctx, x, left) {
         const isRight = !!left;
-        if (ctx.strictParams && !(x instanceof SqlElement) && isRight) {
+        if (ctx.strictParams && !isSqlElement(x) && isRight) {
             ctx.strictParamGenId = ctx.strictParamGenId || 0;
             const name = 'P$_' + ++ctx.strictParamGenId;
             ctx.params = ctx.params || {};
+            ctx.orgParams = ctx.orgParams || {};
             ctx.params[name] = x;
+            ctx.orgParams[name] = x;
             x = Param({
                 name,
                 dataType: left?.dataType,
                 isArray: left?.isArray || Array.isArray(x),
             });
         }
-        if (x instanceof SqlElement) {
+        if (isSqlElement(x)) {
             const expression = ctx.anyToSQL(x);
             const result = {
                 expression,
             };
-            if (x instanceof Field) {
+            if (isFieldName(x)) {
                 result.dataType = x._dataType;
                 result.isArray = x._isArray;
             }
-            if (x instanceof Param) {
+            if (isParam(x)) {
                 let value = ctx.params ? ctx.params[x._name] : undefined;
                 if (x._isArray && value != null && !Array.isArray(value))
                     value = [value];
                 result.value = value;
                 result.isArray = x._isArray || Array.isArray(value);
-                result.isParam = true;
+                result.isParam = ctx.params?.[x._name] != undefined;
             }
             return result;
         }

package/sql/operators/in.js

@@ -1,6 +1,6 @@
 import { OperatorType } from '../../enums.js';
 import { SerializeContext } from '../../serialize-context.js';
-import { isSerializable } from '../../type-guards.js';
+import { isSqlElement } from '../../type-guards.js';
 import { CompOperator } from './comp-operator.js';
 class InClass extends CompOperator {
     _serialize(ctx) {
@@ -22,7 +22,7 @@ export const In = function (left, right) {
         this._left = m[1];
         this._isArray = !!m[2];
     }
-    this._right = Array.isArray(right) || isSerializable(right) ? right : [right];
+    this._right = Array.isArray(right) || isSqlElement(right) ? right : [right];
 };
 In.prototype = InClass.prototype;
 In.prototype.constructor = In;

package/sql/query.js

@@ -11,6 +11,7 @@ class QueryClass extends SqlElement {
         const ctx = new SerializeContext(this, options);
         if (this._params)
             ctx.params = { ...ctx.params, ...this._params };
+        ctx.orgParams = { ...ctx.params };
         ctx.serializeHooks = this.listeners('serialize');
         /* generate output */
         let sql = this._serialize(ctx);

package/sql/select.js

@@ -4,7 +4,7 @@ import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
 import { SqlElement } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
-import { isJoin } from '../type-guards.js';
+import { isJoin, isSelect, isTableName } from '../type-guards.js';
 import { Field } from './elements/field.js';
 import { GroupColumn } from './elements/group-column.js';
 import { Join } from './elements/join.js';
@@ -66,7 +66,7 @@ class SelectClass extends Query {
         for (const arg of table) {
             if (!arg)
                 continue;
-            this._tables.push(arg instanceof TableName
+            this._tables.push(isTableName(arg)
                 ? arg
                 : typeof arg === 'string'
                     ? new TableName(arg)
@@ -217,7 +217,7 @@ class SelectClass extends Query {
                 const s = ctx.anyToSQL(t);
                 // t._serialize(ctx);
                 if (s) {
-                    if (t instanceof SelectClass) {
+                    if (isSelect(t)) {
                         if (!t._alias)
                             throw new TypeError('Alias required for sub-select in columns');
                         arr.push(s + ' ' + t._alias);
@@ -239,7 +239,7 @@ class SelectClass extends Query {
                 const s = t._serialize(ctx);
                 /* istanbul ignore else */
                 if (s) {
-                    if (t instanceof SelectClass) {
+                    if (isSelect(t)) {
                         if (!t._alias)
                             throw new TypeError('Alias required for sub-select in "from"');
                         arr.push({

package/sql/update.js

@@ -1,8 +1,7 @@
 import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
-import { SqlElement } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
-import { isRaw } from '../type-guards.js';
+import { isRaw, isSelect, isTableName } from '../type-guards.js';
 import { Raw } from './elements/raw.js';
 import { TableName } from './elements/table-name.js';
 import { And } from './operators/and.js';
@@ -76,24 +75,22 @@ export const Update = function (tableName, input) {
         return new Update(tableName, input);
     Query.call(this);
     if (!(tableName &&
-        (tableName instanceof TableName ||
+        (isTableName(tableName) ||
             typeof tableName === 'string' ||
             isRaw(tableName)))) {
         throw new TypeError('String or Raw instance required as first argument (tableName) for Update');
     }
     if (!input ||
         !((typeof input === 'object' && !Array.isArray(input)) ||
-            (input instanceof SqlElement &&
-                (input._type === SerializationType.SELECT_QUERY ||
-                    input._type === SerializationType.RAW)))) {
+            isSelect(input) ||
+            isRaw(input))) {
         throw new TypeError('Object or Raw instance required as second argument (input) for Update');
     }
-    this._table =
-        tableName instanceof TableName
-            ? tableName
-            : typeof tableName === 'string'
-                ? new TableName(tableName)
-                : tableName;
+    this._table = isTableName(tableName)
+        ? tableName
+        : typeof tableName === 'string'
+            ? new TableName(tableName)
+            : tableName;
     this._input = input;
 };
 Update.prototype = UpdateClass.prototype;

package/type-guards.d.ts

@@ -1,7 +1,8 @@
+import { SerializationType } from './enums.js';
 import type { SqlElement } from './serializable.js';
 import type { Case, CompOperator, Count, Delete, Field, GroupColumn, Insert, Join, LogicalOperator, OrderColumn, Param, Query, Raw, ReturningColumn, Select, TableName, Update } from './sql/index.js';
-export declare function isSqlElement(value: any): value is SqlElement;
-export declare function isSerializable(value: any): value is SqlElement;
+export declare function isSqlElement(value: any, type?: SerializationType): value is SqlElement;
+export declare const isSerializable: typeof isSqlElement;
 export declare function isQuery(value: any): value is Query;
 export declare function isRaw(value: any): value is Raw;
 export declare function isSelect(value: any): value is Select;
@@ -20,3 +21,4 @@ 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;
+export declare function isFieldName(value: any): value is Field;

package/type-guards.js

@@ -1,68 +1,68 @@
 import { SerializationType } from './enums.js';
-export function isSqlElement(value) {
-    return typeof value === 'object' && typeof value._serialize === 'function';
+export function isSqlElement(value, type) {
+    return (value &&
+        typeof value === 'object' &&
+        typeof value._serialize === 'function' &&
+        (!type || value._type === type));
 }
 /* Backward compatibility */
-export function isSerializable(value) {
-    return isSqlElement(value);
-}
+export const isSerializable = isSqlElement;
 export function isQuery(value) {
-    return (isSerializable(value) &&
+    return (isSqlElement(value) &&
         typeof value.generate === 'function' &&
         typeof value.values === 'function');
 }
 export function isRaw(value) {
-    return isSerializable(value) && value._type === SerializationType.RAW;
+    return isSqlElement(value, SerializationType.RAW);
 }
 export function isSelect(value) {
-    return (isSerializable(value) && value._type === SerializationType.SELECT_QUERY);
+    return isSqlElement(value, SerializationType.SELECT_QUERY);
 }
 export function isInsert(value) {
-    return (isSerializable(value) && value._type === SerializationType.INSERT_QUERY);
+    return isSqlElement(value, SerializationType.INSERT_QUERY);
 }
 export function isIUpdate(value) {
-    return (isSerializable(value) && value._type === SerializationType.UPDATE_QUERY);
+    return isSqlElement(value, SerializationType.UPDATE_QUERY);
 }
 export function isDelete(value) {
-    return (isSerializable(value) && value._type === SerializationType.DELETE_QUERY);
+    return isSqlElement(value, SerializationType.DELETE_QUERY);
 }
 export function isJoin(value) {
-    return isSerializable(value) && value._type === SerializationType.JOIN;
+    return isSqlElement(value) && value._type === SerializationType.JOIN;
 }
 export function isCase(value) {
-    return (isSerializable(value) && value._type === SerializationType.CASE_STATEMENT);
+    return isSqlElement(value, SerializationType.CASE_STATEMENT);
 }
 export function isCount(value) {
-    return (isSerializable(value) && value._type === SerializationType.COUNT_STATEMENT);
+    return isSqlElement(value, SerializationType.COUNT_STATEMENT);
 }
 export function isParam(value) {
-    return (isSerializable(value) &&
-        value._type === SerializationType.EXTERNAL_PARAMETER);
+    return isSqlElement(value, SerializationType.EXTERNAL_PARAMETER);
 }
 export function isLogicalOperator(value) {
-    return (isSerializable(value) &&
-        value._type === SerializationType.LOGICAL_EXPRESSION);
+    return isSqlElement(value, SerializationType.LOGICAL_EXPRESSION);
 }
 export function isCompOperator(value) {
-    return (isSerializable(value) &&
-        value._type === SerializationType.COMPARISON_EXPRESSION);
+    return isSqlElement(value, SerializationType.COMPARISON_EXPRESSION);
 }
 export function isNot(value) {
-    return (isSerializable(value) &&
-        value._type === SerializationType.NEGATIVE_EXPRESSION);
+    return isSqlElement(value, SerializationType.NEGATIVE_EXPRESSION);
 }
 export function isSelectColumn(value) {
-    return isSerializable(value) && value._type === SerializationType.FIELD_NAME;
+    return isSqlElement(value, SerializationType.FIELD_NAME);
 }
 export function isOrderColumn(value) {
-    return (isSerializable(value) && value._type === SerializationType.ORDER_COLUMN);
+    return isSqlElement(value, SerializationType.ORDER_COLUMN);
 }
 export function isGroupColumn(value) {
-    return (isSerializable(value) && value._type === SerializationType.GROUP_COLUMN);
+    return isSqlElement(value, SerializationType.GROUP_COLUMN);
 }
 export function isReturningColumn(value) {
-    return (isSerializable(value) && value._type === SerializationType.RETURNING_COLUMN);
+    return isSqlElement(value, SerializationType.RETURNING_COLUMN);
 }
 export function isTableName(value) {
-    return isSerializable(value) && value._type === SerializationType.TABLE_NAME;
+    return isSqlElement(value, SerializationType.TABLE_NAME);
+}
+export function isFieldName(value) {
+    return isSqlElement(value, SerializationType.FIELD_NAME);
 }