@sqb/builder 4.15.0 → 4.16.1

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

@@ -1,15 +1,12 @@
-"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 {
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class MinStatement extends Serializable {
     constructor(expression) {
         super();
         this._expression = expression;
     }
     get _type() {
-        return enums_js_1.SerializationType.MIN_STATEMENT;
+        return SerializationType.MIN_STATEMENT;
     }
     /**
      * Sets alias to case expression.
@@ -35,4 +32,3 @@ class MinStatement extends serializable_js_1.Serializable {
         return 'min(' + o + ')' + (this._alias ? ' ' + this._alias : '');
     }
 }
-exports.MinStatement = MinStatement;

package/esm/sql-objects/operator.js

@@ -1,7 +1,3 @@
-"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 {
+import { Serializable } from '../serializable.js';
+export class Operator extends Serializable {
 }
-exports.Operator = Operator;

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

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

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

@@ -1,23 +1,19 @@
-"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 = {};
+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 = {};
 // noinspection RegExpUnnecessaryNonCapturingGroup
 const COMPARE_LEFT_PATTERN = /^([\w\\.$]+(?:\[])?) *(.*)$/;
-class LogicalOperator extends operator_js_1.Operator {
+export class LogicalOperator extends Operator {
     constructor(...expressions) {
         super();
         this._items = [];
         this.add(...expressions);
     }
     get _type() {
-        return enums_js_1.SerializationType.LOGICAL_EXPRESSION;
+        return SerializationType.LOGICAL_EXPRESSION;
     }
     /**
      * Adds operator(s) to item list
@@ -26,13 +22,13 @@ class LogicalOperator extends operator_js_1.Operator {
         for (const item of expressions) {
             if (!item)
                 continue;
-            if ((0, typeguards_js_1.isLogicalOperator)(item)) {
+            if (isLogicalOperator(item)) {
                 this._items.push(item);
             }
-            else if ((0, typeguards_js_1.isRawStatement)(item) || (0, typeguards_js_1.isCompOperator)(item) || (0, typeguards_js_1.isNotOperator)(item)) {
+            else if (isRawStatement(item) || isCompOperator(item) || isNotOperator(item)) {
                 this._items.push(item);
             }
-            else if ((0, putil_isplainobject_1.default)(item)) {
+            else if (isPlainObject(item)) {
                 this.add(...this._wrapObject(item));
             }
             else
@@ -48,8 +44,8 @@ class LogicalOperator extends operator_js_1.Operator {
             if (s)
                 arr.push(s);
         }
-        return ctx.serialize(enums_js_1.SerializationType.LOGICAL_EXPRESSION, arr, () => {
-            const s = (0, helpers_js_1.printArray)(arr, ' ' + String(this._operatorType));
+        return ctx.serialize(SerializationType.LOGICAL_EXPRESSION, arr, () => {
+            const s = printArray(arr, ' ' + String(this._operatorType));
             return s.indexOf('\n') > 0 ? s.replace('\n', '\n\t') + '\b' : s;
         });
     }
@@ -60,19 +56,19 @@ class LogicalOperator extends operator_js_1.Operator {
             let op;
             const v = obj[n];
             if (['and', 'or'].includes(n.toLowerCase())) {
-                op = exports.WrapOps[n.toLowerCase()];
+                op = 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(exports.WrapOps[n](obj[n]));
+                result.push(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 = exports.WrapOps[m[2] || 'eq'];
+                op = WrapOps[m[2] || 'eq'];
                 if (!op)
                     throw new Error(`Unknown operator "${m[2]}"`);
                 result.push(op(m[1], obj[n]));
@@ -81,4 +77,3 @@ class LogicalOperator extends operator_js_1.Operator {
         return result;
     }
 }
-exports.LogicalOperator = LogicalOperator;

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

@@ -1,12 +1,8 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { LogicalOperator } from './logical-operator.js';
+export class OpAnd extends LogicalOperator {
     constructor() {
         super(...arguments);
-        this._operatorType = enums_js_1.OperatorType.and;
+        this._operatorType = OperatorType.and;
     }
 }
-exports.OpAnd = OpAnd;

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

@@ -1,12 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpBetween extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.between;
+        this._operatorType = OperatorType.between;
         this._symbol = 'between';
         if (right && right[1] == null)
             right[1] = right[0];
@@ -28,4 +25,3 @@ class OpBetween extends comp_operator_js_1.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,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpEq extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.eq;
+        this._operatorType = OperatorType.eq;
         this._symbol = '=';
     }
 }
-exports.OpEq = OpEq;

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

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

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpGt extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.gt;
+        this._operatorType = OperatorType.gt;
         this._symbol = '>';
     }
 }
-exports.OpGt = OpGt;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpGte extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.gte;
+        this._operatorType = OperatorType.gte;
         this._symbol = '>=';
     }
 }
-exports.OpGte = OpGte;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { OpLike } from './op-like.js';
+export class OpILike extends OpLike {
     constructor() {
         super(...arguments);
-        this._operatorType = enums_js_1.OperatorType.iLike;
+        this._operatorType = OperatorType.iLike;
         this._symbol = 'ilike';
     }
 }
-exports.OpILike = OpILike;

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

@@ -1,13 +1,10 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { isSerializable } from '../../typeguards.js';
+import { CompOperator } from './comp-operator.js';
+export class OpIn extends CompOperator {
     constructor(left, right) {
-        super(left, Array.isArray(right) || (0, typeguards_js_1.isSerializable)(right) ? right : [right]);
-        this._operatorType = enums_js_1.OperatorType.in;
+        super(left, Array.isArray(right) || isSerializable(right) ? right : [right]);
+        this._operatorType = OperatorType.in;
         this._symbol = 'in';
     }
     _serialize(ctx) {
@@ -16,4 +13,3 @@ class OpIn extends comp_operator_js_1.CompOperator {
         return super._serialize(ctx);
     }
 }
-exports.OpIn = OpIn;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpIsNot extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.isNot;
+        this._operatorType = OperatorType.isNot;
         this._symbol = 'is not';
     }
 }
-exports.OpIsNot = OpIsNot;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpIs extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.is;
+        this._operatorType = OperatorType.is;
         this._symbol = 'is';
     }
 }
-exports.OpIs = OpIs;

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

@@ -1,12 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpLike extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.like;
+        this._operatorType = OperatorType.like;
         this._symbol = 'like';
     }
     __serialize(ctx, o) {
@@ -17,4 +14,3 @@ class OpLike extends comp_operator_js_1.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,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpLt extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.lt;
+        this._operatorType = OperatorType.lt;
         this._symbol = '<';
     }
 }
-exports.OpLt = OpLt;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpLte extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.lte;
+        this._operatorType = OperatorType.lte;
         this._symbol = '<=';
     }
 }
-exports.OpLte = OpLte;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { CompOperator } from './comp-operator.js';
+export class OpNe extends CompOperator {
     constructor(left, right) {
         super(left, right);
-        this._operatorType = enums_js_1.OperatorType.ne;
+        this._operatorType = OperatorType.ne;
         this._symbol = '!=';
     }
 }
-exports.OpNe = OpNe;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { OpBetween } from './op-between.js';
+export class OpNotBetween extends OpBetween {
     constructor() {
         super(...arguments);
-        this._operatorType = enums_js_1.OperatorType.notBetween;
+        this._operatorType = OperatorType.notBetween;
         this._symbol = 'not between';
     }
 }
-exports.OpNotBetween = OpNotBetween;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { OpExists } from './op-exists.js';
+export class OpNotExists extends OpExists {
     constructor() {
         super(...arguments);
-        this._operatorType = enums_js_1.OperatorType.notExists;
+        this._operatorType = OperatorType.notExists;
         this._symbol = 'not exists';
     }
 }
-exports.OpNotExists = OpNotExists;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { OpILike } from './op-ilike.js';
+export class OpNotILike extends OpILike {
     constructor() {
         super(...arguments);
-        this._operatorType = enums_js_1.OperatorType.notILike;
+        this._operatorType = OperatorType.notILike;
         this._symbol = 'not ilike';
     }
 }
-exports.OpNotILike = OpNotILike;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { OpIn } from './op-in.js';
+export class OpNotIn extends OpIn {
     constructor() {
         super(...arguments);
-        this._operatorType = enums_js_1.OperatorType.notIn;
+        this._operatorType = OperatorType.notIn;
         this._symbol = 'not in';
     }
 }
-exports.OpNotIn = OpNotIn;

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

@@ -1,13 +1,9 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { OpLike } from './op-like.js';
+export class OpNotLike extends OpLike {
     constructor() {
         super(...arguments);
-        this._operatorType = enums_js_1.OperatorType.notLike;
+        this._operatorType = OperatorType.notLike;
         this._symbol = 'not like';
     }
 }
-exports.OpNotLike = OpNotLike;

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

@@ -1,20 +1,16 @@
-"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 {
+import { OperatorType, SerializationType } from '../../enums.js';
+import { Operator } from '../operator.js';
+export class OpNot extends Operator {
     constructor(expression) {
         super();
-        this._operatorType = enums_js_1.OperatorType.not;
+        this._operatorType = OperatorType.not;
         this._expression = expression;
     }
     get _type() {
-        return enums_js_1.SerializationType.NEGATIVE_EXPRESSION;
+        return 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,12 +1,8 @@
-"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 {
+import { OperatorType } from '../../enums.js';
+import { LogicalOperator } from './logical-operator.js';
+export class OpOr extends LogicalOperator {
     constructor() {
         super(...arguments);
-        this._operatorType = enums_js_1.OperatorType.or;
+        this._operatorType = OperatorType.or;
     }
 }
-exports.OpOr = OpOr;