@sqb/builder 4.20.0 → 4.20.2

package/cjs/sql-objects/param-expression.js

@@ -4,6 +4,9 @@ exports.ParamExpression = void 0;
 const enums_js_1 = require("../enums.js");
 const serializable_js_1 = require("../serializable.js");
 class ParamExpression extends serializable_js_1.Serializable {
+    _name;
+    _dataType;
+    _isArray;
     constructor(arg) {
         super();
         if (typeof arg === 'object') {

package/cjs/sql-objects/raw-statement.js

@@ -4,6 +4,7 @@ exports.RawStatement = void 0;
 const enums_js_1 = require("../enums.js");
 const serializable_js_1 = require("../serializable.js");
 class RawStatement extends serializable_js_1.Serializable {
+    _text;
     constructor(str) {
         super();
         this._text = str;

package/cjs/sql-objects/returning-column.js

@@ -5,6 +5,7 @@ const enums_js_1 = require("../enums.js");
 const base_field_js_1 = require("./base-field.js");
 const RETURNING_COLUMN_PATTERN = /^([a-zA-Z_]\w*) *(?:as)? *(\w+)?$/;
 class ReturningColumn extends base_field_js_1.BaseField {
+    _alias;
     constructor(field) {
         super();
         const m = field.match(RETURNING_COLUMN_PATTERN);

package/cjs/sql-objects/sequence-getter-statement.js

@@ -4,6 +4,9 @@ exports.SequenceGetterStatement = void 0;
 const enums_js_1 = require("../enums.js");
 const serializable_js_1 = require("../serializable.js");
 class SequenceGetterStatement extends serializable_js_1.Serializable {
+    _expression;
+    _next;
+    _alias;
     constructor(expression, next) {
         super();
         this._expression = expression;

package/cjs/sql-objects/string-agg-statement.js

@@ -7,6 +7,10 @@ const serializable_js_1 = require("../serializable.js");
 const field_expression_js_1 = require("./field-expression.js");
 const order_column_js_1 = require("./order-column.js");
 class StringAGGStatement extends serializable_js_1.Serializable {
+    _field;
+    _delimiter;
+    _orderBy;
+    _alias;
     constructor(field, delimiter) {
         super();
         this._field =

package/cjs/sql-objects/table-name.js

@@ -4,6 +4,9 @@ exports.TableName = void 0;
 const enums_js_1 = require("../enums.js");
 const serializable_js_1 = require("../serializable.js");
 class TableName extends serializable_js_1.Serializable {
+    schema;
+    table;
+    alias;
     constructor(tableName) {
         super();
         const m = tableName.match(/^(?:([a-zA-Z][\w$]*)\.)? *([a-zA-Z][\w$]*) *(?:as)? *(\w+)?$/);

package/cjs/sql-objects/upper-statement.js

@@ -4,6 +4,8 @@ exports.UpperStatement = void 0;
 const enums_js_1 = require("../enums.js");
 const serializable_js_1 = require("../serializable.js");
 class UpperStatement extends serializable_js_1.Serializable {
+    _expression;
+    _alias;
     constructor(expression) {
         super();
         this._expression = expression;

package/esm/extensions.js

@@ -1,4 +1,5 @@
 export class SerializerRegistry {
+    static serializers = [];
     static get size() {
         return this.serializers.length;
     }
@@ -31,4 +32,3 @@ export class SerializerRegistry {
         return !!this.serializers.find(x => x === extension);
     }
 }
-SerializerRegistry.serializers = [];

package/esm/query/delete-query.js

@@ -4,6 +4,8 @@ import { TableName } from '../sql-objects/table-name.js';
 import { isRawStatement } from '../typeguards.js';
 import { Query } from './query.js';
 export class DeleteQuery extends Query {
+    _table;
+    _where;
     constructor(tableName) {
         super();
         if (!tableName ||

package/esm/query/insert-query.js

@@ -4,6 +4,8 @@ import { TableName } from '../sql-objects/table-name.js';
 import { isRawStatement, isSelectQuery, isSerializable, } from '../typeguards.js';
 import { ReturningQuery } from './returning-query.js';
 export class InsertQuery extends ReturningQuery {
+    _table;
+    _input;
     constructor(tableName, input) {
         super();
         if (!tableName ||

package/esm/query/query.js

@@ -4,6 +4,7 @@ import merge from 'putil-merge';
 import { Serializable } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
 export class Query extends Serializable {
+    _params;
     constructor() {
         super();
         EventEmitter.call(this);

package/esm/query/returning-query.js

@@ -3,6 +3,7 @@ import { printArray } from '../helpers.js';
 import { ReturningColumn } from '../sql-objects/returning-column.js';
 import { Query } from './query.js';
 export class ReturningQuery extends Query {
+    _returningColumns;
     /**
      *
      */

package/esm/query/select-query.js

@@ -9,6 +9,16 @@ import { TableName } from '../sql-objects/table-name.js';
 import { isJoinStatement, isSerializable } from '../typeguards.js';
 import { Query } from './query.js';
 export class SelectQuery extends Query {
+    _tables;
+    _columns;
+    _joins;
+    _where;
+    _groupBy;
+    _orderBy;
+    _limit;
+    _offset;
+    _alias;
+    _distinct;
     constructor(...column) {
         super();
         if (column.length)

package/esm/query/union-query.js

@@ -1,6 +1,8 @@
 import { SerializationType } from '../enums.js';
 import { Query } from './query.js';
 export class UnionQuery extends Query {
+    _queries;
+    _unionType;
     constructor(queries, unionType) {
         super();
         this._queries = queries;

package/esm/query/update-query.js

@@ -5,6 +5,9 @@ import { TableName } from '../sql-objects/table-name.js';
 import { isRawStatement } from '../typeguards.js';
 import { ReturningQuery } from './returning-query.js';
 export class UpdateQuery extends ReturningQuery {
+    _table;
+    _input;
+    _where;
     constructor(tableName, input) {
         super();
         if (!tableName ||

package/esm/serialize-context.js

@@ -3,65 +3,75 @@ import { SerializerRegistry } from './extensions.js';
 import { Serializable } from './serializable.js';
 import { isLogicalOperator, isQuery, isSerializable } from './typeguards.js';
 export class SerializeContext {
+    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',
+    ];
+    dialect;
+    prettyPrint;
+    params;
+    dialectVersion;
+    strictParams;
+    serializeHooks;
+    paramOptions;
+    preparedParams;
+    returningFields;
+    strictParamGenId;
     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);
     }

package/esm/sql-objects/base-field.js

@@ -1,7 +1,7 @@
 import { Expression } from './expression.js';
 export class BaseField extends Expression {
-    constructor() {
-        super(...arguments);
-        this._field = '';
-    }
+    _field = '';
+    _schema;
+    _table;
+    _descending;
 }

package/esm/sql-objects/case-statement.js

@@ -2,6 +2,10 @@ import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 import { OpAnd } from './operators/op-and.js';
 export class CaseStatement extends Serializable {
+    _expressions;
+    _elseValue;
+    _condition;
+    _alias;
     constructor() {
         super();
         this._expressions = [];

package/esm/sql-objects/coalesce-statement.js

@@ -1,6 +1,8 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 export class CoalesceStatement extends Serializable {
+    _expressions;
+    _alias;
     constructor(...expressions) {
         super();
         this._expressions = expressions;

package/esm/sql-objects/count-statement.js

@@ -1,6 +1,7 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 export class CountStatement extends Serializable {
+    _alias;
     get _type() {
         return SerializationType.COUNT_STATEMENT;
     }

package/esm/sql-objects/expression.js

@@ -1,3 +1,6 @@
 import { Serializable } from '../serializable.js';
 export class Expression extends Serializable {
+    _dataType;
+    _isArray;
+    _isDataSet;
 }

package/esm/sql-objects/field-expression.js

@@ -2,6 +2,7 @@ import { SerializationType } from '../enums.js';
 import { BaseField } from './base-field.js';
 const TABLE_COLUMN_PATTERN = /^((?:[a-zA-Z_][\w$_]*\.){0,2}) *([0-9a-zA-Z_][\w$_]*|\*) *(?:as)? *([a-zA-Z_][\w$_]*)?$/;
 export class FieldExpression extends BaseField {
+    _alias;
     constructor(arg0, arg1, arg2) {
         super();
         let expression;

package/esm/sql-objects/join-statement.js

@@ -4,9 +4,11 @@ import { isRawStatement, isSelectQuery, isTableName } from '../typeguards.js';
 import { OpAnd } from './operators/op-and.js';
 import { TableName } from './table-name.js';
 export class JoinStatement extends Serializable {
+    _joinType;
+    _table;
+    _conditions = new OpAnd();
     constructor(joinType, table) {
         super();
-        this._conditions = new OpAnd();
         // noinspection SuspiciousTypeOfGuard
         if (!(isSelectQuery(table) ||
             isRawStatement(table) ||

package/esm/sql-objects/lower-statement.js

@@ -1,6 +1,8 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 export class LowerStatement extends Serializable {
+    _expression;
+    _alias;
     constructor(expression) {
         super();
         this._expression = expression;

package/esm/sql-objects/max-statement.js

@@ -1,6 +1,8 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 export class MaxStatement extends Serializable {
+    _expression;
+    _alias;
     constructor(expression) {
         super();
         this._expression = expression;

package/esm/sql-objects/min-statement.js

@@ -1,6 +1,8 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 export class MinStatement extends Serializable {
+    _expression;
+    _alias;
     constructor(expression) {
         super();
         this._expression = expression;

package/esm/sql-objects/operators/comp-operator.js

@@ -6,6 +6,10 @@ import { Operator } from '../operator.js';
 import { ParamExpression } from '../param-expression.js';
 const EXPRESSION_PATTERN = /^([\w\\.$]+)(\[])?/;
 export class CompOperator extends Operator {
+    _left;
+    _right;
+    _symbol;
+    _isArray;
     constructor(left, right) {
         super();
         if (typeof left === 'string') {

package/esm/sql-objects/operators/logical-operator.js

@@ -7,9 +7,9 @@ export const WrapOps = {};
 // noinspection RegExpUnnecessaryNonCapturingGroup
 const COMPARE_LEFT_PATTERN = /^([\w\\.$]+(?:\[])?) *(.*)$/;
 export class LogicalOperator extends Operator {
+    _items = [];
     constructor(...expressions) {
         super();
-        this._items = [];
         this.add(...expressions);
     }
     get _type() {

package/esm/sql-objects/operators/op-and.js

@@ -1,8 +1,5 @@
 import { OperatorType } from '../../enums.js';
 import { LogicalOperator } from './logical-operator.js';
 export class OpAnd extends LogicalOperator {
-    constructor() {
-        super(...arguments);
-        this._operatorType = OperatorType.and;
-    }
+    _operatorType = OperatorType.and;
 }

package/esm/sql-objects/operators/op-between.js

@@ -1,10 +1,10 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpBetween extends CompOperator {
+    _operatorType = OperatorType.between;
+    _symbol = 'between';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.between;
-        this._symbol = 'between';
         if (right && right[1] == null)
             right[1] = right[0];
     }

package/esm/sql-objects/operators/op-eq.js

@@ -1,9 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpEq extends CompOperator {
+    _operatorType = OperatorType.eq;
+    _symbol = '=';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.eq;
-        this._symbol = '=';
     }
 }

package/esm/sql-objects/operators/op-exists.js

@@ -2,10 +2,10 @@ import { OperatorType } from '../../enums.js';
 import { isSelectQuery } from '../../typeguards.js';
 import { CompOperator } from './comp-operator.js';
 export class OpExists extends CompOperator {
+    _operatorType = OperatorType.exists;
+    _symbol = 'exists';
     constructor(query) {
         super(query);
-        this._operatorType = OperatorType.exists;
-        this._symbol = 'exists';
         if (!(typeof query === 'object' && isSelectQuery(query))) {
             throw new TypeError('You must provide a SelectQuery in `exists()`');
         }

package/esm/sql-objects/operators/op-gt.js

@@ -1,9 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpGt extends CompOperator {
+    _operatorType = OperatorType.gt;
+    _symbol = '>';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.gt;
-        this._symbol = '>';
     }
 }

package/esm/sql-objects/operators/op-gte.js

@@ -1,9 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpGte extends CompOperator {
+    _operatorType = OperatorType.gte;
+    _symbol = '>=';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.gte;
-        this._symbol = '>=';
     }
 }

package/esm/sql-objects/operators/op-ilike.js

@@ -1,9 +1,6 @@
 import { OperatorType } from '../../enums.js';
 import { OpLike } from './op-like.js';
 export class OpILike extends OpLike {
-    constructor() {
-        super(...arguments);
-        this._operatorType = OperatorType.iLike;
-        this._symbol = 'ilike';
-    }
+    _operatorType = OperatorType.iLike;
+    _symbol = 'ilike';
 }

package/esm/sql-objects/operators/op-in.js

@@ -2,10 +2,10 @@ import { OperatorType } from '../../enums.js';
 import { isSerializable } from '../../typeguards.js';
 import { CompOperator } from './comp-operator.js';
 export class OpIn extends CompOperator {
+    _operatorType = OperatorType.in;
+    _symbol = 'in';
     constructor(left, right) {
         super(left, Array.isArray(right) || isSerializable(right) ? right : [right]);
-        this._operatorType = OperatorType.in;
-        this._symbol = 'in';
     }
     _serialize(ctx) {
         if (Array.isArray(this._right) && !this._right.length)

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

@@ -1,9 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpIsNot extends CompOperator {
+    _operatorType = OperatorType.isNot;
+    _symbol = 'is not';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.isNot;
-        this._symbol = 'is not';
     }
 }

package/esm/sql-objects/operators/op-is.js

@@ -1,9 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpIs extends CompOperator {
+    _operatorType = OperatorType.is;
+    _symbol = 'is';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.is;
-        this._symbol = 'is';
     }
 }

package/esm/sql-objects/operators/op-like.js

@@ -1,10 +1,10 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpLike extends CompOperator {
+    _operatorType = OperatorType.like;
+    _symbol = 'like';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.like;
-        this._symbol = 'like';
     }
     __serialize(ctx, o) {
         if (!o.right.expression)

package/esm/sql-objects/operators/op-lt.js

@@ -1,9 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpLt extends CompOperator {
+    _operatorType = OperatorType.lt;
+    _symbol = '<';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.lt;
-        this._symbol = '<';
     }
 }

package/esm/sql-objects/operators/op-lte.js

@@ -1,9 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpLte extends CompOperator {
+    _operatorType = OperatorType.lte;
+    _symbol = '<=';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.lte;
-        this._symbol = '<=';
     }
 }

package/esm/sql-objects/operators/op-ne.js

@@ -1,9 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { CompOperator } from './comp-operator.js';
 export class OpNe extends CompOperator {
+    _operatorType = OperatorType.ne;
+    _symbol = '!=';
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.ne;
-        this._symbol = '!=';
     }
 }

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

@@ -1,9 +1,6 @@
 import { OperatorType } from '../../enums.js';
 import { OpBetween } from './op-between.js';
 export class OpNotBetween extends OpBetween {
-    constructor() {
-        super(...arguments);
-        this._operatorType = OperatorType.notBetween;
-        this._symbol = 'not between';
-    }
+    _operatorType = OperatorType.notBetween;
+    _symbol = 'not between';
 }

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

@@ -1,9 +1,6 @@
 import { OperatorType } from '../../enums.js';
 import { OpExists } from './op-exists.js';
 export class OpNotExists extends OpExists {
-    constructor() {
-        super(...arguments);
-        this._operatorType = OperatorType.notExists;
-        this._symbol = 'not exists';
-    }
+    _operatorType = OperatorType.notExists;
+    _symbol = 'not exists';
 }

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

@@ -1,9 +1,6 @@
 import { OperatorType } from '../../enums.js';
 import { OpILike } from './op-ilike.js';
 export class OpNotILike extends OpILike {
-    constructor() {
-        super(...arguments);
-        this._operatorType = OperatorType.notILike;
-        this._symbol = 'not ilike';
-    }
+    _operatorType = OperatorType.notILike;
+    _symbol = 'not ilike';
 }