@tellaro/tql 0.1.0 → 0.1.2

package/dist/src/complexityAnalyzer.js

@@ -0,0 +1,209 @@
+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 = {
+  maxDepth: 5,
+  maxRegex: 3,
+  maxInListSize: 100,
+  maxOrChainLength: 10,
+  maxLeadingWildcards: 2
+}, u = /* @__PURE__ */ new Set([
+  "geoip_lookup",
+  "geoip",
+  "geo",
+  "nslookup"
+]), y = /\*/g, f = /^\*/;
+class x {
+  constructor(e) {
+    h(this, "thresholds");
+    this.thresholds = { ...c, ...e };
+  }
+  /**
+   * Analyze a TQL query for complexity
+   */
+  analyze(e) {
+    const t = g(e), a = {
+      depth: 0,
+      operatorCount: 0,
+      wildcardCount: 0,
+      leadingWildcardCount: 0,
+      regexCount: 0,
+      mutatorCount: 0,
+      postProcessingMutatorCount: 0,
+      inListMaxSize: 0,
+      orChainLength: 0,
+      andChainLength: 0,
+      negationDepth: 0
+    }, n = [], s = [];
+    return t.ast ? (this.analyzeExpression(t.ast, a, n, 0, 0), a.orChainLength = this.calculateOrChainLength(t.ast), a.andChainLength = this.calculateAndChainLength(t.ast), this.generateWarnings(a, n), this.generateSuggestions(n, s, a), {
+      score: this.calculateScore(a, n),
+      warnings: n,
+      suggestions: s,
+      metrics: a
+    }) : {
+      score: "low",
+      warnings: [],
+      suggestions: [],
+      metrics: a
+    };
+  }
+  /**
+   * Recursively analyze an expression and collect metrics
+   */
+  analyzeExpression(e, t, a, n, s) {
+    switch (t.depth = Math.max(t.depth, n), t.negationDepth = Math.max(t.negationDepth, s), e.type) {
+      case "binary":
+        this.analyzeBinaryExpression(e, t, a, n, s);
+        break;
+      case "unary":
+        this.analyzeUnaryExpression(e, t, a, n, s);
+        break;
+      case "comparison":
+        this.analyzeComparisonExpression(e, t, a);
+        break;
+      case "group":
+        this.analyzeGroupExpression(e, t, a, n, s);
+        break;
+    }
+  }
+  analyzeBinaryExpression(e, t, a, n, s) {
+    t.operatorCount++, this.analyzeExpression(e.left, t, a, n + 1, s), this.analyzeExpression(e.right, t, a, n + 1, s);
+  }
+  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);
+  }
+  analyzeGroupExpression(e, t, a, n, s) {
+    this.analyzeExpression(e.expression, t, a, n + 1, s);
+  }
+  analyzeComparisonExpression(e, t, a) {
+    t.operatorCount++;
+    const n = e.field;
+    if (n.type === "mutator")
+      t.mutatorCount++, u.has(n.mutator) && (t.postProcessingMutatorCount++, a.push({
+        type: "post_processing_mutator",
+        message: `Mutator '${n.mutator}' requires post-processing and may be slow`,
+        severity: "warning",
+        location: { start: n.start, end: n.end }
+      }));
+    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({
+          type: "post_processing_mutator",
+          message: `Mutator '${o}' 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);
+    }
+  }
+  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({
+          type: "leading_wildcard",
+          message: `Leading wildcard in '${o.value}' is expensive - consider using 'endswith' if possible`,
+          severity: "warning",
+          location: { start: n.start, end: n.end }
+        })));
+      }
+  }
+  /**
+   * Calculate the length of OR chains (consecutive ORs)
+   */
+  calculateOrChainLength(e) {
+    if (e.type !== "binary" || e.operator !== "OR")
+      return 0;
+    let t = 1, a = e;
+    for (; a.type === "binary" && a.operator === "OR"; )
+      t++, a = a.right;
+    const n = this.calculateOrChainLength(e.left);
+    return Math.max(t, n);
+  }
+  /**
+   * Calculate the length of AND chains (consecutive ANDs)
+   */
+  calculateAndChainLength(e) {
+    if (e.type !== "binary" || e.operator !== "AND")
+      return 0;
+    let t = 1, a = e;
+    for (; a.type === "binary" && a.operator === "AND"; )
+      t++, a = a.right;
+    const n = this.calculateAndChainLength(e.left);
+    return Math.max(t, n);
+  }
+  /**
+   * Generate warnings based on collected metrics
+   */
+  generateWarnings(e, t) {
+    e.depth > this.thresholds.maxDepth && t.push({
+      type: "deep_nesting",
+      message: `Query depth of ${e.depth} exceeds recommended maximum of ${this.thresholds.maxDepth}`,
+      severity: "warning"
+    }), e.regexCount > this.thresholds.maxRegex && t.push({
+      type: "multiple_regex",
+      message: `Query contains ${e.regexCount} regex operators which may impact performance`,
+      severity: "warning"
+    }), e.inListMaxSize > this.thresholds.maxInListSize && t.push({
+      type: "large_in_list",
+      message: `IN list with ${e.inListMaxSize} values exceeds recommended maximum of ${this.thresholds.maxInListSize}`,
+      severity: "warning"
+    }), e.orChainLength > this.thresholds.maxOrChainLength && t.push({
+      type: "complex_or_chain",
+      message: `OR chain with ${e.orChainLength} conditions may be slow`,
+      severity: "info"
+    }), e.leadingWildcardCount > this.thresholds.maxLeadingWildcards && t.push({
+      type: "multiple_wildcards",
+      message: `Query contains ${e.leadingWildcardCount} leading wildcards which prevent index usage`,
+      severity: "warning"
+    }), e.negationDepth > 2 && t.push({
+      type: "nested_negation",
+      message: `Deeply nested negations (depth ${e.negationDepth}) may be hard to understand and optimize`,
+      severity: "info"
+    });
+  }
+  /**
+   * Generate optimization suggestions based on warnings
+   */
+  generateSuggestions(e, t, a) {
+    const n = new Set(e.map((s) => s.type));
+    (n.has("leading_wildcard") || n.has("multiple_wildcards")) && t.push("Leading wildcards (`*foo`) are expensive - use `endswith` if possible"), n.has("deep_nesting") && t.push(`Query depth of ${a.depth} may impact performance - consider simplifying`), n.has("multiple_regex") && t.push("Multiple regex operators are slow - consider using `contains` or `startswith` where possible"), n.has("large_in_list") && t.push("Large IN lists can be slow - consider splitting into multiple queries or using a lookup table"), n.has("complex_or_chain") && t.push("Consider using `in` instead of multiple `OR` conditions for the same field"), n.has("post_processing_mutator") && t.push("Mutators like `geoip_lookup` and `nslookup` require post-processing and cannot be optimized by the database"), n.has("nested_negation") && t.push("Simplify nested NOT expressions for better readability and potential optimization");
+  }
+  /**
+   * Calculate overall complexity score based on metrics and warnings
+   */
+  calculateScore(e, t) {
+    let a = 0;
+    e.depth > this.thresholds.maxDepth ? a += 2 : e.depth > 3 && (a += 1), e.regexCount > this.thresholds.maxRegex ? a += 2 : e.regexCount > 1 && (a += 1), e.leadingWildcardCount > this.thresholds.maxLeadingWildcards ? a += 2 : e.leadingWildcardCount > 0 && (a += 1), e.inListMaxSize > this.thresholds.maxInListSize ? a += 2 : e.inListMaxSize > 50 && (a += 1), e.postProcessingMutatorCount > 0 && (a += e.postProcessingMutatorCount), e.orChainLength > this.thresholds.maxOrChainLength && (a += 1);
+    const n = t.filter((s) => s.severity === "error").length;
+    return a += n * 2, a >= 4 ? "high" : a >= 2 ? "medium" : "low";
+  }
+}
+function r(i, e) {
+  return new x(e).analyze(i);
+}
+function L(i, e) {
+  return r(i, e).score === "high";
+}
+function z(i, e) {
+  return r(i, e).warnings;
+}
+function _(i) {
+  return r(i).metrics;
+}
+export {
+  x as ComplexityAnalyzer,
+  r as analyzeComplexity,
+  _ as getComplexityMetrics,
+  z as getComplexityWarnings,
+  L as isHighComplexity
+};

package/dist/src/fuzzyMatcher.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Fuzzy Matcher for TQL Autocompletion
+ *
+ * Provides fuzzy string matching for better autocomplete suggestions.
+ * Supports subsequence matching and calculates match scores.
+ */
+/**
+ * Match result with score and highlight positions
+ */
+export interface FuzzyMatchResult {
+    /** Whether the pattern matched */
+    matched: boolean;
+    /** Match score (higher is better). 0 = no match */
+    score: number;
+    /** Indices in the target string that matched */
+    matchedIndices: number[];
+}
+/**
+ * Options for fuzzy matching
+ */
+export interface FuzzyMatchOptions {
+    /** Bonus for consecutive character matches */
+    consecutiveBonus?: number;
+    /** Bonus for matching at word boundaries (after . or _) */
+    wordBoundaryBonus?: number;
+    /** Bonus for matching the first character */
+    firstCharBonus?: number;
+    /** Bonus for matching case exactly */
+    caseMatchBonus?: number;
+    /** Penalty for gaps between matches */
+    gapPenalty?: number;
+    /** Minimum score to consider a match */
+    minScore?: number;
+}
+/**
+ * Perform fuzzy matching of a pattern against a target string.
+ *
+ * Uses subsequence matching - all characters in the pattern must appear
+ * in the target in the same order, but not necessarily consecutively.
+ *
+ * @example
+ * fuzzyMatch("srcip", "source_ip") // matches: s-r-c-e_-i-p
+ * fuzzyMatch("hst", "hostname")    // matches: h-o-s-t-name
+ */
+export declare function fuzzyMatch(pattern: string, target: string, options?: FuzzyMatchOptions): FuzzyMatchResult;
+/**
+ * Calculate Levenshtein (edit) distance between two strings.
+ * Useful for typo detection and suggestions.
+ */
+export declare function levenshteinDistance(a: string, b: string): number;
+/**
+ * Find the closest match for a string from a list of candidates
+ * using Levenshtein distance.
+ */
+export declare function findClosestMatch(input: string, candidates: string[], maxDistance?: number): {
+    match: string;
+    distance: number;
+} | null;
+/**
+ * Filter and sort candidates by fuzzy match score
+ */
+export declare function fuzzyFilter<T>(pattern: string, candidates: T[], getText: (item: T) => string, options?: FuzzyMatchOptions): Array<{
+    item: T;
+    score: number;
+    matchedIndices: number[];
+}>;
+/**
+ * Generate highlighted HTML for a fuzzy match result.
+ * Wraps matched characters in a span with a highlight class.
+ */
+export declare function highlightMatch(text: string, matchedIndices: number[], highlightClass?: string): string;

package/dist/src/fuzzyMatcher.js

@@ -0,0 +1,110 @@
+const d = {
+  consecutiveBonus: 15,
+  wordBoundaryBonus: 10,
+  firstCharBonus: 8,
+  caseMatchBonus: 3,
+  gapPenalty: 1,
+  minScore: 0
+};
+function g(n, o, r = {}) {
+  const c = { ...d, ...r };
+  if (n.length === 0)
+    return { matched: !0, score: 0, matchedIndices: [] };
+  if (n.length > o.length)
+    return { matched: !1, score: 0, matchedIndices: [] };
+  const t = n.toLowerCase(), e = o.toLowerCase();
+  if (e.startsWith(t)) {
+    const h = Array.from({ length: n.length }, (f, u) => u);
+    return { matched: !0, score: m(n, o, c), matchedIndices: h };
+  }
+  const s = B(t, e, n, o, c);
+  return s.matchedIndices.length === n.length && s.score >= c.minScore ? { matched: !0, ...s } : { matched: !1, score: 0, matchedIndices: [] };
+}
+function m(n, o, r) {
+  let c = n.length * 10;
+  c += r.firstCharBonus, c += (n.length - 1) * r.consecutiveBonus;
+  for (let t = 0; t < n.length; t++)
+    n[t] === o[t] && (c += r.caseMatchBonus);
+  return n.toLowerCase() === o.toLowerCase() && (c += 50), c;
+}
+function B(n, o, r, c, t) {
+  const e = n.length, s = o.length, h = [];
+  let i = 0, f = 0, u = -1;
+  for (let l = 0; l < s && f < e; l++)
+    n[f] === o[l] && (h.push(l), i += 10, f === 0 && l === 0 && (i += t.firstCharBonus), u !== -1 && l === u + 1 ? i += t.consecutiveBonus : u !== -1 && (i -= (l - u - 1) * t.gapPenalty), (l === 0 || c[l - 1] === "." || c[l - 1] === "_") && (i += t.wordBoundaryBonus), r[f] === c[l] && (i += t.caseMatchBonus), u = l, f++);
+  return { score: Math.max(0, i), matchedIndices: h };
+}
+function a(n, o) {
+  const r = n.toLowerCase(), c = o.toLowerCase(), t = [];
+  for (let e = 0; e <= c.length; e++)
+    t[e] = [e];
+  for (let e = 0; e <= r.length; e++)
+    t[0][e] = e;
+  for (let e = 1; e <= c.length; e++)
+    for (let s = 1; s <= r.length; s++)
+      c.charAt(e - 1) === r.charAt(s - 1) ? t[e][s] = t[e - 1][s - 1] : t[e][s] = Math.min(
+        t[e - 1][s - 1] + 1,
+        // substitution
+        t[e][s - 1] + 1,
+        // insertion
+        t[e - 1][s] + 1
+        // deletion
+      );
+  return t[c.length][r.length];
+}
+function I(n, o, r = 3) {
+  if (o.length === 0)
+    return null;
+  let c = o[0], t = a(n, c);
+  for (let e = 1; e < o.length; e++) {
+    const s = a(n, o[e]);
+    s < t && (t = s, c = o[e]);
+  }
+  return t <= r ? { match: c, distance: t } : null;
+}
+function M(n, o, r, c = {}) {
+  const t = [];
+  for (const e of o) {
+    const s = r(e), h = g(n, s, c);
+    h.matched && t.push({
+      item: e,
+      score: h.score,
+      matchedIndices: h.matchedIndices
+    });
+  }
+  return t.sort((e, s) => s.score - e.score), t;
+}
+function C(n, o, r = "tql-fuzzy-highlight") {
+  if (o.length === 0)
+    return n;
+  const c = new Set(o);
+  let t = "", e = !1;
+  for (let s = 0; s < n.length; s++) {
+    const h = c.has(s);
+    h && !e ? (t += `<span class="${r}">`, e = !0) : !h && e && (t += "</span>", e = !1), t += w(n[s]);
+  }
+  return e && (t += "</span>"), t;
+}
+function w(n) {
+  switch (n) {
+    case "&":
+      return "&amp;";
+    case "<":
+      return "&lt;";
+    case ">":
+      return "&gt;";
+    case '"':
+      return "&quot;";
+    case "'":
+      return "&#39;";
+    default:
+      return n;
+  }
+}
+export {
+  I as findClosestMatch,
+  M as fuzzyFilter,
+  g as fuzzyMatch,
+  C as highlightMatch,
+  a as levenshteinDistance
+};

package/dist/src/index.d.ts

@@ -11,3 +11,8 @@ export { TqlTokenizer, tokenizeTql, tokenizeTqlNoWhitespace, findTokenAtPosition
 export { TqlParser, parseTql, isValidTql, getTqlErrors, formatParseError } from './parser';
 export { TqlValidator, validateTql, isValidTqlSyntax, getTqlIssues, formatValidationResult } from './validator';
 export { getCompletions, getWordAtPosition, getCompletionTriggerCharacters, shouldTriggerCompletion } from './completionProvider';
+export { fuzzyMatch, levenshteinDistance, findClosestMatch, fuzzyFilter, highlightMatch, type FuzzyMatchResult, type FuzzyMatchOptions } from './fuzzyMatcher';
+export { SchemaCache, getSchemaCache, createSchemaCache, getCachedFieldNames, getCachedFieldType, getCachedField, type CachedSchema } from './schemaCache';
+export { ComplexityAnalyzer, analyzeComplexity, isHighComplexity, getComplexityWarnings, getComplexityMetrics } from './complexityAnalyzer';
+export { SemanticPreview, generatePreview, getFieldUsage, getLogicTree, getUniqueFields, getOperatorSummary, formatLogicTreeNode, formatLogicTreeAscii, flattenLogicTree, getLogicTreeDepth } from './semanticPreview';
+export type { ComplexityScore, ComplexityWarning, ComplexityWarningType, ComplexityMetrics, ComplexityResult, ComplexityThresholds, MatchType, FieldUsage, LogicTreeNodeType, LogicTreeNode, PreviewResult, QueryHistoryEntry, UseQueryHistoryOptions } from './types';

package/dist/src/parser.d.ts

@@ -62,6 +62,16 @@ export declare class TqlParser {
     private matchLogical;
     private addError;
     private addWarning;
+    /**
+     * Synchronize parser state after an error by advancing to a recovery point.
+     * Recovery points are: logical operators (AND, OR, NOT), closing parens, or EOF.
+     */
+    private synchronize;
+    /**
+     * Create a placeholder expression for error recovery.
+     * This allows the parser to continue and find additional errors.
+     */
+    private createPlaceholderExpression;
 }
 /**
  * Parse a TQL query string