@sqb/builder 4.9.1 → 4.10.0

package/esm/query/query.js

@@ -4,7 +4,6 @@ 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,7 +3,6 @@ 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,16 +9,6 @@ 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/update-query.js

@@ -5,9 +5,6 @@ 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 || !(typeof tableName === 'string' || isRawStatement(tableName)))

package/esm/serialize-context.js

@@ -3,29 +3,19 @@ import { serializers } 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 {
-    _field = '';
-    _schema;
-    _table;
-    _descending;
+    constructor() {
+        super(...arguments);
+        this._field = '';
+    }
 }

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

@@ -2,10 +2,6 @@ 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,8 +1,6 @@
 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,7 +1,6 @@
 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,6 +1,3 @@
 import { Serializable } from '../serializable.js';
 export class Expression extends Serializable {
-    _dataType;
-    _isArray;
-    _isDataSet;
 }

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

@@ -2,7 +2,6 @@ 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,11 +4,9 @@ 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) || isTableName(table) ||
             typeof table === 'string'))

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

@@ -1,8 +1,6 @@
 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,8 +1,6 @@
 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,8 +1,6 @@
 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,10 +6,6 @@ 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,5 +1,8 @@
 import { OperatorType } from '../../enums.js';
 import { LogicalOperator } from './logical-operator.js';
 export class OpAnd extends LogicalOperator {
-    _operatorType = OperatorType.and;
+    constructor() {
+        super(...arguments);
+        this._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,6 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { OpLike } from './op-like.js';
 export class OpILike extends OpLike {
-    _operatorType = OperatorType.iLike;
-    _symbol = 'ilike';
+    constructor() {
+        super(...arguments);
+        this._operatorType = OperatorType.iLike;
+        this._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,6 +1,9 @@
 import { OperatorType } from '../../enums.js';
 import { OpBetween } from './op-between.js';
 export class OpNotBetween extends OpBetween {
-    _operatorType = OperatorType.notBetween;
-    _symbol = 'not between';
+    constructor() {
+        super(...arguments);
+        this._operatorType = OperatorType.notBetween;
+        this._symbol = 'not between';
+    }
 }

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

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

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

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

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

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

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

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

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

@@ -1,10 +1,9 @@
 import { OperatorType, SerializationType } from '../../enums.js';
 import { Operator } from '../operator.js';
 export class OpNot extends Operator {
-    _operatorType = OperatorType.not;
-    _expression;
     constructor(expression) {
         super();
+        this._operatorType = OperatorType.not;
         this._expression = expression;
     }
     get _type() {

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

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

package/esm/sql-objects/order-column.js

@@ -2,7 +2,6 @@ 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);

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

@@ -1,9 +1,6 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 export class ParamExpression extends Serializable {
-    _name;
-    _dataType;
-    _isArray;
     constructor(arg) {
         super();
         if (typeof arg === 'object') {

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

@@ -1,7 +1,6 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 export class RawStatement extends Serializable {
-    _text;
     constructor(str) {
         super();
         this._text = str;

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

@@ -2,7 +2,6 @@ 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);

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

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

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

@@ -4,10 +4,6 @@ import { Serializable } from '../serializable.js';
 import { FieldExpression } from './field-expression.js';
 import { OrderColumn } from './order-column.js';
 export class StringAGGStatement extends Serializable {
-    _field;
-    _delimiter;
-    _orderBy;
-    _alias;
     constructor(field, delimiter) {
         super();
         this._field = typeof field === 'string' ? new FieldExpression(field) : field;

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

@@ -1,9 +1,6 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 export class TableName extends Serializable {
-    schema;
-    table;
-    alias;
     constructor(tableName) {
         super();
         const m = tableName.match(/^(?:([a-zA-Z][\w$]*)\.)? *([a-zA-Z][\w$]*) *(?:as)? *(\w+)?$/);

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

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/builder",
   "description": "Extensible multi-dialect SQL query builder written with TypeScript",
-  "version": "4.9.1",
+  "version": "4.10.0",
   "author": "Panates",
   "private": false,
   "contributors": [
@@ -14,6 +14,10 @@
     "url": "https://github.com/sqbjs/sqb.git",
     "directory": "packages/builder"
   },
+  "type": "module",
+  "module": "./esm/index.js",
+  "main": "./cjs/index.js",
+  "types": "./types/index.d.ts",
   "scripts": {
     "compile": "tsc",
     "prebuild": "npm run lint && npm run clean",
@@ -33,21 +37,11 @@
     "debug": "^4.3.4",
     "putil-flattentext": "^2.1.1",
     "putil-isplainobject": "^1.1.5",
-    "putil-merge": "^3.10.3",
+    "putil-merge": "^3.12.1",
     "putil-varhelpers": "^1.6.5"
   },
   "devDependencies": {
-    "@types/debug": "^4.1.8"
-  },
-  "type": "module",
-  "types": "esm/index.d.ts",
-  "exports": {
-    ".": {
-      "require": "./cjs/index.js",
-      "default": "./esm/index.js"
-    },
-    "./cjs": "./cjs/index.js",
-    "./esm": "./esm/index.js"
+    "@types/debug": "^4.1.12"
   },
   "engines": {
     "node": ">=16.0",