@sqb/builder 4.14.1 → 4.15.0

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

@@ -1,12 +1,15 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-export class MinStatement extends Serializable {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinStatement = void 0;
+const enums_js_1 = require("../enums.js");
+const serializable_js_1 = require("../serializable.js");
+class MinStatement extends serializable_js_1.Serializable {
     constructor(expression) {
         super();
         this._expression = expression;
     }
     get _type() {
-        return SerializationType.MIN_STATEMENT;
+        return enums_js_1.SerializationType.MIN_STATEMENT;
     }
     /**
      * Sets alias to case expression.
@@ -32,3 +35,4 @@ export class MinStatement extends Serializable {
         return 'min(' + o + ')' + (this._alias ? ' ' + this._alias : '');
     }
 }
+exports.MinStatement = MinStatement;

package/esm/sql-objects/operator.js

@@ -1,3 +1,7 @@
-import { Serializable } from '../serializable.js';
-export class Operator extends Serializable {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operator = void 0;
+const serializable_js_1 = require("../serializable.js");
+class Operator extends serializable_js_1.Serializable {
 }
+exports.Operator = Operator;

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

@@ -1,11 +1,14 @@
-import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-import { Param } from '../../sqlobject.initializers.js';
-import { FieldExpression } from '../field-expression.js';
-import { Operator } from '../operator.js';
-import { ParamExpression } from '../param-expression.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompOperator = void 0;
+const enums_js_1 = require("../../enums.js");
+const serializable_js_1 = require("../../serializable.js");
+const sqlobject_initializers_js_1 = require("../../sqlobject.initializers.js");
+const field_expression_js_1 = require("../field-expression.js");
+const operator_js_1 = require("../operator.js");
+const param_expression_js_1 = require("../param-expression.js");
 const EXPRESSION_PATTERN = /^([\w\\.$]+)(\[])?/;
-export class CompOperator extends Operator {
+class CompOperator extends operator_js_1.Operator {
     constructor(left, right) {
         super();
         if (typeof left === 'string') {
@@ -20,7 +23,7 @@ export class CompOperator extends Operator {
         this._right = right;
     }
     get _type() {
-        return SerializationType.COMPARISON_EXPRESSION;
+        return enums_js_1.SerializationType.COMPARISON_EXPRESSION;
     }
     _serialize(ctx) {
         const left = this.__serializeItem(ctx, this._left);
@@ -36,23 +39,23 @@ export class CompOperator extends Operator {
         return this.__serialize(ctx, o);
     }
     __serializeItem(ctx, x, isRight) {
-        if (ctx.strictParams && !(x instanceof Serializable) && (typeof x !== 'string' || isRight)) {
+        if (ctx.strictParams && !(x instanceof serializable_js_1.Serializable) && (typeof x !== 'string' || isRight)) {
             ctx.strictParamGenId = ctx.strictParamGenId || 0;
             const name = 'P$_' + ++ctx.strictParamGenId;
             ctx.params = ctx.params || {};
             ctx.params[name] = x;
-            x = Param(name);
+            x = (0, sqlobject_initializers_js_1.Param)(name);
         }
-        if (x instanceof Serializable) {
+        if (x instanceof serializable_js_1.Serializable) {
             const expression = ctx.anyToSQL(x);
             const result = {
                 expression,
             };
-            if (x instanceof FieldExpression) {
+            if (x instanceof field_expression_js_1.FieldExpression) {
                 result.dataType = result._dataType;
                 result.isArray = x._isArray;
             }
-            if (x instanceof ParamExpression) {
+            if (x instanceof param_expression_js_1.ParamExpression) {
                 let value = ctx.params ? ctx.params[x._name] : undefined;
                 if (x._isArray && value != null)
                     value = [value];
@@ -76,3 +79,4 @@ export class CompOperator extends Operator {
         return o.left.expression + ' ' + o.symbol + ' ' + o.right.expression;
     }
 }
+exports.CompOperator = CompOperator;

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

@@ -1,19 +1,23 @@
-import isPlainObject from 'putil-isplainobject';
-import { SerializationType } from '../../enums.js';
-import { printArray } from '../../helpers.js';
-import { isCompOperator, isLogicalOperator, isNotOperator, isRawStatement } from '../../typeguards.js';
-import { Operator } from '../operator.js';
-export const WrapOps = {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicalOperator = exports.WrapOps = void 0;
+const tslib_1 = require("tslib");
+const putil_isplainobject_1 = tslib_1.__importDefault(require("putil-isplainobject"));
+const enums_js_1 = require("../../enums.js");
+const helpers_js_1 = require("../../helpers.js");
+const typeguards_js_1 = require("../../typeguards.js");
+const operator_js_1 = require("../operator.js");
+exports.WrapOps = {};
 // noinspection RegExpUnnecessaryNonCapturingGroup
 const COMPARE_LEFT_PATTERN = /^([\w\\.$]+(?:\[])?) *(.*)$/;
-export class LogicalOperator extends Operator {
+class LogicalOperator extends operator_js_1.Operator {
     constructor(...expressions) {
         super();
         this._items = [];
         this.add(...expressions);
     }
     get _type() {
-        return SerializationType.LOGICAL_EXPRESSION;
+        return enums_js_1.SerializationType.LOGICAL_EXPRESSION;
     }
     /**
      * Adds operator(s) to item list
@@ -22,13 +26,13 @@ export class LogicalOperator extends Operator {
         for (const item of expressions) {
             if (!item)
                 continue;
-            if (isLogicalOperator(item)) {
+            if ((0, typeguards_js_1.isLogicalOperator)(item)) {
                 this._items.push(item);
             }
-            else if (isRawStatement(item) || isCompOperator(item) || isNotOperator(item)) {
+            else if ((0, typeguards_js_1.isRawStatement)(item) || (0, typeguards_js_1.isCompOperator)(item) || (0, typeguards_js_1.isNotOperator)(item)) {
                 this._items.push(item);
             }
-            else if (isPlainObject(item)) {
+            else if ((0, putil_isplainobject_1.default)(item)) {
                 this.add(...this._wrapObject(item));
             }
             else
@@ -44,8 +48,8 @@ export class LogicalOperator extends Operator {
             if (s)
                 arr.push(s);
         }
-        return ctx.serialize(SerializationType.LOGICAL_EXPRESSION, arr, () => {
-            const s = printArray(arr, ' ' + String(this._operatorType));
+        return ctx.serialize(enums_js_1.SerializationType.LOGICAL_EXPRESSION, arr, () => {
+            const s = (0, helpers_js_1.printArray)(arr, ' ' + String(this._operatorType));
             return s.indexOf('\n') > 0 ? s.replace('\n', '\n\t') + '\b' : s;
         });
     }
@@ -56,19 +60,19 @@ export class LogicalOperator extends Operator {
             let op;
             const v = obj[n];
             if (['and', 'or'].includes(n.toLowerCase())) {
-                op = WrapOps[n.toLowerCase()];
+                op = exports.WrapOps[n.toLowerCase()];
                 if (!op)
                     throw new Error(`Unknown operator "${n}"`);
                 result.push(Array.isArray(v) ? op(...v) : op(v));
                 continue;
             }
             if (['exists', '!exists'].includes(n))
-                result.push(WrapOps[n](obj[n]));
+                result.push(exports.WrapOps[n](obj[n]));
             else {
                 const m = n.match(COMPARE_LEFT_PATTERN);
                 if (!m)
                     throw new TypeError(`"${n}" is not a valid expression definition`);
-                op = WrapOps[m[2] || 'eq'];
+                op = exports.WrapOps[m[2] || 'eq'];
                 if (!op)
                     throw new Error(`Unknown operator "${m[2]}"`);
                 result.push(op(m[1], obj[n]));
@@ -77,3 +81,4 @@ export class LogicalOperator extends Operator {
         return result;
     }
 }
+exports.LogicalOperator = LogicalOperator;

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

@@ -1,8 +1,12 @@
-import { OperatorType } from '../../enums.js';
-import { LogicalOperator } from './logical-operator.js';
-export class OpAnd extends LogicalOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpAnd = void 0;
+const enums_js_1 = require("../../enums.js");
+const logical_operator_js_1 = require("./logical-operator.js");
+class OpAnd extends logical_operator_js_1.LogicalOperator {
     constructor() {
         super(...arguments);
-        this._operatorType = OperatorType.and;
+        this._operatorType = enums_js_1.OperatorType.and;
     }
 }
+exports.OpAnd = OpAnd;

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

@@ -1,9 +1,12 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpBetween extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpBetween = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpBetween extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.between;
+        this._operatorType = enums_js_1.OperatorType.between;
         this._symbol = 'between';
         if (right && right[1] == null)
             right[1] = right[0];
@@ -25,3 +28,4 @@ export class OpBetween extends CompOperator {
         return o.left.expression + ' ' + o.symbol + ' ' + o.right[0].expression + ' and ' + o.right[1].expression;
     }
 }
+exports.OpBetween = OpBetween;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpEq extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpEq = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpEq extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.eq;
+        this._operatorType = enums_js_1.OperatorType.eq;
         this._symbol = '=';
     }
 }
+exports.OpEq = OpEq;

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

@@ -1,12 +1,15 @@
-import { OperatorType } from '../../enums.js';
-import { isSelectQuery } from '../../typeguards.js';
-import { CompOperator } from './comp-operator.js';
-export class OpExists extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpExists = void 0;
+const enums_js_1 = require("../../enums.js");
+const typeguards_js_1 = require("../../typeguards.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpExists extends comp_operator_js_1.CompOperator {
     constructor(query) {
         super(query);
-        this._operatorType = OperatorType.exists;
+        this._operatorType = enums_js_1.OperatorType.exists;
         this._symbol = 'exists';
-        if (!(typeof query === 'object' && isSelectQuery(query))) {
+        if (!(typeof query === 'object' && (0, typeguards_js_1.isSelectQuery)(query))) {
             throw new TypeError('You must provide a SelectQuery in `exists()`');
         }
     }
@@ -25,3 +28,4 @@ export class OpExists extends CompOperator {
         return o.left.expression ? o.symbol + ' ' + o.left.expression : '';
     }
 }
+exports.OpExists = OpExists;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpGt extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpGt = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpGt extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.gt;
+        this._operatorType = enums_js_1.OperatorType.gt;
         this._symbol = '>';
     }
 }
+exports.OpGt = OpGt;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpGte extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpGte = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpGte extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.gte;
+        this._operatorType = enums_js_1.OperatorType.gte;
         this._symbol = '>=';
     }
 }
+exports.OpGte = OpGte;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { OpLike } from './op-like.js';
-export class OpILike extends OpLike {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpILike = void 0;
+const enums_js_1 = require("../../enums.js");
+const op_like_js_1 = require("./op-like.js");
+class OpILike extends op_like_js_1.OpLike {
     constructor() {
         super(...arguments);
-        this._operatorType = OperatorType.iLike;
+        this._operatorType = enums_js_1.OperatorType.iLike;
         this._symbol = 'ilike';
     }
 }
+exports.OpILike = OpILike;

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

@@ -1,10 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { isSerializable } from '../../typeguards.js';
-import { CompOperator } from './comp-operator.js';
-export class OpIn extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpIn = void 0;
+const enums_js_1 = require("../../enums.js");
+const typeguards_js_1 = require("../../typeguards.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpIn extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
-        super(left, Array.isArray(right) || isSerializable(right) ? right : [right]);
-        this._operatorType = OperatorType.in;
+        super(left, Array.isArray(right) || (0, typeguards_js_1.isSerializable)(right) ? right : [right]);
+        this._operatorType = enums_js_1.OperatorType.in;
         this._symbol = 'in';
     }
     _serialize(ctx) {
@@ -13,3 +16,4 @@ export class OpIn extends CompOperator {
         return super._serialize(ctx);
     }
 }
+exports.OpIn = OpIn;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpIsNot extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpIsNot = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpIsNot extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.isNot;
+        this._operatorType = enums_js_1.OperatorType.isNot;
         this._symbol = 'is not';
     }
 }
+exports.OpIsNot = OpIsNot;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpIs extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpIs = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpIs extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.is;
+        this._operatorType = enums_js_1.OperatorType.is;
         this._symbol = 'is';
     }
 }
+exports.OpIs = OpIs;

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

@@ -1,9 +1,12 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpLike extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpLike = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpLike extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.like;
+        this._operatorType = enums_js_1.OperatorType.like;
         this._symbol = 'like';
     }
     __serialize(ctx, o) {
@@ -14,3 +17,4 @@ export class OpLike extends CompOperator {
         return ctx.serialize(this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
     }
 }
+exports.OpLike = OpLike;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpLt extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpLt = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpLt extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.lt;
+        this._operatorType = enums_js_1.OperatorType.lt;
         this._symbol = '<';
     }
 }
+exports.OpLt = OpLt;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpLte extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpLte = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpLte extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.lte;
+        this._operatorType = enums_js_1.OperatorType.lte;
         this._symbol = '<=';
     }
 }
+exports.OpLte = OpLte;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { CompOperator } from './comp-operator.js';
-export class OpNe extends CompOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNe = void 0;
+const enums_js_1 = require("../../enums.js");
+const comp_operator_js_1 = require("./comp-operator.js");
+class OpNe extends comp_operator_js_1.CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = OperatorType.ne;
+        this._operatorType = enums_js_1.OperatorType.ne;
         this._symbol = '!=';
     }
 }
+exports.OpNe = OpNe;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { OpBetween } from './op-between.js';
-export class OpNotBetween extends OpBetween {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotBetween = void 0;
+const enums_js_1 = require("../../enums.js");
+const op_between_js_1 = require("./op-between.js");
+class OpNotBetween extends op_between_js_1.OpBetween {
     constructor() {
         super(...arguments);
-        this._operatorType = OperatorType.notBetween;
+        this._operatorType = enums_js_1.OperatorType.notBetween;
         this._symbol = 'not between';
     }
 }
+exports.OpNotBetween = OpNotBetween;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { OpExists } from './op-exists.js';
-export class OpNotExists extends OpExists {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotExists = void 0;
+const enums_js_1 = require("../../enums.js");
+const op_exists_js_1 = require("./op-exists.js");
+class OpNotExists extends op_exists_js_1.OpExists {
     constructor() {
         super(...arguments);
-        this._operatorType = OperatorType.notExists;
+        this._operatorType = enums_js_1.OperatorType.notExists;
         this._symbol = 'not exists';
     }
 }
+exports.OpNotExists = OpNotExists;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { OpILike } from './op-ilike.js';
-export class OpNotILike extends OpILike {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotILike = void 0;
+const enums_js_1 = require("../../enums.js");
+const op_ilike_js_1 = require("./op-ilike.js");
+class OpNotILike extends op_ilike_js_1.OpILike {
     constructor() {
         super(...arguments);
-        this._operatorType = OperatorType.notILike;
+        this._operatorType = enums_js_1.OperatorType.notILike;
         this._symbol = 'not ilike';
     }
 }
+exports.OpNotILike = OpNotILike;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { OpIn } from './op-in.js';
-export class OpNotIn extends OpIn {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotIn = void 0;
+const enums_js_1 = require("../../enums.js");
+const op_in_js_1 = require("./op-in.js");
+class OpNotIn extends op_in_js_1.OpIn {
     constructor() {
         super(...arguments);
-        this._operatorType = OperatorType.notIn;
+        this._operatorType = enums_js_1.OperatorType.notIn;
         this._symbol = 'not in';
     }
 }
+exports.OpNotIn = OpNotIn;

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

@@ -1,9 +1,13 @@
-import { OperatorType } from '../../enums.js';
-import { OpLike } from './op-like.js';
-export class OpNotLike extends OpLike {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotLike = void 0;
+const enums_js_1 = require("../../enums.js");
+const op_like_js_1 = require("./op-like.js");
+class OpNotLike extends op_like_js_1.OpLike {
     constructor() {
         super(...arguments);
-        this._operatorType = OperatorType.notLike;
+        this._operatorType = enums_js_1.OperatorType.notLike;
         this._symbol = 'not like';
     }
 }
+exports.OpNotLike = OpNotLike;

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

@@ -1,16 +1,20 @@
-import { OperatorType, SerializationType } from '../../enums.js';
-import { Operator } from '../operator.js';
-export class OpNot extends Operator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNot = void 0;
+const enums_js_1 = require("../../enums.js");
+const operator_js_1 = require("../operator.js");
+class OpNot extends operator_js_1.Operator {
     constructor(expression) {
         super();
-        this._operatorType = OperatorType.not;
+        this._operatorType = enums_js_1.OperatorType.not;
         this._expression = expression;
     }
     get _type() {
-        return SerializationType.NEGATIVE_EXPRESSION;
+        return enums_js_1.SerializationType.NEGATIVE_EXPRESSION;
     }
     _serialize(ctx) {
         const expression = ctx.anyToSQL(this._expression);
         return ctx.serialize(this._type, expression, () => (expression ? 'not ' + expression : ''));
     }
 }
+exports.OpNot = OpNot;

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

@@ -1,8 +1,12 @@
-import { OperatorType } from '../../enums.js';
-import { LogicalOperator } from './logical-operator.js';
-export class OpOr extends LogicalOperator {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpOr = void 0;
+const enums_js_1 = require("../../enums.js");
+const logical_operator_js_1 = require("./logical-operator.js");
+class OpOr extends logical_operator_js_1.LogicalOperator {
     constructor() {
         super(...arguments);
-        this._operatorType = OperatorType.or;
+        this._operatorType = enums_js_1.OperatorType.or;
     }
 }
+exports.OpOr = OpOr;