@webda/ql 4.0.0-beta.2 → 4.0.0-beta.3

package/lib/query.spec.js

@@ -1,12 +1,44 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
 };
-import { suite, test } from "@testdeck/mocha";
+import { suite, test } from "@webda/test";
 import * as assert from "assert";
 import * as WebdaQL from "./query.js";
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { ParseTreeWalker } from "antlr4ts/tree/index.js";
+import { WebdaQLLexer } from "./WebdaQLLexer.js";
+import { WebdaQLParserParser } from "./WebdaQLParserParser.js";
 const targets = [
     {
         test: {
@@ -18,197 +50,563 @@ const targets = [
         attr5: ["test", "plip"]
     }
 ];
-let QueryTest = class QueryTest {
-    dev() {
-        const queryMap = {
-            "a = 1 AND b = 2 AND c = 3 AND d = 4": "a = 1 AND b = 2 AND c = 3 AND d = 4",
-            "a = 1 AND (b = 2 AND c = 3) AND d = 4": "a = 1 AND b = 2 AND c = 3 AND d = 4",
-            "a = 1 AND ((b = 2 AND c = 3) AND d = 4)": "a = 1 AND b = 2 AND c = 3 AND d = 4",
-            "a = 1 AND ((b = 2 OR c = 3) AND d = 4)": "a = 1 AND ( b = 2 OR c = 3 ) AND d = 4",
-            "a = 1 AND (b = 2) AND c = 3 AND d = 4": "a = 1 AND b = 2 AND c = 3 AND d = 4",
-            "a = 1 OR b = 2 OR c = 3 OR d = 4": "a = 1 OR b = 2 OR c = 3 OR d = 4",
-            'a = 1 AND (b = 2 OR c = 3) AND d = "plop"': 'a = 1 AND ( b = 2 OR c = 3 ) AND d = "plop"',
-            "a = 1 OR b = TRUE AND c = FALSE OR d = 'plop'": 'a = 1 OR ( b = TRUE AND c = FALSE ) OR d = "plop"',
-            "test.attr1 = 'plop'": true,
-            "test.attr1 = 'plop2'": false,
-            "test.attr1 = 'plop' AND attr2 IN ['TEST', TRUE, 3]": 'test.attr1 = "plop" AND attr2 IN ["TEST", TRUE, 3]',
-            "(test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK']) OR attr3 <= 12": null,
-            "test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK'] OR attr3 <= 12 AND attr4 = 'ok'": null,
-            "test.attr1 = 'plop' AND (attr2 IN ['TEST', 'OK'] OR attr3 <= 12) AND attr4 = 'ok'": null,
-            "test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK'] AND attr3 <= 12 AND attr4 = 'ok'": null,
-            "a = 1 OR b = 2": null,
-            "a = 1 AND b = 2 OR c = 3 AND d = 4": null,
-            "a = 1 AND b = 2 OR c = 3 AND d = 4 OR e = 5 AND f = 6": null,
-            "a = 1 AND (b = 2 OR (c = 3 AND (d = 4 OR e = 5))) AND f = 6": null,
-            "": true,
-            'test.attr1 LIKE "pl_p"': true,
-            'test.attr1 LIKE "pl__p"': false,
-            'attr3 LIKE "1_"': true,
-            "attr3 >= 12": true,
-            "attr3 <= 12": false,
-            "attr3 != 12": true,
-            "attr3 > 12": true,
-            "attr3 < 13": false,
-            "attr5 CONTAINS 'test'": true,
-            "attr5 CONTAINS 'test2'": false,
-            'test.attr1 LIKE "pl%"': true,
-            "a = 1 AND b=2 OR a=1 AND b=3": "( a = 1 AND b = 2 ) OR ( a = 1 AND b = 3 )", // TODO Might want to auto-simplify to a = 1 AND b IN [2,3]
-            "a = 1 ORDER BY a": null,
-            "a = 1 ORDER BY a DESC, b ASC": null,
-            "(attr3 >= 12)": true
-        };
-        for (const query in queryMap) {
-            const validator = new WebdaQL.QueryValidator(query);
-            assert.strictEqual(validator.displayTree().replace(/\s/g, ""), query.replace(/\s/g, ""));
-            if (typeof queryMap[query] === "string") {
-                assert.strictEqual(validator.getExpression().toString(), queryMap[query], `Failed optimization of query: ${query} => ${validator.getExpression().toString()}`);
+let QueryTest = (() => {
+    let _classDecorators = [suite];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _instanceExtraInitializers = [];
+    let _dev_decorators;
+    let _prependQuery_decorators;
+    let _likeRegexp_decorators;
+    let _simple_decorators;
+    let _contains_decorators;
+    let _andQuery_decorators;
+    let _orQuery_decorators;
+    let _multipleQuery_decorators;
+    let _unsanitize_decorators;
+    let _limitOffset_decorators;
+    let _badQuery_decorators;
+    let _setters_decorators;
+    let _parse_decorators;
+    let _partialValidator_decorators;
+    let _mergeTypeMismatch_decorators;
+    let _getOffsetFallback_decorators;
+    let _expressionToString_decorators;
+    let _hasCondition_decorators;
+    let _queryValidatorToString_decorators;
+    let _complexQueries_decorators;
+    let _containsNonArray_decorators;
+    let _likeOnNonString_decorators;
+    let _likeOnMissingAttribute_decorators;
+    let _quotedLiterals_decorators;
+    let _lexerIntrospection_decorators;
+    let _parserIntrospection_decorators;
+    let _listenerWalk_decorators;
+    let _contextAccessors_decorators;
+    let _setterAssignment_decorators;
+    let _mergePreservesExistingMeta_decorators;
+    let _booleanLiterals_decorators;
+    let _booleanLiteralsFold_decorators;
+    let _bareAtomsAreSyntaxErrors_decorators;
+    let _partialValidatorWithBooleans_decorators;
+    let _isNull_decorators;
+    let _isNullToString_decorators;
+    let _isNullPartial_decorators;
+    var QueryTest = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _dev_decorators = [test];
+            _prependQuery_decorators = [test];
+            _likeRegexp_decorators = [test];
+            _simple_decorators = [test];
+            _contains_decorators = [test];
+            _andQuery_decorators = [test];
+            _orQuery_decorators = [test];
+            _multipleQuery_decorators = [test];
+            _unsanitize_decorators = [test];
+            _limitOffset_decorators = [test];
+            _badQuery_decorators = [test];
+            _setters_decorators = [test];
+            _parse_decorators = [test];
+            _partialValidator_decorators = [test];
+            _mergeTypeMismatch_decorators = [test];
+            _getOffsetFallback_decorators = [test];
+            _expressionToString_decorators = [test];
+            _hasCondition_decorators = [test];
+            _queryValidatorToString_decorators = [test];
+            _complexQueries_decorators = [test];
+            _containsNonArray_decorators = [test];
+            _likeOnNonString_decorators = [test];
+            _likeOnMissingAttribute_decorators = [test];
+            _quotedLiterals_decorators = [test];
+            _lexerIntrospection_decorators = [test];
+            _parserIntrospection_decorators = [test];
+            _listenerWalk_decorators = [test];
+            _contextAccessors_decorators = [test];
+            _setterAssignment_decorators = [test];
+            _mergePreservesExistingMeta_decorators = [test];
+            _booleanLiterals_decorators = [test];
+            _booleanLiteralsFold_decorators = [test];
+            _bareAtomsAreSyntaxErrors_decorators = [test];
+            _partialValidatorWithBooleans_decorators = [test];
+            _isNull_decorators = [test];
+            _isNullToString_decorators = [test];
+            _isNullPartial_decorators = [test];
+            __esDecorate(this, null, _dev_decorators, { kind: "method", name: "dev", static: false, private: false, access: { has: obj => "dev" in obj, get: obj => obj.dev }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _prependQuery_decorators, { kind: "method", name: "prependQuery", static: false, private: false, access: { has: obj => "prependQuery" in obj, get: obj => obj.prependQuery }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _likeRegexp_decorators, { kind: "method", name: "likeRegexp", static: false, private: false, access: { has: obj => "likeRegexp" in obj, get: obj => obj.likeRegexp }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _simple_decorators, { kind: "method", name: "simple", static: false, private: false, access: { has: obj => "simple" in obj, get: obj => obj.simple }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _contains_decorators, { kind: "method", name: "contains", static: false, private: false, access: { has: obj => "contains" in obj, get: obj => obj.contains }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _andQuery_decorators, { kind: "method", name: "andQuery", static: false, private: false, access: { has: obj => "andQuery" in obj, get: obj => obj.andQuery }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _orQuery_decorators, { kind: "method", name: "orQuery", static: false, private: false, access: { has: obj => "orQuery" in obj, get: obj => obj.orQuery }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _multipleQuery_decorators, { kind: "method", name: "multipleQuery", static: false, private: false, access: { has: obj => "multipleQuery" in obj, get: obj => obj.multipleQuery }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _unsanitize_decorators, { kind: "method", name: "unsanitize", static: false, private: false, access: { has: obj => "unsanitize" in obj, get: obj => obj.unsanitize }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _limitOffset_decorators, { kind: "method", name: "limitOffset", static: false, private: false, access: { has: obj => "limitOffset" in obj, get: obj => obj.limitOffset }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _badQuery_decorators, { kind: "method", name: "badQuery", static: false, private: false, access: { has: obj => "badQuery" in obj, get: obj => obj.badQuery }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setters_decorators, { kind: "method", name: "setters", static: false, private: false, access: { has: obj => "setters" in obj, get: obj => obj.setters }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _parse_decorators, { kind: "method", name: "parse", static: false, private: false, access: { has: obj => "parse" in obj, get: obj => obj.parse }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _partialValidator_decorators, { kind: "method", name: "partialValidator", static: false, private: false, access: { has: obj => "partialValidator" in obj, get: obj => obj.partialValidator }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _mergeTypeMismatch_decorators, { kind: "method", name: "mergeTypeMismatch", static: false, private: false, access: { has: obj => "mergeTypeMismatch" in obj, get: obj => obj.mergeTypeMismatch }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getOffsetFallback_decorators, { kind: "method", name: "getOffsetFallback", static: false, private: false, access: { has: obj => "getOffsetFallback" in obj, get: obj => obj.getOffsetFallback }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _expressionToString_decorators, { kind: "method", name: "expressionToString", static: false, private: false, access: { has: obj => "expressionToString" in obj, get: obj => obj.expressionToString }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _hasCondition_decorators, { kind: "method", name: "hasCondition", static: false, private: false, access: { has: obj => "hasCondition" in obj, get: obj => obj.hasCondition }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _queryValidatorToString_decorators, { kind: "method", name: "queryValidatorToString", static: false, private: false, access: { has: obj => "queryValidatorToString" in obj, get: obj => obj.queryValidatorToString }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _complexQueries_decorators, { kind: "method", name: "complexQueries", static: false, private: false, access: { has: obj => "complexQueries" in obj, get: obj => obj.complexQueries }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _containsNonArray_decorators, { kind: "method", name: "containsNonArray", static: false, private: false, access: { has: obj => "containsNonArray" in obj, get: obj => obj.containsNonArray }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _likeOnNonString_decorators, { kind: "method", name: "likeOnNonString", static: false, private: false, access: { has: obj => "likeOnNonString" in obj, get: obj => obj.likeOnNonString }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _likeOnMissingAttribute_decorators, { kind: "method", name: "likeOnMissingAttribute", static: false, private: false, access: { has: obj => "likeOnMissingAttribute" in obj, get: obj => obj.likeOnMissingAttribute }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _quotedLiterals_decorators, { kind: "method", name: "quotedLiterals", static: false, private: false, access: { has: obj => "quotedLiterals" in obj, get: obj => obj.quotedLiterals }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _lexerIntrospection_decorators, { kind: "method", name: "lexerIntrospection", static: false, private: false, access: { has: obj => "lexerIntrospection" in obj, get: obj => obj.lexerIntrospection }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _parserIntrospection_decorators, { kind: "method", name: "parserIntrospection", static: false, private: false, access: { has: obj => "parserIntrospection" in obj, get: obj => obj.parserIntrospection }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listenerWalk_decorators, { kind: "method", name: "listenerWalk", static: false, private: false, access: { has: obj => "listenerWalk" in obj, get: obj => obj.listenerWalk }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _contextAccessors_decorators, { kind: "method", name: "contextAccessors", static: false, private: false, access: { has: obj => "contextAccessors" in obj, get: obj => obj.contextAccessors }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setterAssignment_decorators, { kind: "method", name: "setterAssignment", static: false, private: false, access: { has: obj => "setterAssignment" in obj, get: obj => obj.setterAssignment }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _mergePreservesExistingMeta_decorators, { kind: "method", name: "mergePreservesExistingMeta", static: false, private: false, access: { has: obj => "mergePreservesExistingMeta" in obj, get: obj => obj.mergePreservesExistingMeta }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _booleanLiterals_decorators, { kind: "method", name: "booleanLiterals", static: false, private: false, access: { has: obj => "booleanLiterals" in obj, get: obj => obj.booleanLiterals }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _booleanLiteralsFold_decorators, { kind: "method", name: "booleanLiteralsFold", static: false, private: false, access: { has: obj => "booleanLiteralsFold" in obj, get: obj => obj.booleanLiteralsFold }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _bareAtomsAreSyntaxErrors_decorators, { kind: "method", name: "bareAtomsAreSyntaxErrors", static: false, private: false, access: { has: obj => "bareAtomsAreSyntaxErrors" in obj, get: obj => obj.bareAtomsAreSyntaxErrors }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _partialValidatorWithBooleans_decorators, { kind: "method", name: "partialValidatorWithBooleans", static: false, private: false, access: { has: obj => "partialValidatorWithBooleans" in obj, get: obj => obj.partialValidatorWithBooleans }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _isNull_decorators, { kind: "method", name: "isNull", static: false, private: false, access: { has: obj => "isNull" in obj, get: obj => obj.isNull }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _isNullToString_decorators, { kind: "method", name: "isNullToString", static: false, private: false, access: { has: obj => "isNullToString" in obj, get: obj => obj.isNullToString }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _isNullPartial_decorators, { kind: "method", name: "isNullPartial", static: false, private: false, access: { has: obj => "isNullPartial" in obj, get: obj => obj.isNullPartial }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            QueryTest = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        dev() {
+            const queryMap = {
+                "a = 1 AND b = 2 AND c = 3 AND d = 4": "a = 1 AND b = 2 AND c = 3 AND d = 4",
+                "a = 1 AND (b = 2 AND c = 3) AND d = 4": "a = 1 AND b = 2 AND c = 3 AND d = 4",
+                "a = 1 AND ((b = 2 AND c = 3) AND d = 4)": "a = 1 AND b = 2 AND c = 3 AND d = 4",
+                "a = 1 AND ((b = 2 OR c = 3) AND d = 4)": "a = 1 AND ( b = 2 OR c = 3 ) AND d = 4",
+                "a = 1 AND (b = 2) AND c = 3 AND d = 4": "a = 1 AND b = 2 AND c = 3 AND d = 4",
+                "a = 1 OR b = 2 OR c = 3 OR d = 4": "a = 1 OR b = 2 OR c = 3 OR d = 4",
+                'a = 1 AND (b = 2 OR c = 3) AND d = "plop"': 'a = 1 AND ( b = 2 OR c = 3 ) AND d = "plop"',
+                "a = 1 OR b = TRUE AND c = FALSE OR d = 'plop'": 'a = 1 OR ( b = TRUE AND c = FALSE ) OR d = "plop"',
+                "test.attr1 = 'plop'": true,
+                "test.attr1 = 'plop2'": false,
+                "test.attr1 = 'plop' AND attr2 IN ['TEST', TRUE, 3]": 'test.attr1 = "plop" AND attr2 IN ["TEST", TRUE, 3]',
+                "(test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK']) OR attr3 <= 12": null,
+                "test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK'] OR attr3 <= 12 AND attr4 = 'ok'": null,
+                "test.attr1 = 'plop' AND (attr2 IN ['TEST', 'OK'] OR attr3 <= 12) AND attr4 = 'ok'": null,
+                "test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK'] AND attr3 <= 12 AND attr4 = 'ok'": null,
+                "a = 1 OR b = 2": null,
+                "a = 1 AND b = 2 OR c = 3 AND d = 4": null,
+                "a = 1 AND b = 2 OR c = 3 AND d = 4 OR e = 5 AND f = 6": null,
+                "a = 1 AND (b = 2 OR (c = 3 AND (d = 4 OR e = 5))) AND f = 6": null,
+                "": true,
+                'test.attr1 LIKE "pl_p"': true,
+                'test.attr1 LIKE "pl__p"': false,
+                'attr3 LIKE "1_"': true,
+                "attr3 >= 12": true,
+                "attr3 <= 12": false,
+                "attr3 != 12": true,
+                "attr3 > 12": true,
+                "attr3 < 13": false,
+                "attr5 CONTAINS 'test'": true,
+                "attr5 CONTAINS 'test2'": false,
+                'test.attr1 LIKE "pl%"': true,
+                "a = 1 AND b=2 OR a=1 AND b=3": "( a = 1 AND b = 2 ) OR ( a = 1 AND b = 3 )",
+                "a = 1 ORDER BY a": null,
+                "a = 1 ORDER BY a DESC, b ASC": null,
+                "(attr3 >= 12)": true
+            };
+            for (const query in queryMap) {
+                const validator = new WebdaQL.QueryValidator(query);
+                assert.strictEqual(validator.displayTree().replace(/\s/g, ""), query.replace(/\s/g, ""));
+                if (typeof queryMap[query] === "string") {
+                    assert.strictEqual(validator.getExpression().toString(), queryMap[query], `Failed optimization of query: ${query} => ${validator.getExpression().toString()}`);
+                }
+                else if (typeof queryMap[query] === "boolean") {
+                    assert.strictEqual(validator.eval(targets[0]), queryMap[query], `Failed query: ${query}`);
+                }
+                else {
+                    console.log("QUERY", query);
+                    console.log("OPTIMIZED QUERY", validator.getExpression().toString(), "=>", validator.eval(targets[0]));
+                }
             }
-            else if (typeof queryMap[query] === "boolean") {
-                assert.strictEqual(validator.eval(targets[0]), queryMap[query], `Failed query: ${query}`);
+        }
+        prependQuery() {
+            // merge method is tested through the prependQuery helper
+            const strictEqual = (arg1, arg2) => {
+                // Ensure it is parsable
+                new WebdaQL.QueryValidator(arg1);
+                assert.deepStrictEqual(arg1, arg2);
+            };
+            strictEqual(WebdaQL.PrependCondition("", "test='plop'"), 'test = "plop"');
+            strictEqual(WebdaQL.PrependCondition("test='plop'", ""), 'test = "plop"');
+            strictEqual(WebdaQL.PrependCondition("test='plip'", "test='plop'"), 'test = "plip" AND test = "plop"');
+            strictEqual(WebdaQL.PrependCondition("ORDER BY test", "test='plop'"), 'test = "plop" ORDER BY test ASC');
+            strictEqual(WebdaQL.PrependCondition("ORDER BY test LIMIT 100", "test='plop'"), 'test = "plop" ORDER BY test ASC LIMIT 100');
+            strictEqual(WebdaQL.PrependCondition("ORDER BY test DESC LIMIT 100", "test='plop'"), 'test = "plop" ORDER BY test DESC LIMIT 100');
+            strictEqual(WebdaQL.PrependCondition("test='plip' ORDER BY test ASC LIMIT 100", "test='plop'"), 'test = "plip" AND test = "plop" ORDER BY test ASC LIMIT 100');
+            strictEqual(WebdaQL.PrependCondition("test='plip' LIMIT 100", "test='plop'"), 'test = "plip" AND test = "plop" LIMIT 100');
+            strictEqual(WebdaQL.PrependCondition("test='plip' OFFSET 'test'", "test='plop'"), 'test = "plip" AND test = "plop" OFFSET "test"');
+            strictEqual(WebdaQL.PrependCondition("test='ORDER BY plop' OFFSET 'test'", "test='plop'"), 'test = "ORDER BY plop" AND test = "plop" OFFSET "test"');
+            strictEqual(WebdaQL.PrependCondition('test="ORDER BY plop" LIMIT 100', "test='plop'"), 'test = "ORDER BY plop" AND test = "plop" LIMIT 100');
+            // Composed ORDER BY
+            strictEqual(WebdaQL.PrependCondition('test="plop" ORDER BY ab ASC LIMIT 100', "ORDER BY forced DESC"), 'test = "plop" ORDER BY forced DESC, ab ASC LIMIT 100');
+            // Opposite ORDER BY
+            strictEqual(WebdaQL.PrependCondition('test="plop" ORDER BY forced ASC LIMIT 100', "ORDER BY forced DESC"), 'test = "plop" ORDER BY forced DESC LIMIT 100');
+            // Overwrite LIMIT
+            strictEqual(WebdaQL.PrependCondition('test="plop" ORDER BY forced ASC LIMIT 100', "LIMIT 5"), 'test = "plop" ORDER BY forced ASC LIMIT 5');
+            // Overwrite OFFSET
+            strictEqual(WebdaQL.PrependCondition('OFFSET "test"', "OFFSET 'plop'"), 'OFFSET "plop"');
+            strictEqual(WebdaQL.PrependCondition('plop = "ok"', "OFFSET 'plop'"), 'plop = "ok" OFFSET "plop"');
+        }
+        likeRegexp() {
+            assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("test"), /test/);
+            assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t_est"), /t.{1}est/);
+            assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("_test"), /.{1}test/);
+            assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t\\_est"), /t_est/);
+            assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t%est"), /t.*est/);
+            assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("%te?st"), /.*te\?st/);
+            assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t\\%est"), /t%est/);
+            assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t\\eest"), /t\\est/);
+        }
+        simple() {
+            assert.strictEqual(new WebdaQL.QueryValidator("test.attr1 = 'plop'").eval(targets[0]), true);
+            assert.strictEqual(new WebdaQL.QueryValidator("test.attr1 = 'plop2'").eval(targets[0]), false);
+        }
+        contains() {
+            assert.strictEqual(new WebdaQL.QueryValidator("test.attr1 CONTAINS 'plop2'").eval(targets[0]), false);
+        }
+        andQuery() {
+            assert.strictEqual(new WebdaQL.QueryValidator("test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK']").eval(targets[0]), true);
+        }
+        orQuery() {
+            new WebdaQL.QueryValidator("(test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK']) OR attr3 <= 12").eval(targets[0]);
+        }
+        multipleQuery() {
+            new WebdaQL.QueryValidator("test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK'] OR attr3 <= 12 AND attr4 = 'ok'").eval(targets[0]);
+            new WebdaQL.QueryValidator("test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK'] AND attr3 <= 12 AND attr4 = 'ok'").eval(targets[0]);
+        }
+        unsanitize() {
+            assert.strictEqual(WebdaQL.unsanitize("test.attr1 &lt; 12 AND attr2 &gt; 13"), "test.attr1 < 12 AND attr2 > 13");
+        }
+        limitOffset() {
+            let val = new WebdaQL.QueryValidator('LIMIT 10 OFFSET "pl"');
+            // getQuery
+            val.getQuery();
+            assert.strictEqual(val.getLimit(), 10);
+            assert.strictEqual(val.getOffset(), "pl");
+            val = new WebdaQL.QueryValidator('OFFSET "pl2"');
+            assert.strictEqual(val.getLimit(), 1000);
+            assert.strictEqual(val.getOffset(), "pl2");
+        }
+        badQuery() {
+            assert.throws(() => new WebdaQL.QueryValidator("test lo 'plop'").eval(targets[0]));
+        }
+        setters() {
+            let target = {};
+            new WebdaQL.SetterValidator('i = 10 AND j = "12"').eval(target);
+            assert.strictEqual(target.i, 10);
+            assert.strictEqual(target.j, "12");
+            target = {};
+            new WebdaQL.SetterValidator("").eval(target);
+            assert.strictEqual(Object.keys(target).length, 0);
+            new WebdaQL.SetterValidator('test.i = 10 AND j.k.l = "12"').eval(target);
+            assert.strictEqual(target.test.i, 10);
+            assert.strictEqual(target.j.k.l, "12");
+            target = {};
+            new WebdaQL.SetterValidator("test.__proto__.test = 10").eval(target);
+            assert.strictEqual(target.__proto__.test, undefined);
+            assert.throws(() => new WebdaQL.SetterValidator('i = 10 OR j = "12"').eval(target), SyntaxError);
+            assert.throws(() => new WebdaQL.SetterValidator('i > 10 AND j = "12"').eval(target), SyntaxError);
+        }
+        parse() {
+            // Basic query with filter, order, limit, offset
+            const query = WebdaQL.parse("status = 'active' AND age > 18 ORDER BY name DESC LIMIT 50 OFFSET 'token123'");
+            assert.ok(query.filter instanceof WebdaQL.AndExpression);
+            assert.strictEqual(query.limit, 50);
+            assert.strictEqual(query.continuationToken, "token123");
+            assert.deepStrictEqual(query.orderBy, [{ field: "name", direction: "DESC" }]);
+            // toString returns the original parse tree reconstruction
+            assert.ok(query.toString().includes("status"));
+            // Empty query
+            const empty = WebdaQL.parse("");
+            assert.ok(empty.filter instanceof WebdaQL.AndExpression);
+            assert.strictEqual(empty.filter.children.length, 0);
+            // Filter-only query
+            const simple = WebdaQL.parse("x = 1");
+            assert.ok(simple.filter.eval({ x: 1 }));
+            assert.ok(!simple.filter.eval({ x: 2 }));
+        }
+        partialValidator() {
+            const validator = new WebdaQL.PartialValidator("attr1 = 'plop' AND attr2 = 'ok'");
+            assert.ok(validator.eval({ attr1: "plop" }));
+            assert.ok(validator.wasPartialMatch());
+            assert.ok(!validator.eval({ attr1: "plop" }, false));
+            assert.ok(!validator.eval({ attr1: "plop2" }));
+            assert.ok(new WebdaQL.PartialValidator("attr1 = 'plop' AND attr2 LIKE '?ok' AND attr3 IN ['test'] AND attr4 CONTAINS 'plop'").eval({ attr1: "plop" }));
+        }
+        mergeTypeMismatch() {
+            // AND filter merged with OR type — should wrap in OrExpression
+            const v1 = new WebdaQL.QueryValidator("a = 1 AND b = 2");
+            v1.merge("c = 3", "OR");
+            const expr1 = v1.getExpression();
+            assert.ok(expr1 instanceof WebdaQL.OrExpression);
+            // OR filter merged with AND type — should wrap in AndExpression
+            const v2 = new WebdaQL.QueryValidator("a = 1 OR b = 2");
+            v2.merge("c = 3", "AND");
+            const expr2 = v2.getExpression();
+            assert.ok(expr2 instanceof WebdaQL.AndExpression);
+        }
+        getOffsetFallback() {
+            // Query without OFFSET should return ""
+            const v = new WebdaQL.QueryValidator("a = 1");
+            assert.strictEqual(v.getOffset(), "");
+            // Query with OFFSET
+            const v2 = new WebdaQL.QueryValidator('OFFSET "tok"');
+            assert.strictEqual(v2.getOffset(), "tok");
+        }
+        expressionToString() {
+            // Test toString at different depths
+            const v = new WebdaQL.QueryValidator("a = 1 AND (b = 2 OR c = 3)");
+            const str = v.getExpression().toString();
+            assert.ok(str.includes("a = 1"));
+            // Empty AND/OR toString
+            const emptyAnd = new WebdaQL.AndExpression([]);
+            assert.strictEqual(emptyAnd.toString(), "");
+            assert.strictEqual(emptyAnd.eval({}), true);
+            const emptyOr = new WebdaQL.OrExpression([]);
+            assert.strictEqual(emptyOr.toString(), "");
+            assert.strictEqual(emptyOr.eval({}), true);
+            // Test ComparisonExpression toString with various operators
+            const comp = new WebdaQL.ComparisonExpression("!=", "field", "test");
+            assert.strictEqual(comp.toString(), 'field != "test"');
+            // Boolean values in toString
+            const boolComp = new WebdaQL.ComparisonExpression("=", "field", true);
+            assert.strictEqual(boolComp.toString(), "field = TRUE");
+            // Array values in toString
+            const arrComp = new WebdaQL.ComparisonExpression("IN", "field", ["a", 1, true]);
+            assert.ok(arrComp.toString().includes("IN"));
+        }
+        hasCondition() {
+            const v1 = new WebdaQL.QueryValidator("a = 1");
+            assert.ok(v1.hasCondition());
+            const v2 = new WebdaQL.QueryValidator("");
+            assert.ok(!v2.hasCondition());
+            const v3 = new WebdaQL.QueryValidator("ORDER BY a");
+            assert.ok(!v3.hasCondition());
+        }
+        queryValidatorToString() {
+            const v = new WebdaQL.QueryValidator("a = 1 ORDER BY b LIMIT 10");
+            const str = v.toString();
+            assert.ok(str.includes("a = 1"));
+            assert.ok(str.includes("ORDER BY"));
+            assert.ok(str.includes("LIMIT 10"));
+        }
+        complexQueries() {
+            // Nested parentheses
+            new WebdaQL.QueryValidator("(a = 1 OR b = 2) AND (c = 3 OR d = 4)").eval({ a: 1, c: 3 });
+            // Multiple IN values
+            const v = new WebdaQL.QueryValidator("field IN ['a', 'b', 'c', 'd']");
+            assert.ok(v.eval({ field: "b" }));
+            assert.ok(!v.eval({ field: "e" }));
+            // Multiple ORDER BY
+            const v2 = new WebdaQL.QueryValidator("a = 1 ORDER BY x DESC, y ASC, z DESC");
+            assert.strictEqual(v2.toString().includes("ORDER BY"), true);
+            // LIMIT + OFFSET + ORDER BY together
+            const v3 = new WebdaQL.QueryValidator('a = 1 ORDER BY b LIMIT 5 OFFSET "page2"');
+            assert.strictEqual(v3.getOffset(), "page2");
+            // Numeric comparisons
+            assert.ok(new WebdaQL.QueryValidator("x > 5").eval({ x: 10 }));
+            assert.ok(new WebdaQL.QueryValidator("x >= 10").eval({ x: 10 }));
+            assert.ok(new WebdaQL.QueryValidator("x < 10").eval({ x: 5 }));
+            assert.ok(new WebdaQL.QueryValidator("x <= 10").eval({ x: 10 }));
+            // FALSE boolean
+            assert.ok(new WebdaQL.QueryValidator("x = FALSE").eval({ x: false }));
+        }
+        containsNonArray() {
+            // CONTAINS on non-array should return false
+            assert.ok(!new WebdaQL.QueryValidator("x CONTAINS 'a'").eval({ x: "hello" }));
+            assert.ok(!new WebdaQL.QueryValidator("x CONTAINS 'a'").eval({ x: 42 }));
+        }
+        likeOnNonString() {
+            // LIKE on numeric value should toString and match
+            assert.ok(new WebdaQL.QueryValidator("x LIKE '1%'").eval({ x: 123 }));
+        }
+        likeOnMissingAttribute() {
+            // A missing or null attribute never matches instead of throwing
+            assert.ok(!new WebdaQL.QueryValidator("x LIKE '%a%'").eval({}));
+            assert.ok(!new WebdaQL.QueryValidator("x LIKE '%a%'").eval({ x: null }));
+            assert.ok(new WebdaQL.QueryValidator("x LIKE '%a%' OR y LIKE '%a%'").eval({ y: "abc" }));
+        }
+        quotedLiterals() {
+            // Doubled quotes (what escapeValue produces) and backslash-escaped quotes are unescaped
+            assert.ok(new WebdaQL.QueryValidator("k = 'it''s'").eval({ k: "it's" }));
+            assert.ok(new WebdaQL.QueryValidator('k = "say ""hi"""').eval({ k: 'say "hi"' }));
+            assert.ok(new WebdaQL.QueryValidator("k = 'it\\'s'").eval({ k: "it's" }));
+            assert.strictEqual(WebdaQL.unescapeStringLiteral("'a''b'"), "a'b");
+            // Backslash handling
+            assert.ok(new WebdaQL.QueryValidator("k = 'a\\\\b'").eval({ k: "a\\b" }));
+            assert.strictEqual(WebdaQL.unescapeStringLiteral("'a\\\\''b'"), "a\\'b");
+            // LIKE escapes are not touched
+            assert.ok(new WebdaQL.QueryValidator("k LIKE '100\\%'").eval({ k: "100%" }));
+            assert.ok(!new WebdaQL.QueryValidator("k LIKE '100\\%'").eval({ k: "1000" }));
+        }
+        lexerIntrospection() {
+            const lexer = new WebdaQLLexer(CharStreams.fromString("a = 1"));
+            assert.ok(lexer.grammarFileName);
+            assert.ok(Array.isArray(lexer.ruleNames));
+            assert.ok(typeof lexer.serializedATN === "string");
+            assert.ok(Array.isArray(lexer.channelNames));
+            assert.ok(Array.isArray(lexer.modeNames));
+        }
+        parserIntrospection() {
+            const lexer = new WebdaQLLexer(CharStreams.fromString("a = 1"));
+            const tokenStream = new CommonTokenStream(lexer);
+            const parser = new WebdaQLParserParser(tokenStream);
+            assert.ok(parser.vocabulary);
+            assert.strictEqual(parser.grammarFileName, "WebdaQLParser.g4");
+            assert.ok(Array.isArray(parser.ruleNames));
+            assert.ok(typeof parser.serializedATN === "string");
+        }
+        listenerWalk() {
+            const lexer = new WebdaQLLexer(CharStreams.fromString('a = 1 AND b LIKE "test%" AND c IN [1, "x", TRUE] AND d CONTAINS "v" AND (e = 2 OR f = 3) ORDER BY g DESC LIMIT 10 OFFSET "tok"'));
+            const tokenStream = new CommonTokenStream(lexer);
+            const parser = new WebdaQLParserParser(tokenStream);
+            const tree = parser.webdaql();
+            const visited = [];
+            const listener = {};
+            // Dynamically add all enter/exit methods to track visits
+            for (const rule of parser.ruleNames) {
+                const capitalized = rule.charAt(0).toUpperCase() + rule.slice(1);
+                listener[`enter${capitalized}`] = () => visited.push(`enter${capitalized}`);
+                listener[`exit${capitalized}`] = () => visited.push(`exit${capitalized}`);
             }
-            else {
-                console.log("QUERY", query);
-                console.log("OPTIMIZED QUERY", validator.getExpression().toString(), "=>", validator.eval(targets[0]));
+            ParseTreeWalker.DEFAULT.walk(listener, tree);
+            assert.ok(visited.includes("enterWebdaql"));
+            assert.ok(visited.includes("exitWebdaql"));
+            assert.ok(visited.length > 20);
+        }
+        contextAccessors() {
+            // Exercise parser context accessor methods
+            const lexer = new WebdaQLLexer(CharStreams.fromString("a = 1 AND b IN [1, 2] ORDER BY c DESC"));
+            const tokenStream = new CommonTokenStream(lexer);
+            const parser = new WebdaQLParserParser(tokenStream);
+            const tree = parser.webdaql();
+            // Access children of the parse tree
+            assert.ok(tree.expression());
+            const orderExpr = tree.orderExpression();
+            assert.ok(orderExpr);
+            assert.strictEqual(tree.limitExpression(), undefined);
+            // Exercise ruleIndex
+            assert.strictEqual(typeof tree.ruleIndex, "number");
+        }
+        setterAssignment() {
+            // Test SetterValidator assignments
+            const setter = new WebdaQL.SetterValidator("a = 1 AND b = 'hello' AND c = TRUE");
+            const target = { a: 0, b: "", c: false };
+            setter.eval(target);
+            assert.strictEqual(target.a, 1);
+            assert.strictEqual(target.b, "hello");
+            assert.strictEqual(target.c, true);
+        }
+        mergePreservesExistingMeta() {
+            // Same-type merge (AND + AND) should push into existing children
+            const v = new WebdaQL.QueryValidator("a = 1 AND b = 2");
+            v.merge("c = 3", "AND");
+            const expr = v.getExpression();
+            assert.ok(expr instanceof WebdaQL.AndExpression);
+            assert.strictEqual(expr.children.length, 3);
+        }
+        booleanLiterals() {
+            const check = (query, target = {}) => new WebdaQL.QueryValidator(query).eval(target);
+            assert.strictEqual(check("TRUE"), true);
+            assert.strictEqual(check("FALSE"), false);
+            assert.strictEqual(check("(TRUE)"), true);
+            assert.strictEqual(check("TRUE AND x = 1", { x: 1 }), true);
+            assert.strictEqual(check("TRUE AND x = 1", { x: 2 }), false);
+            assert.strictEqual(check("FALSE OR x = 1", { x: 1 }), true);
+            assert.strictEqual(check("FALSE AND x = 1", { x: 1 }), false);
+            assert.strictEqual(check("TRUE OR x = 1", { x: 2 }), true);
+            assert.strictEqual(check("x = 1 OR (y = 2 AND FALSE)", { y: 2 }), false);
+        }
+        booleanLiteralsFold() {
+            // Store query translators only ever see the existing expression classes
+            const all = WebdaQL.parse("TRUE").filter;
+            assert.ok(all instanceof WebdaQL.AndExpression);
+            assert.strictEqual(all.children.length, 0);
+            assert.strictEqual(WebdaQL.parse("TRUE AND x = 1").filter.toString(), "x = 1");
+            assert.ok(WebdaQL.parse("TRUE OR x = 1").filter instanceof WebdaQL.AndExpression);
+            const none = WebdaQL.parse("FALSE").filter;
+            assert.ok(none instanceof WebdaQL.BooleanExpression);
+            assert.strictEqual(none.toString(), "FALSE");
+            assert.strictEqual(WebdaQL.parse("x = 1 AND FALSE").filter.toString(), "FALSE");
+        }
+        bareAtomsAreSyntaxErrors() {
+            assert.throws(() => new WebdaQL.QueryValidator("active"), SyntaxError);
+            assert.throws(() => new WebdaQL.QueryValidator("42"), SyntaxError);
+            assert.throws(() => new WebdaQL.QueryValidator("x = 1 AND 'a'"), SyntaxError);
+        }
+        partialValidatorWithBooleans() {
+            // A missing attribute is a partial match, TRUE is folded away
+            assert.ok(new WebdaQL.PartialValidator("TRUE AND x = 1").eval({}));
+            assert.ok(!new WebdaQL.PartialValidator("FALSE").eval({}));
+        }
+        isNull() {
+            const target = { a: null, b: "x", c: 0, d: false, e: "", nested: { f: null, g: 1 } };
+            const cases = {
+                "a IS NULL": true,
+                "a IS NOT NULL": false,
+                "missing IS NULL": true,
+                "missing IS NOT NULL": false,
+                "b IS NULL": false,
+                "b IS NOT NULL": true,
+                // Falsy values are not null
+                "c IS NOT NULL": true,
+                "d IS NOT NULL": true,
+                "e IS NOT NULL": true,
+                "nested.f IS NULL": true,
+                "nested.g IS NOT NULL": true,
+                "nested.missing.deep IS NULL": true,
+                "a IS NULL AND b IS NOT NULL": true,
+                "a IS NOT NULL OR b = 'x'": true
+            };
+            for (const [query, expected] of Object.entries(cases)) {
+                assert.strictEqual(new WebdaQL.QueryValidator(query).eval(target), expected, query);
             }
+            // Keywords only win on an exact match: identifiers starting with them still parse
+            assert.ok(new WebdaQL.QueryValidator("notes IS NOT NULL AND isActive = TRUE AND nullable IS NULL").eval({
+                notes: "n",
+                isActive: true
+            }));
+            // NULL is not a value
+            assert.throws(() => new WebdaQL.QueryValidator("a = NULL"), SyntaxError);
+            assert.throws(() => new WebdaQL.QueryValidator("a IS 'x'"), SyntaxError);
         }
-    }
-    prependQuery() {
-        // merge method is tested through the prependQuery helper
-        const strictEqual = (arg1, arg2) => {
-            // Ensure it is parsable
-            new WebdaQL.QueryValidator(arg1);
-            assert.deepStrictEqual(arg1, arg2);
-        };
-        strictEqual(WebdaQL.PrependCondition("", "test='plop'"), 'test = "plop"');
-        strictEqual(WebdaQL.PrependCondition("test='plop'", ""), 'test = "plop"');
-        strictEqual(WebdaQL.PrependCondition("test='plip'", "test='plop'"), 'test = "plip" AND test = "plop"');
-        strictEqual(WebdaQL.PrependCondition("ORDER BY test", "test='plop'"), 'test = "plop" ORDER BY test ASC');
-        strictEqual(WebdaQL.PrependCondition("ORDER BY test LIMIT 100", "test='plop'"), 'test = "plop" ORDER BY test ASC LIMIT 100');
-        strictEqual(WebdaQL.PrependCondition("ORDER BY test DESC LIMIT 100", "test='plop'"), 'test = "plop" ORDER BY test DESC LIMIT 100');
-        strictEqual(WebdaQL.PrependCondition("test='plip' ORDER BY test ASC LIMIT 100", "test='plop'"), 'test = "plip" AND test = "plop" ORDER BY test ASC LIMIT 100');
-        strictEqual(WebdaQL.PrependCondition("test='plip' LIMIT 100", "test='plop'"), 'test = "plip" AND test = "plop" LIMIT 100');
-        strictEqual(WebdaQL.PrependCondition("test='plip' OFFSET 'test'", "test='plop'"), 'test = "plip" AND test = "plop" OFFSET "test"');
-        strictEqual(WebdaQL.PrependCondition("test='ORDER BY plop' OFFSET 'test'", "test='plop'"), 'test = "ORDER BY plop" AND test = "plop" OFFSET "test"');
-        strictEqual(WebdaQL.PrependCondition('test="ORDER BY plop" LIMIT 100', "test='plop'"), 'test = "ORDER BY plop" AND test = "plop" LIMIT 100');
-        // Composed ORDER BY
-        strictEqual(WebdaQL.PrependCondition('test="plop" ORDER BY ab ASC LIMIT 100', "ORDER BY forced DESC"), 'test = "plop" ORDER BY forced DESC, ab ASC LIMIT 100');
-        // Opposite ORDER BY
-        strictEqual(WebdaQL.PrependCondition('test="plop" ORDER BY forced ASC LIMIT 100', "ORDER BY forced DESC"), 'test = "plop" ORDER BY forced DESC LIMIT 100');
-        // Overwrite LIMIT
-        strictEqual(WebdaQL.PrependCondition('test="plop" ORDER BY forced ASC LIMIT 100', "LIMIT 5"), 'test = "plop" ORDER BY forced ASC LIMIT 5');
-        // Overwrite OFFSET
-        strictEqual(WebdaQL.PrependCondition('OFFSET "test"', "OFFSET 'plop'"), 'OFFSET "plop"');
-        strictEqual(WebdaQL.PrependCondition('plop = "ok"', "OFFSET 'plop'"), 'plop = "ok" OFFSET "plop"');
-    }
-    likeRegexp() {
-        assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("test"), /test/);
-        assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t_est"), /t.{1}est/);
-        assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("_test"), /.{1}test/);
-        assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t\\_est"), /t_est/);
-        assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t%est"), /t.*est/);
-        assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("%te?st"), /.*te\?st/);
-        assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t\\%est"), /t%est/);
-        assert.deepStrictEqual(WebdaQL.ComparisonExpression.likeToRegex("t\\eest"), /t\\est/);
-    }
-    simple() {
-        assert.strictEqual(new WebdaQL.QueryValidator("test.attr1 = 'plop'").eval(targets[0]), true);
-        assert.strictEqual(new WebdaQL.QueryValidator("test.attr1 = 'plop2'").eval(targets[0]), false);
-    }
-    contains() {
-        assert.strictEqual(new WebdaQL.QueryValidator("test.attr1 CONTAINS 'plop2'").eval(targets[0]), false);
-    }
-    andQuery() {
-        assert.strictEqual(new WebdaQL.QueryValidator("test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK']").eval(targets[0]), true);
-    }
-    orQuery() {
-        new WebdaQL.QueryValidator("(test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK']) OR attr3 <= 12").eval(targets[0]);
-    }
-    multipleQuery() {
-        new WebdaQL.QueryValidator("test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK'] OR attr3 <= 12 AND attr4 = 'ok'").eval(targets[0]);
-        new WebdaQL.QueryValidator("test.attr1 = 'plop' AND attr2 IN ['TEST', 'OK'] AND attr3 <= 12 AND attr4 = 'ok'").eval(targets[0]);
-    }
-    unsanitize() {
-        assert.strictEqual(WebdaQL.unsanitize("test.attr1 &lt; 12 AND attr2 &gt; 13"), "test.attr1 < 12 AND attr2 > 13");
-    }
-    limitOffset() {
-        let val = new WebdaQL.QueryValidator('LIMIT 10 OFFSET "pl"');
-        // getQuery
-        val.getQuery();
-        assert.strictEqual(val.getLimit(), 10);
-        assert.strictEqual(val.getOffset(), "pl");
-        val = new WebdaQL.QueryValidator('OFFSET "pl2"');
-        assert.strictEqual(val.getLimit(), 1000);
-        assert.strictEqual(val.getOffset(), "pl2");
-    }
-    badQuery() {
-        assert.throws(() => new WebdaQL.QueryValidator("test lo 'plop'").eval(targets[0]));
-    }
-    setters() {
-        let target = {};
-        new WebdaQL.SetterValidator('i = 10 AND j = "12"').eval(target);
-        assert.strictEqual(target.i, 10);
-        assert.strictEqual(target.j, "12");
-        target = {};
-        new WebdaQL.SetterValidator("").eval(target);
-        assert.strictEqual(Object.keys(target).length, 0);
-        new WebdaQL.SetterValidator('test.i = 10 AND j.k.l = "12"').eval(target);
-        assert.strictEqual(target.test.i, 10);
-        assert.strictEqual(target.j.k.l, "12");
-        target = {};
-        new WebdaQL.SetterValidator("test.__proto__.test = 10").eval(target);
-        assert.strictEqual(target.__proto__.test, undefined);
-        assert.throws(() => new WebdaQL.SetterValidator('i = 10 OR j = "12"').eval(target), SyntaxError);
-        assert.throws(() => new WebdaQL.SetterValidator('i > 10 AND j = "12"').eval(target), SyntaxError);
-    }
-    partialValidator() {
-        const validator = new WebdaQL.PartialValidator("attr1 = 'plop' AND attr2 = 'ok'");
-        assert.ok(validator.eval({ attr1: "plop" }));
-        assert.ok(validator.wasPartialMatch());
-        assert.ok(!validator.eval({ attr1: "plop" }, false));
-        assert.ok(!validator.eval({ attr1: "plop2" }));
-        assert.ok(new WebdaQL.PartialValidator("attr1 = 'plop' AND attr2 LIKE '?ok' AND attr3 IN ['test'] AND attr4 CONTAINS 'plop'").eval({ attr1: "plop" }));
-    }
-};
-__decorate([
-    test
-], QueryTest.prototype, "dev", null);
-__decorate([
-    test
-], QueryTest.prototype, "prependQuery", null);
-__decorate([
-    test
-], QueryTest.prototype, "likeRegexp", null);
-__decorate([
-    test
-], QueryTest.prototype, "simple", null);
-__decorate([
-    test
-], QueryTest.prototype, "contains", null);
-__decorate([
-    test
-], QueryTest.prototype, "andQuery", null);
-__decorate([
-    test
-], QueryTest.prototype, "orQuery", null);
-__decorate([
-    test
-], QueryTest.prototype, "multipleQuery", null);
-__decorate([
-    test
-], QueryTest.prototype, "unsanitize", null);
-__decorate([
-    test
-], QueryTest.prototype, "limitOffset", null);
-__decorate([
-    test
-], QueryTest.prototype, "badQuery", null);
-__decorate([
-    test
-], QueryTest.prototype, "setters", null);
-__decorate([
-    test
-], QueryTest.prototype, "partialValidator", null);
-QueryTest = __decorate([
-    suite
-], QueryTest);
+        isNullToString() {
+            const expression = new WebdaQL.QueryValidator("a IS NULL AND b.c IS NOT NULL").getExpression();
+            assert.strictEqual(expression.toString(), "a IS NULL AND b.c IS NOT NULL");
+            const comparison = expression.children[0];
+            assert.strictEqual(comparison.operator, "IS NULL");
+            assert.deepStrictEqual(comparison.attribute, ["a"]);
+            // The printed query parses back to the same expression
+            assert.strictEqual(new WebdaQL.QueryValidator(expression.toString()).getExpression().toString(), expression.toString());
+            // Merging keeps the operators printable and parsable
+            assert.strictEqual(WebdaQL.PrependCondition("a IS NULL ORDER BY a", "b IS NOT NULL"), "a IS NULL AND b IS NOT NULL ORDER BY a ASC");
+            const merged = new WebdaQL.QueryValidator("a IS NULL").merge("b IS NOT NULL", "OR").toString();
+            assert.strictEqual(merged, "a IS NULL OR b IS NOT NULL");
+            assert.ok(new WebdaQL.QueryValidator(merged).eval({ a: null }));
+        }
+        isNullPartial() {
+            // A missing attribute is a partial match
+            const validator = new WebdaQL.PartialValidator("a IS NOT NULL AND b IS NULL");
+            assert.ok(validator.eval({}));
+            assert.ok(validator.wasPartialMatch());
+            assert.ok(!validator.eval({ a: null, b: null }));
+            assert.ok(validator.eval({ a: 1, b: null }));
+            assert.ok(!validator.eval({ a: 1, b: 2 }));
+        }
+        constructor() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+    return QueryTest = _classThis;
+})();
 //# sourceMappingURL=query.spec.js.map