@tellaro/tql 3.0.1 → 3.0.2

package/dist/src/types.d.ts

@@ -276,7 +276,16 @@ export interface TqlValidationResult {
 }
 export interface TqlValidationOptions {
     availableFields?: string[];
-    fieldTypes?: Record<string, TqlFieldType>;
+    /**
+     * Declared type per field name.
+     *
+     * An ARRAY means the field is mapped more than one way across the index pattern the
+     * schema describes -- `text` in one index and `keyword` in another is the ordinary way
+     * to get there, and the engines answer such a field with a disjunction over both forms
+     * (see `TypeDivergence` in the Rust engine). A single type is the common case and
+     * behaves exactly as before.
+     */
+    fieldTypes?: Record<string, TqlFieldType | TqlFieldType[]>;
     strictMode?: boolean;
     allowAggregations?: boolean;
     allowMutators?: boolean;

package/dist/src/validator.d.ts

@@ -82,40 +82,7 @@ export declare const CASE_SENSITIVE_WHOLE_VALUE_OPERATORS: TqlComparisonOperator
 export declare const CASE_SENSITIVE_MEMBERSHIP_OPERATORS: TqlComparisonOperator[];
 /** Every spelling of every case-SENSITIVE operator — the union of the two families above. */
 export declare const CASE_SENSITIVE_OPERATORS: TqlComparisonOperator[];
-/**
- * Whether a field offers a CASE-PRESERVING form, as far as the supplied schema shows.
- *
- * This is the field half of the engines' rule, on its own because the two `_cs` operator
- * families consume it differently (see `caseSensitiveSupport`, which is the function you
- * probably want).
- *
- *   * `"present"` — the field itself is `keyword`, or it has a `keyword` subfield. One whole
- *     value, one indexed term, case intact.
- *   * `"absent"` — no such form. That covers analyzed `text` with no `keyword` sibling AND
- *     every non-string type: a `long`, `ip`, `date` or `boolean` field has no un-analyzed
- *     STRING form either. Whether that matters depends on the operator, which is why this
- *     function does not decide it.
- *   * `"unknown"` — no `fieldTypes` was supplied, or this field is not in it.
- *
- * Mirrors `FieldMappings::unanalyzed_form` (Rust) and `FieldMapping.unanalyzed_field`
- * (Python) as closely as a flat name→type map allows. Two documented divergences, both of
- * which fail quiet — see `caseSensitiveSupport`.
- *
- * ## The sibling test is on TYPE, not on the name `.keyword`
- *
- * Both engines scan a field's declared subfields for one whose TYPE is `keyword` (Rust:
- * `subfield_of(field, |t| *t == FieldType::Keyword)`; Python: `keyword_field`, set for any
- * subfield with `"type": "keyword"`). A multifield named `.raw` or `.kw` answers exactly as
- * well as one named `.keyword`, and hard-coding the name would report `"absent"` on a working
- * mapping. So this walks the map for `${field}.` prefixed entries and looks at their type.
- *
- * ## One level down, matching the engines
- *
- * A subfield is a DIRECT child: both engines read a declared `subfields` map, so
- * `f.sub.deep` is not a subfield of `f` to either of them. Scanning descendants at any depth
- * would report `"present"` for a mapping the engines refuse.
- */
-export declare function casePreservingForm(field: string, fieldTypes?: Record<string, TqlFieldType>): "present" | "absent" | "unknown";
+export declare function casePreservingForm(field: string, fieldTypes?: Record<string, TqlFieldType | TqlFieldType[]>): "present" | "absent" | "unknown";
 /**
  * Whether a field can answer a case-SENSITIVE operator, as far as the supplied schema shows.
  *
@@ -180,7 +147,7 @@ export declare function casePreservingForm(field: string, fieldTypes?: Record<st
  *   distinguish the two `text` shapes it must ALSO contain the multifield entries
  *   (`message.keyword`), which is what an index-mapping flattener naturally produces.
  */
-export declare function caseSensitiveSupport(field: string, operator: TqlComparisonOperator, fieldTypes?: Record<string, TqlFieldType>): CaseSensitiveSupport;
+export declare function caseSensitiveSupport(field: string, operator: TqlComparisonOperator, fieldTypes?: Record<string, TqlFieldType | TqlFieldType[]>): CaseSensitiveSupport;
 export declare class TqlValidator {
     private options;
     private errors;

package/dist/src/validator.js

@@ -1,5 +1,5 @@
-import { parseTql as w } from "./parser.js";
-const u = 1e3, r = [
+import { parseTql as p } from "./parser.js";
+const g = 1e3, r = [
   "text",
   "keyword",
   "long",
@@ -17,7 +17,7 @@ const u = 1e3, r = [
   "nested",
   "object",
   "geo_point"
-], h = [
+], _ = [
   "long",
   "integer",
   "short",
@@ -27,7 +27,7 @@ const u = 1e3, r = [
   "half_float",
   "scaled_float",
   "unsigned_long"
-], l = [...h, "date", "keyword"], c = [...h, "date"], y = {
+], l = [..._, "date", "keyword"], u = [..._, "date"], b = {
   // Equality (all types) — and now that is what it says.
   //
   // The transcribed twelve-element list this replaces claimed "all types" while omitting
@@ -157,9 +157,9 @@ const u = 1e3, r = [
   // `keyword` and `text` stay out, and that is a decision rather than an omission: Python's
   // `keyword_ops` excludes `between` while including `gte`, which is the divergence pinned
   // in `tests/collectionAndNullSemantics.spec.ts`.
-  between: c,
-  not_between: c,
-  "!between": c,
+  between: u,
+  not_between: u,
+  "!between": u,
   // Membership — the same set as `eq`, because `in` IS a disjunction of equalities and both
   // evaluators implement it that way. The transcribed list this replaces omitted the five
   // narrow numeric widths plus `nested`, `object` and `geo_point`.
@@ -226,11 +226,11 @@ const u = 1e3, r = [
   "!any": r,
   "!all": r,
   "!none": r
-}, g = {
+}, h = {
   cidr: ["ip"],
   not_cidr: ["ip"],
   "!cidr": ["ip"]
-}, p = [
+}, m = [
   "contains_cs",
   "not_contains_cs",
   "!contains_cs",
@@ -240,35 +240,44 @@ const u = 1e3, r = [
   "endswith_cs",
   "not_endswith_cs",
   "!endswith_cs"
-], _ = [
+], f = [
   "in_cs",
   "not_in_cs",
   "!in_cs"
-], b = [
-  ...p,
-  ..._
+], v = [
+  ...m,
+  ...f
 ];
-function m(o, t) {
+function c(o, t) {
+  const e = t?.[o];
+  return e === void 0 ? [] : Array.isArray(e) ? e : [e];
+}
+function E(o, t) {
   if (!t)
     return "unknown";
-  const e = t[o];
-  if (!e)
+  const e = c(o, t);
+  if (e.length === 0)
     return "unknown";
-  if (e === "keyword" || t[`${o}.keyword`] === "keyword")
+  if (e.includes("keyword") || c(`${o}.keyword`, t).includes("keyword"))
     return "present";
   const i = `${o}.`;
   for (const [n, s] of Object.entries(t))
-    if (!(s !== "keyword" || !n.startsWith(i)) && !n.slice(i.length).includes("."))
+    if (!(!(Array.isArray(s) ? s : [s]).includes("keyword") || !n.startsWith(i)) && !n.slice(i.length).includes("."))
       return "present";
   return "absent";
 }
-function v(o, t, e) {
-  if (!b.includes(t))
+function k(o, t, e) {
+  if (!v.includes(t))
     return "supported";
-  const i = m(o, e);
-  return i !== "absent" ? i === "present" ? "supported" : "unknown" : _.includes(t) ? e?.[o] === "text" ? "unsupported" : "supported" : "unsupported";
+  const i = E(o, e);
+  if (i !== "absent")
+    return i === "present" ? "supported" : "unknown";
+  if (!f.includes(t))
+    return "unsupported";
+  const n = c(o, e);
+  return n.length > 0 && n.every((s) => s === "text") ? "unsupported" : "supported";
 }
-const E = {
+const T = {
   eq: ["string", "number", "boolean"],
   ne: ["string", "number", "boolean"],
   "=": ["string", "number", "boolean"],
@@ -337,7 +346,7 @@ const E = {
   "!all": ["string", "number", "boolean"],
   "!none": ["string", "number", "boolean"]
 };
-class k {
+class A {
   options;
   errors;
   warnings;
@@ -350,7 +359,7 @@ class k {
   validate(t) {
     if (this.errors = [], this.warnings = [], !t)
       return { valid: !0, errors: [], warnings: [] };
-    const e = w(t);
+    const e = p(t);
     return this.errors.push(...e.errors), this.warnings.push(...e.warnings), e.ast && this.validateExpression(e.ast), {
       valid: this.errors.length === 0,
       errors: this.errors,
@@ -477,22 +486,22 @@ class k {
       "UNKNOWN_FIELD",
       `Did you mean: ${this.suggestField(e)}`
     ), this.options.fieldTypes && t.field.type === "field") {
-      const n = this.options.fieldTypes[e];
-      if (n) {
-        const s = g[t.operator];
-        s && !s.includes(n) && this.addError(
-          `Operator '${t.operator}' requires field type ${s.join(" or ")}, but '${e}' is type '${n}'`,
+      const n = c(e, this.options.fieldTypes), s = n.join(" or ");
+      if (n.length > 0) {
+        const a = h[t.operator];
+        a && !n.some((d) => a.includes(d)) && this.addError(
+          `Operator '${t.operator}' requires field type ${a.join(" or ")}, but '${e}' is type '${s}'`,
           t.start,
           t.end,
           1,
           1,
           "TYPE_MISMATCH",
-          `Use '${t.operator}' only with ${s.join(" or ")} fields`
+          `Use '${t.operator}' only with ${a.join(" or ")} fields`
         );
       }
     }
     let i = !1;
-    if (t.field.type === "field" && v(e, t.operator, this.options.fieldTypes) === "unsupported") {
+    if (t.field.type === "field" && k(e, t.operator, this.options.fieldTypes) === "unsupported") {
       i = !0;
       const n = t.operator.replace(/_cs$/, ""), s = this.options.fieldTypes?.[e], a = s === "text" ? `'${e}' is an analyzed text field with no case-preserving subfield in the supplied schema, so the analyzer lowercased every token it indexed and the case '${t.operator}' asks about is not in the index` : `'${e}' is type '${s}' and has no un-analyzed string form, which is what '${t.operator}' matches against`;
       this.addWarning(
@@ -513,22 +522,22 @@ class k {
       );
     }
     if (this.options.fieldTypes && t.field.type === "field") {
-      const n = this.options.fieldTypes[e];
-      if (n) {
-        const s = y[t.operator], a = g[t.operator];
-        !i && !a && s && !s.includes(n) && this.addWarning(
-          `Operator '${t.operator}' may not work well with field type '${n}'`,
+      const n = c(e, this.options.fieldTypes), s = n.join(" or ");
+      if (n.length > 0) {
+        const a = b[t.operator], d = h[t.operator];
+        !i && !d && a && !n.some((y) => a.includes(y)) && this.addWarning(
+          `Operator '${t.operator}' may not work well with field type '${s}'`,
           t.start,
           t.end,
           1,
           1,
           "TYPE_MISMATCH",
-          `Consider using a different operator for ${n} fields`
+          `Consider using a different operator for ${s} fields`
         );
       }
     }
     if (!Array.isArray(t.value) && t.value.type === "literal") {
-      const n = E[t.operator];
+      const n = T[t.operator];
       n && !n.includes(t.value.valueType) && this.addWarning(
         `Operator '${t.operator}' expects ${n.join(" or ")} value`,
         t.value.start,
@@ -540,9 +549,9 @@ class k {
     }
     if ((t.operator === "regexp" || t.operator === "regex" || t.operator === "not_regexp" || t.operator === "not_regex" || t.operator === "matches" || t.operator === "not_matches") && !Array.isArray(t.value) && t.value.valueType === "string" && typeof t.value.value == "string") {
       const n = Array.from(t.value.value).length;
-      if (n > u)
+      if (n > g)
         this.addError(
-          `Regex pattern is ${n} characters, which exceeds the maximum supported length of ${u}. The query cannot run as written.`,
+          `Regex pattern is ${n} characters, which exceeds the maximum supported length of ${g}. The query cannot run as written.`,
           t.value.start,
           t.value.end,
           1,
@@ -622,17 +631,17 @@ class k {
     });
   }
 }
-function f(o, t) {
-  return new k(t).validate(o);
+function w(o, t) {
+  return new A(t).validate(o);
 }
-function $(o) {
-  return f(o).valid;
+function I(o) {
+  return w(o).valid;
 }
-function A(o, t) {
-  const e = f(o, t);
+function S(o, t) {
+  const e = w(o, t);
   return [...e.errors, ...e.warnings];
 }
-function I(o) {
+function R(o) {
   const t = [];
   o.valid ? t.push("Query is valid") : t.push("Query has errors:");
   for (const e of o.errors)
@@ -644,18 +653,18 @@ function I(o) {
 }
 export {
   r as ALL_FIELD_TYPES,
-  c as BETWEEN_FIELD_TYPES,
-  _ as CASE_SENSITIVE_MEMBERSHIP_OPERATORS,
-  b as CASE_SENSITIVE_OPERATORS,
-  p as CASE_SENSITIVE_WHOLE_VALUE_OPERATORS,
-  u as MAX_REGEX_PATTERN_LENGTH,
-  h as NUMERIC_FIELD_TYPES,
+  u as BETWEEN_FIELD_TYPES,
+  f as CASE_SENSITIVE_MEMBERSHIP_OPERATORS,
+  v as CASE_SENSITIVE_OPERATORS,
+  m as CASE_SENSITIVE_WHOLE_VALUE_OPERATORS,
+  g as MAX_REGEX_PATTERN_LENGTH,
+  _ as NUMERIC_FIELD_TYPES,
   l as ORDERED_FIELD_TYPES,
-  k as TqlValidator,
-  m as casePreservingForm,
-  v as caseSensitiveSupport,
-  I as formatValidationResult,
-  A as getTqlIssues,
-  $ as isValidTqlSyntax,
-  f as validateTql
+  A as TqlValidator,
+  E as casePreservingForm,
+  k as caseSensitiveSupport,
+  R as formatValidationResult,
+  S as getTqlIssues,
+  I as isValidTqlSyntax,
+  w as validateTql
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tellaro/tql",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Tellaro Query Language (TQL) parser, validator, and autocomplete for JavaScript/TypeScript",
   "type": "module",
   "main": "./dist/index.js",