@tellaro/tql 0.1.0 → 0.1.2

package/dist/src/parser.js

@@ -1,9 +1,9 @@
 var c = Object.defineProperty;
-var p = (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) => p(r, typeof e != "symbol" ? e + "" : e, t);
-import { tokenizeTql as d, COMPARISON_OPERATORS as v } from "./tokenizer.js";
-const k = 50;
-class f {
+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 } from "./tokenizer.js";
+const f = 50, k = /* @__PURE__ */ new Set(["logicalOp", "paren"]);
+class y {
   constructor(e) {
     o(this, "tokens");
     o(this, "allTokens");
@@ -12,7 +12,7 @@ class f {
     o(this, "errors");
     o(this, "warnings");
     o(this, "depth");
-    this.allTokens = d(e), this.tokens = this.allTokens.filter((t) => t.type !== "whitespace"), this.current = 0, this.errors = [], this.warnings = [], this.depth = 0;
+    this.allTokens = p(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
@@ -61,7 +61,7 @@ class f {
    * Parse a full expression (lowest precedence)
    */
   parseExpression() {
-    if (this.depth++, this.depth > k)
+    if (this.depth++, this.depth > f)
       throw new Error("Maximum query depth exceeded");
     try {
       return this.parseOr();
@@ -75,14 +75,22 @@ class f {
   parseOr() {
     let e = this.parseAnd();
     for (; this.matchLogical("OR"); ) {
-      const t = this.parseAnd();
+      const t = this.previous();
+      if (this.isAtEnd())
+        return this.addError(
+          "Expected expression after 'OR'",
+          t,
+          "MISSING_OPERAND",
+          "Add a condition after 'OR'"
+        ), e;
+      const n = this.parseAnd();
       e = {
         type: "binary",
         operator: "OR",
         left: e,
-        right: t,
+        right: n,
         start: e.start,
-        end: t.end
+        end: n.end
       };
     }
     return e;
@@ -93,14 +101,22 @@ class f {
   parseAnd() {
     let e = this.parseUnary();
     for (; this.matchLogical("AND"); ) {
-      const t = this.parseUnary();
+      const t = this.previous();
+      if (this.isAtEnd())
+        return this.addError(
+          "Expected expression after 'AND'",
+          t,
+          "MISSING_OPERAND",
+          "Add a condition after 'AND'"
+        ), e;
+      const n = this.parseUnary();
       e = {
         type: "binary",
         operator: "AND",
         left: e,
-        right: t,
+        right: n,
         start: e.start,
-        end: t.end
+        end: n.end
       };
     }
     return e;
@@ -130,14 +146,14 @@ class f {
     if (this.check("field") || this.check("aggregation") || this.check("mutator") || this.check("typeHint"))
       return this.parseComparison();
     const e = this.peek();
-    if (this.addError(
+    this.addError(
       `Expected field name or '(' but found '${e.value}'`,
       e,
       "UNEXPECTED_TOKEN",
       "Start with a field name like 'hostname' or 'status'"
-    ), this.advance(), !this.isAtEnd())
-      return this.parsePrimary();
-    throw new Error("Parser recovery failed");
+    );
+    const t = this.createPlaceholderExpression(e);
+    return this.synchronize(), t;
   }
   /**
    * Parse a grouped expression
@@ -181,14 +197,14 @@ class f {
           "Valid types: string, int, float, date, bool, array"
         );
       }
-    const i = [];
+    const n = [];
     for (; this.check("pipe"); )
       if (this.advance(), this.check("mutator")) {
         const s = this.advance();
-        i.push(s.value.toLowerCase());
+        n.push(s.value.toLowerCase());
       } else if (this.check("field")) {
         const s = this.advance();
-        i.push(s.value.toLowerCase()), this.addWarning(`Unknown mutator '${s.value}'`, s, "Check the mutator name spelling");
+        n.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(
@@ -199,12 +215,12 @@ class f {
         );
         break;
       }
-    if (i.length > 0 && (t = {
+    if (n.length > 0 && (t = {
       ...t,
-      mutators: i,
+      mutators: n,
       end: this.previous().end
     }), !this.check("operator")) {
-      const s = this.isAtEnd() ? this.previous() : this.peek(), h = i.length > 0 ? `'${e.value}' with mutator` : `'${e.value}'`;
+      const s = this.isAtEnd() ? this.previous() : this.peek(), h = n.length > 0 ? `'${e.value}' with mutator` : `'${e.value}'`;
       return this.addError(
         `Expected operator after field ${h}`,
         s,
@@ -225,7 +241,7 @@ class f {
         end: t.end
       };
     }
-    const n = this.advance(), a = this.normalizeOperator(n.value);
+    const i = this.advance(), a = this.normalizeOperator(i.value);
     if (a === "exists" || a === "not_exists")
       return {
         type: "comparison",
@@ -235,11 +251,11 @@ class f {
           type: "literal",
           valueType: "boolean",
           value: !0,
-          start: n.end,
-          end: n.end
+          start: i.end,
+          end: i.end
         },
         start: t.start,
-        end: n.end
+        end: i.end
       };
     if ((a === "is" || a === "is_not") && this.check("null")) {
       const s = this.advance();
@@ -290,7 +306,7 @@ class f {
     if (this.isAtEnd())
       return this.addError(
         `Expected a value after operator '${a}'`,
-        n,
+        i,
         "MISSING_VALUE",
         'Add a value like "text", 123, or true'
       ), {
@@ -301,11 +317,11 @@ class f {
           type: "literal",
           valueType: "string",
           value: "",
-          start: n.end,
-          end: n.end
+          start: i.end,
+          end: i.end
         },
         start: t.start,
-        end: n.end
+        end: i.end
       };
     const l = this.parseValue();
     return {
@@ -405,7 +421,7 @@ class f {
     };
   }
   normalizeOperator(e) {
-    const t = e.toLowerCase(), i = {
+    const t = e.toLowerCase(), n = {
       "==": "eq",
       "=": "eq",
       "!=": "ne",
@@ -414,9 +430,9 @@ class f {
       "<": "lt",
       "<=": "lte"
     };
-    if (e in i)
-      return i[e];
-    const n = {
+    if (e in n)
+      return n[e];
+    const i = {
       "!in": "not_in",
       "!contains": "not_contains",
       "!startswith": "not_startswith",
@@ -431,8 +447,8 @@ class f {
       "!all": "not_all",
       "!none": "not_none"
     };
-    if (t in n)
-      return n[t];
+    if (t in i)
+      return i[t];
     const a = {
       regex: "regexp",
       starts_with: "startswith",
@@ -464,7 +480,7 @@ class f {
   matchLogical(e) {
     return this.check("logicalOp") && this.peek().value.toUpperCase() === e ? (this.advance(), !0) : !1;
   }
-  addError(e, t, i, n) {
+  addError(e, t, n, i) {
     this.errors.push({
       message: e,
       start: t.start,
@@ -472,11 +488,11 @@ class f {
       line: t.line,
       column: t.column,
       severity: "error",
-      code: i,
-      suggestion: n
+      code: n,
+      suggestion: i
     });
   }
-  addWarning(e, t, i) {
+  addWarning(e, t, n) {
     this.warnings.push({
       message: e,
       start: t.start,
@@ -485,27 +501,64 @@ class f {
       column: t.column,
       severity: "warning",
       code: "TYPE_MISMATCH",
-      suggestion: i
+      suggestion: n
     });
   }
+  /**
+   * Synchronize parser state after an error by advancing to a recovery point.
+   * Recovery points are: logical operators (AND, OR, NOT), closing parens, or EOF.
+   */
+  synchronize() {
+    for (this.advance(); !this.isAtEnd(); ) {
+      if (k.has(this.peek().type) || this.peek().type === "paren" && this.peek().value === ")")
+        return;
+      this.advance();
+    }
+  }
+  /**
+   * Create a placeholder expression for error recovery.
+   * This allows the parser to continue and find additional errors.
+   */
+  createPlaceholderExpression(e) {
+    return {
+      type: "comparison",
+      field: {
+        type: "field",
+        name: "_error_",
+        path: ["_error_"],
+        start: e.start,
+        end: e.end
+      },
+      operator: "exists",
+      value: {
+        type: "literal",
+        valueType: "boolean",
+        value: !0,
+        start: e.start,
+        end: e.end
+      },
+      start: e.start,
+      end: e.end
+    };
+  }
 }
 function u(r) {
-  return new f(r).parse();
+  return new y(r).parse();
 }
 function g(r) {
   return u(r).success;
 }
-function E(r) {
+function A(r) {
   return u(r).errors;
 }
-function w(r) {
+function T(r) {
   let e = `Error at line ${r.line}, column ${r.column}: ${r.message}`;
   return r.suggestion && (e += ` (${r.suggestion})`), e;
 }
 export {
-  f as TqlParser,
-  w as formatParseError,
-  E as getTqlErrors,
+  y as TqlParser,
+  T as formatParseError,
+  A as getTqlErrors,
   g as isValidTql,
   u as parseTql
 };

package/dist/src/schemaCache.d.ts

@@ -0,0 +1,75 @@
+import { TqlFieldSchema, TqlFieldType } from './types';
+
+/**
+ * Cached schema data with O(1) lookups
+ */
+export interface CachedSchema {
+    /** Original schema array */
+    fields: TqlFieldSchema[];
+    /** Map of field name to schema for O(1) lookup */
+    fieldMap: Map<string, TqlFieldSchema>;
+    /** Map of field name to type for O(1) type lookup */
+    typeMap: Map<string, TqlFieldType>;
+    /** All field names including nested fields */
+    allFieldNames: string[];
+    /** Hash of the schema for change detection */
+    hash: string;
+    /** Timestamp when cache was created */
+    timestamp: number;
+}
+/**
+ * Schema cache manager
+ */
+export declare class SchemaCache {
+    private cache;
+    /**
+     * Get cached schema data, rebuilding if schema has changed.
+     * Returns null if no schema provided.
+     */
+    get(schema?: TqlFieldSchema[]): CachedSchema | null;
+    /**
+     * Invalidate the cache
+     */
+    invalidate(): void;
+    /**
+     * Check if cache is valid for a given schema
+     */
+    isValid(schema?: TqlFieldSchema[]): boolean;
+    /**
+     * Get field by name with O(1) lookup
+     */
+    getField(schema: TqlFieldSchema[] | undefined, fieldName: string): TqlFieldSchema | undefined;
+    /**
+     * Get field type by name with O(1) lookup
+     */
+    getFieldType(schema: TqlFieldSchema[] | undefined, fieldName: string): TqlFieldType | undefined;
+    /**
+     * Build the cache from a schema
+     */
+    private buildCache;
+    /**
+     * Compute a hash for schema change detection.
+     * Uses a simple string-based hash for performance.
+     */
+    private computeHash;
+}
+/**
+ * Get the global schema cache instance
+ */
+export declare function getSchemaCache(): SchemaCache;
+/**
+ * Create a new schema cache instance (useful for isolated testing)
+ */
+export declare function createSchemaCache(): SchemaCache;
+/**
+ * Utility: Get field names from schema using cache
+ */
+export declare function getCachedFieldNames(schema?: TqlFieldSchema[]): string[];
+/**
+ * Utility: Get field type from schema using cache
+ */
+export declare function getCachedFieldType(schema: TqlFieldSchema[] | undefined, fieldName: string): TqlFieldType | undefined;
+/**
+ * Utility: Get field from schema using cache
+ */
+export declare function getCachedField(schema: TqlFieldSchema[] | undefined, fieldName: string): TqlFieldSchema | undefined;

package/dist/src/schemaCache.js

@@ -0,0 +1,104 @@
+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);
+  }
+  /**
+   * Get cached schema data, rebuilding if schema has changed.
+   * Returns null if no schema provided.
+   */
+  get(e) {
+    if (!e || e.length === 0)
+      return null;
+    const t = this.computeHash(e);
+    return this.cache && this.cache.hash === t ? this.cache : (this.cache = this.buildCache(e, t), this.cache);
+  }
+  /**
+   * Invalidate the cache
+   */
+  invalidate() {
+    this.cache = null;
+  }
+  /**
+   * Check if cache is valid for a given schema
+   */
+  isValid(e) {
+    return !e || e.length === 0 ? this.cache === null : this.cache ? this.cache.hash === this.computeHash(e) : !1;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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);
+    };
+    for (const a of e)
+      c(a);
+    return {
+      fields: e,
+      fieldMap: n,
+      typeMap: h,
+      allFieldNames: i,
+      hash: t,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Compute a hash for schema change detection.
+   * 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);
+  }
+}
+let l = null;
+function u() {
+  return l || (l = new p()), l;
+}
+function C() {
+  return new p();
+}
+function y(s) {
+  const e = u().get(s);
+  return (e == null ? void 0 : e.allFieldNames) ?? [];
+}
+function M(s, e) {
+  return u().getFieldType(s, e);
+}
+function w(s, e) {
+  return u().getField(s, e);
+}
+export {
+  p as SchemaCache,
+  C as createSchemaCache,
+  w as getCachedField,
+  y as getCachedFieldNames,
+  M as getCachedFieldType,
+  u as getSchemaCache
+};

package/dist/src/semanticPreview.d.ts

@@ -0,0 +1,72 @@
+import { FieldUsage, LogicTreeNode, PreviewResult } from './types';
+
+export declare class SemanticPreview {
+    /**
+     * Generate a complete preview for a TQL query
+     */
+    generatePreview(query: string): PreviewResult;
+    /**
+     * Extract field usage information from an expression
+     */
+    private extractFieldUsage;
+    private extractFromBinary;
+    private extractFromUnary;
+    private extractFromGroup;
+    private extractFromComparison;
+    /**
+     * Get field name and mutators from field reference or mutator expression
+     */
+    private getFieldInfo;
+    /**
+     * Determine the match type based on operator and value
+     */
+    private determineMatchType;
+    /**
+     * Extract the actual value(s) from literal(s)
+     */
+    private extractValue;
+    /**
+     * Build a logic tree from the AST
+     */
+    private buildLogicTree;
+    private buildBinaryNode;
+    private buildUnaryNode;
+    private buildComparisonNode;
+    private buildGroupNode;
+}
+/**
+ * Generate a preview for a TQL query
+ */
+export declare function generatePreview(query: string): PreviewResult;
+/**
+ * Get field usage information from a query
+ */
+export declare function getFieldUsage(query: string): FieldUsage[];
+/**
+ * Get the logic tree for a query
+ */
+export declare function getLogicTree(query: string): LogicTreeNode | null;
+/**
+ * Get unique field names used in a query
+ */
+export declare function getUniqueFields(query: string): string[];
+/**
+ * Get operator summary for a query
+ */
+export declare function getOperatorSummary(query: string): Record<string, number>;
+/**
+ * Format a logic tree node as a human-readable string
+ */
+export declare function formatLogicTreeNode(node: LogicTreeNode): string;
+/**
+ * Generate an ASCII tree representation of the logic tree
+ */
+export declare function formatLogicTreeAscii(node: LogicTreeNode | null, indent?: string): string;
+/**
+ * Flatten a logic tree to just the comparison nodes
+ */
+export declare function flattenLogicTree(node: LogicTreeNode | null): LogicTreeNode[];
+/**
+ * Get the depth of a logic tree
+ */
+export declare function getLogicTreeDepth(node: LogicTreeNode | null): number;