@tellaro/tql 0.1.18 → 0.2.0

package/dist/src/complexityAnalyzer.d.ts

@@ -1,5 +1,4 @@
 import { ComplexityMetrics, ComplexityResult, ComplexityThresholds, ComplexityWarning } from './types';
-
 export declare class ComplexityAnalyzer {
     private thresholds;
     constructor(thresholds?: ComplexityThresholds);

package/dist/src/complexityAnalyzer.js

@@ -1,29 +1,26 @@
-var d = Object.defineProperty;
-var p = (i, e, t) => e in i ? d(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
-var h = (i, e, t) => p(i, typeof e != "symbol" ? e + "" : e, t);
-import { parseTql as g } from "./parser.js";
-const c = {
+import { parseTql as u } from "./parser.js";
+const d = {
   maxDepth: 5,
   maxRegex: 3,
   maxInListSize: 100,
   maxOrChainLength: 10,
   maxLeadingWildcards: 2
-}, u = /* @__PURE__ */ new Set([
+}, h = /* @__PURE__ */ new Set([
   "geoip_lookup",
   "geoip",
   "geo",
   "nslookup"
-]), y = /\*/g, f = /^\*/;
-class x {
+]), p = /\*/g, g = /^\*/;
+class c {
+  thresholds;
   constructor(e) {
-    h(this, "thresholds");
-    this.thresholds = { ...c, ...e };
+    this.thresholds = { ...d, ...e };
   }
   /**
    * Analyze a TQL query for complexity
    */
   analyze(e) {
-    const t = g(e), a = {
+    const t = u(e), a = {
       depth: 0,
       operatorCount: 0,
       wildcardCount: 0,
@@ -72,8 +69,8 @@ class x {
   }
   analyzeUnaryExpression(e, t, a, n, s) {
     t.operatorCount++;
-    const o = e.operator === "NOT" ? s + 1 : s;
-    this.analyzeExpression(e.operand, t, a, n + 1, o);
+    const i = e.operator === "NOT" ? s + 1 : s;
+    this.analyzeExpression(e.operand, t, a, n + 1, i);
   }
   analyzeGroupExpression(e, t, a, n, s) {
     this.analyzeExpression(e.expression, t, a, n + 1, s);
@@ -82,7 +79,7 @@ class x {
     t.operatorCount++;
     const n = e.field;
     if (n.type === "mutator")
-      t.mutatorCount++, u.has(n.mutator) && (t.postProcessingMutatorCount++, a.push({
+      t.mutatorCount++, h.has(n.mutator) && (t.postProcessingMutatorCount++, a.push({
         type: "post_processing_mutator",
         message: `Mutator '${n.mutator}' requires post-processing and may be slow`,
         severity: "warning",
@@ -90,28 +87,28 @@ class x {
       }));
     else if (n.type === "field" && n.mutators) {
       t.mutatorCount += n.mutators.length;
-      for (const o of n.mutators)
-        u.has(o) && (t.postProcessingMutatorCount++, a.push({
+      for (const i of n.mutators)
+        h.has(i) && (t.postProcessingMutatorCount++, a.push({
           type: "post_processing_mutator",
-          message: `Mutator '${o}' requires post-processing and may be slow`,
+          message: `Mutator '${i}' requires post-processing and may be slow`,
           severity: "warning",
           location: { start: n.start, end: n.end }
         }));
     }
     const s = e.operator.toLowerCase();
     if ((s === "regexp" || s === "regex" || s === "matches" || s === "not_regexp" || s === "not_matches") && t.regexCount++, this.analyzeValue(e.value, t, a, e), (s === "in" || s === "not_in") && Array.isArray(e.value)) {
-      const o = e.value.length;
-      t.inListMaxSize = Math.max(t.inListMaxSize, o);
+      const i = e.value.length;
+      t.inListMaxSize = Math.max(t.inListMaxSize, i);
     }
   }
   analyzeValue(e, t, a, n) {
     const s = Array.isArray(e) ? e : [e];
-    for (const o of s)
-      if (o.valueType === "string" && typeof o.value == "string") {
-        const l = o.value.match(y);
-        l && (t.wildcardCount += l.length, f.test(o.value) && (t.leadingWildcardCount++, t.leadingWildcardCount <= this.thresholds.maxLeadingWildcards && a.push({
+    for (const i of s)
+      if (i.valueType === "string" && typeof i.value == "string") {
+        const l = i.value.match(p);
+        l && (t.wildcardCount += l.length, g.test(i.value) && (t.leadingWildcardCount++, t.leadingWildcardCount <= this.thresholds.maxLeadingWildcards && a.push({
           type: "leading_wildcard",
-          message: `Leading wildcard in '${o.value}' is expensive - consider using 'endswith' if possible`,
+          message: `Leading wildcard in '${i.value}' is expensive - consider using 'endswith' if possible`,
           severity: "warning",
           location: { start: n.start, end: n.end }
         })));
@@ -188,22 +185,22 @@ class x {
     return a += n * 2, a >= 4 ? "high" : a >= 2 ? "medium" : "low";
   }
 }
-function r(i, e) {
-  return new x(e).analyze(i);
+function r(o, e) {
+  return new c(e).analyze(o);
 }
-function L(i, e) {
-  return r(i, e).score === "high";
+function f(o, e) {
+  return r(o, e).score === "high";
 }
-function z(i, e) {
-  return r(i, e).warnings;
+function x(o, e) {
+  return r(o, e).warnings;
 }
-function _(i) {
-  return r(i).metrics;
+function C(o) {
+  return r(o).metrics;
 }
 export {
-  x as ComplexityAnalyzer,
+  c as ComplexityAnalyzer,
   r as analyzeComplexity,
-  _ as getComplexityMetrics,
-  z as getComplexityWarnings,
-  L as isHighComplexity
+  C as getComplexityMetrics,
+  x as getComplexityWarnings,
+  f as isHighComplexity
 };

package/dist/src/parser.d.ts

@@ -1,5 +1,4 @@
 import { TqlParseError, TqlParseResult } from './types';
-
 export declare class TqlParser {
     private tokens;
     private allTokens;

package/dist/src/parser.js

@@ -1,19 +1,15 @@
-var c = Object.defineProperty;
-var d = (r, e, t) => e in r ? c(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var o = (r, e, t) => d(r, typeof e != "symbol" ? e + "" : e, t);
-import { tokenizeTql as p, COMPARISON_OPERATORS as v, ENRICHMENT_MUTATORS as ENRICHMENT_MUTATORS, MUTATORS as ALL_MUTATORS } from "./tokenizer.js";
-import { suggestOperator as suggestOp, suggestMutator as suggestMut } from "./validator.js";
-const f = 50, k = /* @__PURE__ */ new Set(["logicalOp", "paren"]);
-class y {
+import { tokenizeTql as u, COMPARISON_OPERATORS as c } from "./tokenizer.js";
+const d = 50, p = /* @__PURE__ */ new Set(["logicalOp", "paren"]);
+class v {
+  tokens;
+  allTokens;
+  // Including whitespace for highlighting
+  current;
+  errors;
+  warnings;
+  depth;
   constructor(e) {
-    o(this, "tokens");
-    o(this, "allTokens");
-    // Including whitespace for highlighting
-    o(this, "current");
-    o(this, "errors");
-    o(this, "warnings");
-    o(this, "depth");
-    this.allTokens = p(e), this.tokens = this.allTokens.filter((t) => t.type !== "whitespace"), this.current = 0, this.errors = [], this.warnings = [], this.depth = 0;
+    this.allTokens = u(e), this.tokens = this.allTokens.filter((t) => t.type !== "whitespace"), this.current = 0, this.errors = [], this.warnings = [], this.depth = 0;
   }
   /**
    * Parse the input and return the result
@@ -62,7 +58,7 @@ class y {
    * Parse a full expression (lowest precedence)
    */
   parseExpression() {
-    if (this.depth++, this.depth > f)
+    if (this.depth++, this.depth > d)
       throw new Error("Maximum query depth exceeded");
     try {
       return this.parseOr();
@@ -84,14 +80,14 @@ class y {
           "MISSING_OPERAND",
           "Add a condition after 'OR'"
         ), e;
-      const n = this.parseAnd();
+      const r = this.parseAnd();
       e = {
         type: "binary",
         operator: "OR",
         left: e,
-        right: n,
+        right: r,
         start: e.start,
-        end: n.end
+        end: r.end
       };
     }
     return e;
@@ -110,14 +106,14 @@ class y {
           "MISSING_OPERAND",
           "Add a condition after 'AND'"
         ), e;
-      const n = this.parseUnary();
+      const r = this.parseUnary();
       e = {
         type: "binary",
         operator: "AND",
         left: e,
-        right: n,
+        right: r,
         start: e.start,
-        end: n.end
+        end: r.end
       };
     }
     return e;
@@ -198,16 +194,14 @@ class y {
           "Valid types: string, int, float, date, bool, array"
         );
       }
-    const n = [];
+    const r = [];
     for (; this.check("pipe"); )
       if (this.advance(), this.check("mutator")) {
         const s = this.advance();
-        n.push(s.value.toLowerCase());
+        r.push(s.value.toLowerCase());
       } else if (this.check("field")) {
         const s = this.advance();
-        n.push(s.value.toLowerCase());
-        const suggestion = suggestMut(s.value);
-        this.addWarning(`Unknown mutator '${s.value}'`, s, suggestion ? `Did you mean: ${suggestion}?` : "Valid mutators: lowercase, uppercase, trim, geo, nslookup, etc.");
+        r.push(s.value.toLowerCase()), this.addWarning(`Unknown mutator '${s.value}'`, s, "Check the mutator name spelling");
       } else {
         const s = this.isAtEnd() ? this.previous() : this.peek();
         this.addError(
@@ -218,30 +212,14 @@ class y {
         );
         break;
       }
-    if (n.length > 0 && (t = {
+    if (r.length > 0 && (t = {
       ...t,
-      mutators: n,
+      mutators: r,
       end: this.previous().end
     }), !this.check("operator")) {
-      // Check if the last mutator is an enrichment mutator (geo, nslookup, etc.)
-      // Enrichment mutators don't require an operator - they transform the field into enriched data
-      const lastMutator = n.length > 0 ? n[n.length - 1] : null;
-      const isEnrichmentMutator = lastMutator && ENRICHMENT_MUTATORS.includes(lastMutator);
-
-      if (isEnrichmentMutator) {
-        // Return a valid enrichment expression without error
-        return {
-          type: "enrichment",
-          field: t,
-          mutator: lastMutator,
-          start: t.start,
-          end: t.end
-        };
-      }
-
-      const s = this.isAtEnd() ? this.previous() : this.peek(), h = n.length > 0 ? `'${e.value}' with mutator` : `'${e.value}'`;
+      const s = this.isAtEnd() ? this.previous() : this.peek(), o = r.length > 0 ? `'${e.value}' with mutator` : `'${e.value}'`;
       return this.addError(
-        `Expected operator after field ${h}`,
+        `Expected operator after field ${o}`,
         s,
         "MISSING_OPERATOR",
         "Add an operator like 'eq', 'contains', '==', etc."
@@ -260,35 +238,28 @@ class y {
         end: t.end
       };
     }
-    const i = this.advance();
-    let a = this.normalizeOperator(i.value);
-    // Handle unknown operator with suggestions
-    if (typeof a === 'object' && a.unknown) {
-      const suggestionMsg = a.suggestion ? `Did you mean: ${a.suggestion}?` : "Valid operators: eq, ne, contains, startswith, gt, lt, etc.";
-      this.addWarning(`Unknown operator '${a.value}'`, i, suggestionMsg);
-      a = a.value; // Use the original value
-    }
-    if (a === "exists" || a === "not_exists")
+    const a = this.advance(), n = this.normalizeOperator(a.value);
+    if (n === "exists" || n === "not_exists")
       return {
         type: "comparison",
         field: t,
-        operator: a,
+        operator: n,
         value: {
           type: "literal",
           valueType: "boolean",
           value: !0,
-          start: i.end,
-          end: i.end
+          start: a.end,
+          end: a.end
         },
         start: t.start,
-        end: i.end
+        end: a.end
       };
-    if ((a === "is" || a === "is_not") && this.check("null")) {
+    if ((n === "is" || n === "is_not") && this.check("null")) {
       const s = this.advance();
       return {
         type: "comparison",
         field: t,
-        operator: a,
+        operator: n,
         value: {
           type: "literal",
           valueType: "null",
@@ -300,18 +271,18 @@ class y {
         end: s.end
       };
     }
-    if (a === "in" || a === "not_in") {
+    if (n === "in" || n === "not_in") {
       const s = this.parseValueList();
       return {
         type: "comparison",
         field: t,
-        operator: a,
+        operator: n,
         value: s,
         start: t.start,
         end: this.previous().end
       };
     }
-    if (a === "between" || a === "not_between") {
+    if (n === "between" || n === "not_between") {
       const s = this.parseValue();
       this.matchLogical("AND") || this.addError(
         "Expected 'AND' between values in 'between' operator",
@@ -319,44 +290,44 @@ class y {
         "INVALID_SYNTAX",
         "Use format: field between value1 AND value2"
       );
-      const h = this.parseValue();
+      const o = this.parseValue();
       return {
         type: "comparison",
         field: t,
-        operator: a,
-        value: [s, h],
+        operator: n,
+        value: [s, o],
         start: t.start,
-        end: h.end
+        end: o.end
       };
     }
     if (this.isAtEnd())
       return this.addError(
-        `Expected a value after operator '${a}'`,
-        i,
+        `Expected a value after operator '${n}'`,
+        a,
         "MISSING_VALUE",
         'Add a value like "text", 123, or true'
       ), {
         type: "comparison",
         field: t,
-        operator: a,
+        operator: n,
         value: {
           type: "literal",
           valueType: "string",
           value: "",
-          start: i.end,
-          end: i.end
+          start: a.end,
+          end: a.end
         },
         start: t.start,
-        end: i.end
+        end: a.end
       };
-    const l = this.parseValue();
+    const h = this.parseValue();
     return {
       type: "comparison",
       field: t,
-      operator: a,
-      value: l,
+      operator: n,
+      value: h,
       start: t.start,
-      end: l.end
+      end: h.end
     };
   }
   /**
@@ -447,7 +418,7 @@ class y {
     };
   }
   normalizeOperator(e) {
-    const t = e.toLowerCase(), n = {
+    const t = e.toLowerCase(), r = {
       "==": "eq",
       "=": "eq",
       "!=": "ne",
@@ -456,9 +427,9 @@ class y {
       "<": "lt",
       "<=": "lte"
     };
-    if (e in n)
-      return n[e];
-    const i = {
+    if (e in r)
+      return r[e];
+    const a = {
       "!in": "not_in",
       "!contains": "not_contains",
       "!startswith": "not_startswith",
@@ -473,22 +444,14 @@ class y {
       "!all": "not_all",
       "!none": "not_none"
     };
-    if (t in i)
-      return i[t];
-    const a = {
+    if (t in a)
+      return a[t];
+    const n = {
       regex: "regexp",
       starts_with: "startswith",
       ends_with: "endswith"
     };
-    if (t in a) return a[t];
-    // Check if this is a valid operator, if not add a warning with suggestions
-    if (!v.includes(t)) {
-      const suggestion = suggestOp(t);
-      // Return the original value but note that it might be invalid
-      // The warning will be added by the caller if needed
-      return { value: t, unknown: true, suggestion };
-    }
-    return t;
+    return t in n ? n[t] : (c.includes(t), t);
   }
   isAtEnd() {
     return this.current >= this.tokens.length;
@@ -514,7 +477,7 @@ class y {
   matchLogical(e) {
     return this.check("logicalOp") && this.peek().value.toUpperCase() === e ? (this.advance(), !0) : !1;
   }
-  addError(e, t, n, i) {
+  addError(e, t, r, a) {
     this.errors.push({
       message: e,
       start: t.start,
@@ -522,11 +485,11 @@ class y {
       line: t.line,
       column: t.column,
       severity: "error",
-      code: n,
-      suggestion: i
+      code: r,
+      suggestion: a
     });
   }
-  addWarning(e, t, n) {
+  addWarning(e, t, r) {
     this.warnings.push({
       message: e,
       start: t.start,
@@ -535,7 +498,7 @@ class y {
       column: t.column,
       severity: "warning",
       code: "TYPE_MISMATCH",
-      suggestion: n
+      suggestion: r
     });
   }
   /**
@@ -544,7 +507,7 @@ class y {
    */
   synchronize() {
     for (this.advance(); !this.isAtEnd(); ) {
-      if (k.has(this.peek().type) || this.peek().type === "paren" && this.peek().value === ")")
+      if (p.has(this.peek().type) || this.peek().type === "paren" && this.peek().value === ")")
         return;
       this.advance();
     }
@@ -576,23 +539,23 @@ class y {
     };
   }
 }
-function u(r) {
-  return new y(r).parse();
+function l(i) {
+  return new v(i).parse();
 }
-function g(r) {
-  return u(r).success;
+function k(i) {
+  return l(i).success;
 }
-function A(r) {
-  return u(r).errors;
+function y(i) {
+  return l(i).errors;
 }
-function T(r) {
-  let e = `Error at line ${r.line}, column ${r.column}: ${r.message}`;
-  return r.suggestion && (e += ` (${r.suggestion})`), e;
+function E(i) {
+  let e = `Error at line ${i.line}, column ${i.column}: ${i.message}`;
+  return i.suggestion && (e += ` (${i.suggestion})`), e;
 }
 export {
-  y as TqlParser,
-  T as formatParseError,
-  A as getTqlErrors,
-  g as isValidTql,
-  u as parseTql
+  v as TqlParser,
+  E as formatParseError,
+  y as getTqlErrors,
+  k as isValidTql,
+  l as parseTql
 };

package/dist/src/schemaCache.d.ts

@@ -1,5 +1,4 @@
 import { TqlFieldSchema, TqlFieldType } from './types';
-
 /**
  * Cached schema data with O(1) lookups
  */

package/dist/src/schemaCache.js

@@ -1,10 +1,5 @@
-var f = Object.defineProperty;
-var m = (s, e, t) => e in s ? f(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
-var d = (s, e, t) => m(s, typeof e != "symbol" ? e + "" : e, t);
-class p {
-  constructor() {
-    d(this, "cache", null);
-  }
+class d {
+  cache = null;
   /**
    * Get cached schema data, rebuilding if schema has changed.
    * Returns null if no schema provided.
@@ -31,33 +26,31 @@ class p {
    * Get field by name with O(1) lookup
    */
   getField(e, t) {
-    const n = this.get(e);
-    return n == null ? void 0 : n.fieldMap.get(t);
+    return this.get(e)?.fieldMap.get(t);
   }
   /**
    * Get field type by name with O(1) lookup
    */
   getFieldType(e, t) {
-    const n = this.get(e);
-    return n == null ? void 0 : n.typeMap.get(t);
+    return this.get(e)?.typeMap.get(t);
   }
   /**
    * Build the cache from a schema
    */
   buildCache(e, t) {
-    const n = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), i = [], c = (a, o) => {
-      const r = o ? `${o}.${a.name}` : a.name;
-      if (n.set(r, a), h.set(r, a.type), i.push(r), a.nested)
-        for (const g of a.nested)
-          c(g, r);
+    const a = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), n = [], h = (c, o) => {
+      const r = o ? `${o}.${c.name}` : c.name;
+      if (a.set(r, c), i.set(r, c.type), n.push(r), c.nested)
+        for (const p of c.nested)
+          h(p, r);
     };
-    for (const a of e)
-      c(a);
+    for (const c of e)
+      h(c);
     return {
       fields: e,
-      fieldMap: n,
-      typeMap: h,
-      allFieldNames: i,
+      fieldMap: a,
+      typeMap: i,
+      allFieldNames: n,
       hash: t,
       timestamp: Date.now()
     };
@@ -67,38 +60,37 @@ class p {
    * Uses a simple string-based hash for performance.
    */
   computeHash(e) {
-    const t = (i) => i.map((c) => {
-      let a = `${c.name}:${c.type}`;
-      return c.nested && (a += `[${t(c.nested)}]`), a;
-    }).join(","), n = t(e);
-    let h = 5381;
-    for (let i = 0; i < n.length; i++)
-      h = h * 33 ^ n.charCodeAt(i);
-    return (h >>> 0).toString(36);
+    const t = (n) => n.map((h) => {
+      let c = `${h.name}:${h.type}`;
+      return h.nested && (c += `[${t(h.nested)}]`), c;
+    }).join(","), a = t(e);
+    let i = 5381;
+    for (let n = 0; n < a.length; n++)
+      i = i * 33 ^ a.charCodeAt(n);
+    return (i >>> 0).toString(36);
   }
 }
 let l = null;
 function u() {
-  return l || (l = new p()), l;
+  return l || (l = new d()), l;
 }
-function C() {
-  return new p();
+function g() {
+  return new d();
 }
-function y(s) {
-  const e = u().get(s);
-  return (e == null ? void 0 : e.allFieldNames) ?? [];
+function f(s) {
+  return u().get(s)?.allFieldNames ?? [];
 }
-function M(s, e) {
+function m(s, e) {
   return u().getFieldType(s, e);
 }
-function w(s, e) {
+function F(s, e) {
   return u().getField(s, e);
 }
 export {
-  p as SchemaCache,
-  C as createSchemaCache,
-  w as getCachedField,
-  y as getCachedFieldNames,
-  M as getCachedFieldType,
+  d as SchemaCache,
+  g as createSchemaCache,
+  F as getCachedField,
+  f as getCachedFieldNames,
+  m as getCachedFieldType,
   u as getSchemaCache
 };

package/dist/src/semanticPreview.d.ts

@@ -1,5 +1,4 @@
 import { FieldUsage, LogicTreeNode, PreviewResult } from './types';
-
 export declare class SemanticPreview {
     /**
      * Generate a complete preview for a TQL query