@pythia-software/query-table-core 0.1.0

package/dist/index.js

@@ -0,0 +1,859 @@
+// src/query.ts
+var EMPTY_QUERY = {
+  select: [],
+  where: [],
+  orderBy: [],
+  limit: 100,
+  offset: 0
+};
+var MAX_QUERY_LIMIT = 1e3;
+var MAX_QUERY_OFFSET = 1e6;
+var MAX_SELECT_COLUMNS = 200;
+var MAX_WHERE_CLAUSES = 100;
+var MAX_ORDER_BY_TERMS = 20;
+var MAX_AGGREGATIONS = 20;
+var MAX_GROUP_BY_FIELDS = 20;
+var MAX_QUERY_TOKEN_LENGTH = 2 * 1024 * 1024;
+var MAX_FIELD_NAME_LENGTH = 256;
+var MAX_FILTER_VALUE_LENGTH = 1e4;
+var MAX_LABEL_LENGTH = 1e3;
+var MIN_COLUMN_WIDTH = 24;
+var MAX_COLUMN_WIDTH = 2e3;
+var FILTER_OPS = /* @__PURE__ */ new Set([
+  "=",
+  "!=",
+  ">",
+  ">=",
+  "<",
+  "<=",
+  "contains",
+  "starts_with",
+  "ends_with",
+  "includes",
+  "is_null",
+  "is_not_null"
+]);
+var AGG_OPS = /* @__PURE__ */ new Set(["count", "count_distinct", "sum", "avg", "min", "max"]);
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function boundedString(value, maxLength) {
+  return typeof value === "string" && value.length > 0 && value.length <= maxLength ? value : null;
+}
+function boundedInteger(value, fallback, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.min(max, Math.round(value)));
+}
+function normalizeQueryState(input, fallback = EMPTY_QUERY) {
+  const raw = isRecord(input) ? input : {};
+  const select = [];
+  if (Array.isArray(raw.select)) {
+    for (const item of raw.select.slice(0, MAX_SELECT_COLUMNS)) {
+      if (!isRecord(item)) continue;
+      const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
+      if (!field) continue;
+      const column = { field };
+      if (typeof item.width === "number" && Number.isFinite(item.width)) {
+        column.width = boundedInteger(item.width, MIN_COLUMN_WIDTH, MIN_COLUMN_WIDTH, MAX_COLUMN_WIDTH);
+      }
+      select.push(column);
+    }
+  } else {
+    select.push(...fallback.select.map((column) => ({ ...column })));
+  }
+  const where = [];
+  if (Array.isArray(raw.where)) {
+    for (const item of raw.where.slice(0, MAX_WHERE_CLAUSES)) {
+      if (!isRecord(item)) continue;
+      const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
+      const value = typeof item.value === "string" && item.value.length <= MAX_FILTER_VALUE_LENGTH ? item.value : null;
+      if (!field || typeof item.op !== "string" || !FILTER_OPS.has(item.op) || value == null) continue;
+      where.push({ field, op: item.op, value });
+    }
+  } else {
+    where.push(...fallback.where.map((clause) => ({ ...clause })));
+  }
+  const orderBy = [];
+  if (Array.isArray(raw.orderBy)) {
+    for (const item of raw.orderBy.slice(0, MAX_ORDER_BY_TERMS)) {
+      if (!isRecord(item)) continue;
+      const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
+      if (!field || item.dir !== "asc" && item.dir !== "desc") continue;
+      const term = { field, dir: item.dir };
+      if (item.nulls === "first" || item.nulls === "last") term.nulls = item.nulls;
+      orderBy.push(term);
+    }
+  } else {
+    orderBy.push(...fallback.orderBy.map((term) => ({ ...term })));
+  }
+  const out = {
+    select,
+    where,
+    orderBy,
+    limit: boundedInteger(raw.limit, fallback.limit, 1, MAX_QUERY_LIMIT),
+    offset: boundedInteger(raw.offset, fallback.offset, 0, MAX_QUERY_OFFSET)
+  };
+  if (Array.isArray(raw.aggregations)) {
+    const aggregations = [];
+    for (const item of raw.aggregations.slice(0, MAX_AGGREGATIONS)) {
+      if (!isRecord(item)) continue;
+      const id = boundedString(item.id, MAX_FIELD_NAME_LENGTH);
+      if (!id || typeof item.op !== "string" || !AGG_OPS.has(item.op) || !Array.isArray(item.groupBy)) continue;
+      const groupBy = item.groupBy.slice(0, MAX_GROUP_BY_FIELDS).map((field2) => boundedString(field2, MAX_FIELD_NAME_LENGTH)).filter((field2) => field2 != null);
+      const aggregation = { id, op: item.op, groupBy };
+      const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
+      const label = boundedString(item.label, MAX_LABEL_LENGTH);
+      if (field) aggregation.field = field;
+      if (label) aggregation.label = label;
+      aggregations.push(aggregation);
+    }
+    if (aggregations.length > 0) out.aggregations = aggregations;
+  } else if (fallback.aggregations?.length) {
+    out.aggregations = fallback.aggregations.map((aggregation) => ({ ...aggregation, groupBy: [...aggregation.groupBy] }));
+  }
+  return out;
+}
+function queriesEqual(a, b) {
+  if (a === b) return true;
+  if (a.limit !== b.limit || a.offset !== b.offset) return false;
+  if (!sameArray(a.where, b.where)) return false;
+  if (!sameArray(a.orderBy, b.orderBy)) return false;
+  if (!sameArray(a.select, b.select)) return false;
+  if (!sameArray(a.aggregations ?? [], b.aggregations ?? [])) return false;
+  return true;
+}
+function sameArray(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (JSON.stringify(a[i]) !== JSON.stringify(b[i])) return false;
+  }
+  return true;
+}
+
+// src/schema.ts
+function isFilterable(f) {
+  return f.filter?.enabled ?? f.source.kind === "backend";
+}
+function isPushdownFilter(f) {
+  return isFilterable(f) && (f.filter?.pushdown ?? f.source.kind === "backend");
+}
+function isSortable(f) {
+  return f.sort?.enabled ?? f.source.kind === "backend";
+}
+function isSelectable(f) {
+  return f.select?.enabled ?? true;
+}
+function filterValues(f) {
+  return f.filter?.values ?? { source: "autocomplete" };
+}
+function indexFields(schema) {
+  return new Map(schema.fields.map((f) => [f.name, f]));
+}
+function selectedFields(schema, q) {
+  const order = q.select.length > 0 ? q.select.map((c) => c.field) : (schema.defaultSelect ?? schema.fields.filter((f) => f.select?.default).map((f) => ({ field: f.name }))).map(
+    (c) => c.field
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const name of order) {
+    if (seen.has(name)) continue;
+    const f = resolveField(schema, name);
+    if (!f || !isSelectable(f)) continue;
+    seen.add(name);
+    seen.add(f.name);
+    out.push(f);
+  }
+  return out;
+}
+function resolveField(schema, field) {
+  const token = field.trim();
+  if (!token) return void 0;
+  const byName = indexFields(schema);
+  const byExactName = byName.get(token);
+  if (byExactName) return byExactName;
+  const needle = token.toLowerCase();
+  for (const f of schema.fields) {
+    if (f.name.toLowerCase() === needle) return f;
+    if (aliasMatches(f, needle)) return f;
+  }
+  return void 0;
+}
+function resolveFieldName(schema, field) {
+  return resolveField(schema, field)?.name;
+}
+function aliasTermsFor(field) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (raw) => {
+    if (typeof raw !== "string") return;
+    const value = raw.trim();
+    if (!value) return;
+    const key = value.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push(value);
+  };
+  add(field.alias);
+  if (field.aliases) {
+    for (const alias of field.aliases) add(alias);
+  }
+  return out;
+}
+function aliasMatches(field, needle) {
+  for (const alias of aliasTermsFor(field)) {
+    if (alias.toLowerCase() === needle) return true;
+  }
+  return false;
+}
+function readFieldValue(field, row) {
+  if (row == null) return null;
+  if (field.source.kind === "derived" && field.source.accessor) {
+    return field.source.accessor(row);
+  }
+  const path = field.source.kind === "backend" && field.source.path || field.name;
+  const r = row;
+  if (path in r) return r[path] ?? null;
+  let cur = row;
+  for (const part of path.split(".")) {
+    if (cur == null || typeof cur !== "object") return null;
+    cur = cur[part];
+  }
+  return cur ?? null;
+}
+function loadSchema(doc) {
+  const d = doc;
+  if (!d || typeof d !== "object") throw new Error("schema: document is not an object");
+  if (typeof d.name !== "string") throw new Error("schema: missing `name`");
+  if (typeof d.idField !== "string") throw new Error("schema: missing `idField`");
+  if (!Array.isArray(d.fields) || d.fields.length === 0) throw new Error("schema: `fields` must be a non-empty array");
+  const fields = d.fields.map((raw, i) => projectField(raw, i));
+  return {
+    name: d.name,
+    idField: d.idField,
+    fields,
+    defaultSort: d.defaultSort,
+    defaultSelect: d.defaultSelect,
+    defaultLimit: d.defaultLimit
+  };
+}
+function projectField(raw, i) {
+  if (!raw || typeof raw.name !== "string") throw new Error(`schema: field[${i}] missing \`name\``);
+  if (typeof raw.label !== "string") throw new Error(`schema: field ${raw.name} missing \`label\``);
+  if (typeof raw.type !== "string") throw new Error(`schema: field ${raw.name} missing \`type\``);
+  const rs = raw.source ?? (raw.bindings ? "backend" : "derived");
+  let source;
+  if (typeof rs === "string") {
+    source = rs === "derived" ? { kind: "derived" } : { kind: "backend" };
+  } else if (rs.kind === "derived") {
+    source = { kind: "derived" };
+  } else {
+    source = { kind: "backend", path: rs.path, synthetic: rs.synthetic };
+  }
+  return {
+    name: raw.name,
+    label: raw.label,
+    type: raw.type,
+    source,
+    filter: raw.filter,
+    sort: raw.sort,
+    select: raw.select,
+    aggregate: raw.aggregate,
+    group: raw.group,
+    alias: raw.alias,
+    aliases: normalizeAliases(raw.aliases, raw.alias),
+    render: raw.render
+    // string key from JSON; consumer may override with a fn
+  };
+}
+function normalizeAliases(rawAliases, rawAlias) {
+  const aliases = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (raw) => {
+    if (typeof raw !== "string") return;
+    const value = raw.trim();
+    if (!value) return;
+    const key = value.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    aliases.push(value);
+  };
+  add(rawAlias);
+  if (Array.isArray(rawAliases)) {
+    for (const item of rawAliases) add(item);
+  }
+  return aliases;
+}
+
+// src/ops.ts
+var NULLITY = ["is_null", "is_not_null"];
+var OPS_BY_TYPE = {
+  text: ["=", "!=", "contains", "starts_with", "ends_with", ...NULLITY],
+  enum: ["=", "!=", ...NULLITY],
+  number: ["=", "!=", ">", ">=", "<", "<=", ...NULLITY],
+  datetime: ["=", "!=", ">", ">=", "<", "<=", ...NULLITY],
+  bool: ["=", "!=", ...NULLITY],
+  textarray: ["includes", ...NULLITY]
+};
+var NULLARY_OPS = new Set(NULLITY);
+function opsForField(field) {
+  return field.filter?.ops ?? OPS_BY_TYPE[field.type];
+}
+function opAllowedForType(type, op) {
+  return OPS_BY_TYPE[type].includes(op);
+}
+function coerceValue(type, raw) {
+  switch (type) {
+    case "number": {
+      const n = Number(raw);
+      if (raw.trim() === "" || Number.isNaN(n)) throw new Error(`not a number: ${JSON.stringify(raw)}`);
+      return n;
+    }
+    case "bool": {
+      const v = raw.toLowerCase();
+      if (v === "true" || v === "1" || v === "t") return true;
+      if (v === "false" || v === "0" || v === "f") return false;
+      throw new Error(`not a bool: ${JSON.stringify(raw)}`);
+    }
+    case "datetime": {
+      const ms = Date.parse(raw);
+      if (Number.isNaN(ms)) throw new Error(`not a datetime: ${JSON.stringify(raw)}`);
+      return ms;
+    }
+    default:
+      return raw;
+  }
+}
+
+// src/agg.ts
+var AGG_OPS_BY_TYPE = {
+  number: ["count", "count_distinct", "sum", "avg", "min", "max"],
+  datetime: ["count", "count_distinct", "min", "max"],
+  enum: ["count", "count_distinct", "min", "max"],
+  text: ["count", "count_distinct", "min", "max"],
+  bool: ["count", "count_distinct"],
+  textarray: ["count"]
+};
+var AGG_OPS_NEEDING_FIELD = /* @__PURE__ */ new Set([
+  "count_distinct",
+  "sum",
+  "avg",
+  "min",
+  "max"
+]);
+function aggOpNeedsField(op) {
+  return AGG_OPS_NEEDING_FIELD.has(op);
+}
+function aggOpsForField(field) {
+  return field.aggregate?.ops ?? AGG_OPS_BY_TYPE[field.type];
+}
+function aggOpAllowedForType(type, op) {
+  return AGG_OPS_BY_TYPE[type].includes(op);
+}
+function isMeasurable(field) {
+  if (field.source.kind !== "backend") return false;
+  if (field.aggregate?.measure != null) return field.aggregate.measure;
+  return aggOpsForField(field).length > 0;
+}
+function isGroupable(field) {
+  if (field.source.kind !== "backend") return false;
+  if (field.aggregate?.groupable != null) return field.aggregate.groupable;
+  return field.type === "enum" || field.type === "text" || field.type === "bool";
+}
+
+// src/encode.ts
+function toBase64Url(json) {
+  let b64;
+  if (typeof Buffer !== "undefined") {
+    b64 = Buffer.from(json, "utf8").toString("base64");
+  } else {
+    const bytes = new TextEncoder().encode(json);
+    let bin = "";
+    for (const b of bytes) bin += String.fromCharCode(b);
+    b64 = btoa(bin);
+  }
+  return b64.replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function fromBase64Url(s) {
+  const b64 = s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4);
+  if (typeof Buffer !== "undefined") return Buffer.from(b64, "base64").toString("utf8");
+  const bin = atob(b64);
+  const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+function encodeQuery(q) {
+  q = normalizeQueryState(q);
+  const c = {};
+  if (q.select.length)
+    c.s = q.select.map((col) => col.width != null ? [col.field, col.width] : [col.field]);
+  if (q.where.length) c.w = q.where;
+  if (q.orderBy.length) c.o = q.orderBy;
+  c.l = q.limit;
+  if (q.offset) c.f = q.offset;
+  if (q.aggregations?.length) c.g = q.aggregations;
+  if (Object.keys(c).length === 0) return "";
+  return toBase64Url(JSON.stringify(c));
+}
+function decodeQuery(token) {
+  if (!token) return { ...EMPTY_QUERY };
+  if (token.length > MAX_QUERY_TOKEN_LENGTH) return { ...EMPTY_QUERY };
+  try {
+    const c = JSON.parse(fromBase64Url(token));
+    const out = normalizeQueryState({
+      select: normalizeSelect(c.s ?? c.c),
+      where: Array.isArray(c.w) ? c.w : [],
+      orderBy: normalizeOrderBy(c.o),
+      limit: c.l,
+      offset: c.f,
+      aggregations: c.g
+    });
+    return out;
+  } catch {
+    return { ...EMPTY_QUERY };
+  }
+}
+function normalizeSelect(s) {
+  if (!Array.isArray(s)) return [];
+  return s.map((item) => {
+    if (typeof item === "string") return { field: item };
+    if (Array.isArray(item) && typeof item[0] === "string") {
+      return typeof item[1] === "number" ? { field: item[0], width: item[1] } : { field: item[0] };
+    }
+    return null;
+  }).filter((x) => x != null);
+}
+function normalizeOrderBy(o) {
+  if (!o) return [];
+  if (Array.isArray(o)) return o;
+  return [o];
+}
+function toServerQuery(q, schema) {
+  q = normalizeQueryState(q);
+  const byName = indexFields(schema);
+  const resolveField2 = (name) => resolveFieldName(schema, name) ?? name;
+  const where = q.where.filter((cl) => {
+    const field = resolveField2(cl.field);
+    const f = byName.get(field);
+    return f != null && isPushdownFilter(f);
+  });
+  const orderBy = [];
+  for (const term of q.orderBy) {
+    const field = resolveField2(term.field);
+    const f = byName.get(field);
+    if (!f || !isSortable(f) || f.source.kind !== "backend") continue;
+    orderBy.push({ ...term, field: f.sort?.field ?? f.name });
+  }
+  const select = new Set(
+    selectedFields(schema, q).filter((f) => f.source.kind === "backend").map((f) => f.name)
+  );
+  select.add(schema.idField);
+  for (const cl of q.where) {
+    const field = resolveField2(cl.field);
+    const f = byName.get(field);
+    if (f && isFilterable(f) && !isPushdownFilter(f) && f.source.kind === "backend") select.add(field);
+  }
+  return { select: [...select], where, orderBy, limit: q.limit, offset: q.offset };
+}
+function toAggregationQuery(q, schema) {
+  q = normalizeQueryState(q);
+  const byName = indexFields(schema);
+  const resolveField2 = (name) => resolveFieldName(schema, name) ?? name;
+  const where = q.where.filter((cl) => {
+    const f = byName.get(resolveField2(cl.field));
+    return f != null && isPushdownFilter(f);
+  });
+  const isBackend = (name) => {
+    if (name == null) return true;
+    const field = resolveField2(name);
+    const f = byName.get(field);
+    return f != null && f.source.kind === "backend";
+  };
+  const aggregations = (q.aggregations ?? []).filter(
+    (a) => isBackend(a.field) && a.groupBy.every((g) => isBackend(g))
+  );
+  return { where, aggregations };
+}
+
+// src/apply.ts
+function applyQuery(rows, q, schema) {
+  const byName = indexFields(schema);
+  const resolveField2 = (name) => resolveFieldName(schema, name) ?? name;
+  const whereClauses = q.where.map((clause) => ({ ...clause, field: resolveField2(clause.field) }));
+  const orderBy = q.orderBy.map((term) => ({ ...term, field: resolveField2(term.field) }));
+  let out = rows.filter((row) => whereClauses.every((cl) => matchesWith(byName, row, cl)));
+  const total = out.length;
+  if (orderBy.length) {
+    const terms = orderBy.map((t) => ({ field: byName.get(t.field), dir: t.dir, nullsLast: (t.nulls ?? "last") === "last" })).filter((t) => t.field != null);
+    out = [...out].sort((a, b) => {
+      for (const t of terms) {
+        const av = readFieldValue(t.field, a);
+        const bv = readFieldValue(t.field, b);
+        const aNull = av == null;
+        const bNull = bv == null;
+        if (aNull || bNull) {
+          if (aNull && bNull) continue;
+          return (aNull ? 1 : -1) * (t.nullsLast ? 1 : -1);
+        }
+        const cmp = compare(av, bv);
+        if (cmp !== 0) return t.dir === "asc" ? cmp : -cmp;
+      }
+      return 0;
+    });
+  }
+  const start = q.offset > 0 ? q.offset : 0;
+  const end = q.limit > 0 ? start + q.limit : out.length;
+  return { rows: out.slice(start, end), total };
+}
+function matchesClause(row, clause, schema) {
+  return matchesWith(indexFields(schema), row, clause);
+}
+function applyAggregations(rows, q, schema) {
+  const byName = indexFields(schema);
+  const resolveField2 = (name) => resolveFieldName(schema, name) ?? name;
+  const whereClauses = q.where.map((clause) => ({ ...clause, field: resolveField2(clause.field) }));
+  const filtered = rows.filter((row) => whereClauses.every((cl) => matchesWith(byName, row, cl)));
+  const metrics = (q.aggregations ?? []).map((agg) => ({
+    id: agg.id,
+    buckets: computeBuckets(filtered, agg, byName, resolveField2)
+  }));
+  return { metrics };
+}
+function computeBuckets(rows, agg, byName, resolveField2) {
+  const groupFields = agg.groupBy.map((n) => byName.get(resolveField2(n)));
+  const measure = agg.field ? byName.get(resolveField2(agg.field)) : void 0;
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const keys = groupFields.map((f) => {
+      if (!f) return null;
+      const v = readFieldValue(f, row);
+      return v == null || v === "" ? null : String(v);
+    });
+    const k = JSON.stringify(keys);
+    let g = groups.get(k);
+    if (!g) {
+      g = { keys, rows: [] };
+      groups.set(k, g);
+    }
+    g.rows.push(row);
+  }
+  const buckets = [...groups.values()].map((g) => ({
+    keys: g.keys,
+    count: g.rows.length,
+    value: aggValue(agg.op, measure, g.rows)
+  }));
+  return sortBuckets(buckets);
+}
+function aggValue(op, measure, rows) {
+  if (op === "count") {
+    if (!measure) return rows.length;
+    let n = 0;
+    for (const r of rows) if (readFieldValue(measure, r) != null) n++;
+    return n;
+  }
+  if (!measure) return null;
+  const values = rows.map((r) => readFieldValue(measure, r)).filter((v) => v != null);
+  switch (op) {
+    case "count_distinct":
+      return new Set(values.map((v) => String(v))).size;
+    case "sum":
+    case "avg": {
+      let sum = 0;
+      let n = 0;
+      for (const v of values) {
+        const num = typeof v === "number" ? v : Number(v);
+        if (Number.isFinite(num)) {
+          sum += num;
+          n++;
+        }
+      }
+      if (op === "avg") return n ? sum / n : null;
+      return n ? sum : null;
+    }
+    case "min":
+    case "max": {
+      let best;
+      for (const v of values) {
+        if (best === void 0) {
+          best = v;
+          continue;
+        }
+        const cmp = compare(v, best);
+        if (op === "min" ? cmp < 0 : cmp > 0) best = v;
+      }
+      return best ?? null;
+    }
+    default:
+      return null;
+  }
+}
+function sortBuckets(buckets) {
+  return [...buckets].sort((a, b) => {
+    const av = typeof a.value === "number" ? a.value : a.count;
+    const bv = typeof b.value === "number" ? b.value : b.count;
+    if (av !== bv) return bv - av;
+    return JSON.stringify(a.keys).localeCompare(JSON.stringify(b.keys));
+  });
+}
+function matchesWith(byName, row, clause) {
+  const field = byName.get(clause.field);
+  if (!field) return true;
+  const v = readFieldValue(field, row);
+  if (clause.op === "is_null") return Array.isArray(v) ? v.length === 0 : v == null || v === "";
+  if (clause.op === "is_not_null") return Array.isArray(v) ? v.length > 0 : v != null && v !== "";
+  if (clause.value === "" && clause.op !== "=" && clause.op !== "!=") return true;
+  if (clause.op === "includes") {
+    const arr = Array.isArray(v) ? v : [];
+    const needle = clause.value.toLowerCase();
+    return arr.some((x) => String(x).toLowerCase() === needle);
+  }
+  if (Array.isArray(v)) {
+    const needle = clause.value.toLowerCase();
+    const hay = v.map((x) => String(x).toLowerCase());
+    switch (clause.op) {
+      case "contains":
+        return hay.some((s) => s.includes(needle));
+      case "=":
+        return hay.includes(needle);
+      case "!=":
+        return !hay.includes(needle);
+      default:
+        return true;
+    }
+  }
+  switch (clause.op) {
+    case "=":
+      return String(v ?? "") === String(coerceSafe(field, clause.value));
+    case "!=":
+      return String(v ?? "") !== String(coerceSafe(field, clause.value));
+    case ">":
+      return compare(v, coerceSafe(field, clause.value)) > 0;
+    case ">=":
+      return compare(v, coerceSafe(field, clause.value)) >= 0;
+    case "<":
+      return compare(v, coerceSafe(field, clause.value)) < 0;
+    case "<=":
+      return compare(v, coerceSafe(field, clause.value)) <= 0;
+    case "contains":
+      return String(v ?? "").toLowerCase().includes(clause.value.toLowerCase());
+    case "starts_with":
+      return String(v ?? "").toLowerCase().startsWith(clause.value.toLowerCase());
+    case "ends_with":
+      return String(v ?? "").toLowerCase().endsWith(clause.value.toLowerCase());
+    default:
+      return true;
+  }
+}
+function coerceSafe(field, raw) {
+  try {
+    return coerceValue(field.type, raw);
+  } catch {
+    return raw;
+  }
+}
+function compare(a, b) {
+  if (a == null && b == null) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "boolean" && typeof b === "boolean") return a === b ? 0 : a ? 1 : -1;
+  return String(a).localeCompare(String(b));
+}
+
+// src/adapters.ts
+var LAST_PREFIX = "query-table:last:";
+var SAVED_PREFIX = "query-table:saved:";
+var DEFAULT_PREFIX = "query-table:default:";
+var MAX_SAVED_QUERIES = 100;
+var MAX_SAVED_NAME_LENGTH = 200;
+function normalizeSavedQuery(value) {
+  if (value == null || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  if (typeof raw.id !== "string" || !raw.id || raw.id.length > 256 || typeof raw.name !== "string" || !raw.name || raw.name.length > MAX_SAVED_NAME_LENGTH || typeof raw.savedAt !== "number" || !Number.isFinite(raw.savedAt) || raw.query == null || typeof raw.query !== "object") {
+    return null;
+  }
+  return { id: raw.id, name: raw.name, savedAt: raw.savedAt, query: normalizeQueryState(raw.query) };
+}
+function normalizeSavedQueries(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, MAX_SAVED_QUERIES).map(normalizeSavedQuery).filter((item) => item != null);
+}
+function memoryStorageAdapter() {
+  const last = /* @__PURE__ */ new Map();
+  const saved = /* @__PURE__ */ new Map();
+  const defaults = /* @__PURE__ */ new Map();
+  return {
+    async loadLast(key) {
+      const query = last.get(key);
+      return query ? normalizeQueryState(query) : null;
+    },
+    async saveLast(key, query) {
+      last.set(key, normalizeQueryState(query));
+    },
+    async listSaved(key) {
+      return (saved.get(key) ?? []).map((item) => ({ ...item, query: normalizeQueryState(item.query) }));
+    },
+    async loadDefaultSaved(key) {
+      const id = defaults.get(key);
+      return id ? (saved.get(key) ?? []).find((item) => item.id === id) ?? null : null;
+    },
+    async setDefaultSaved(key, id) {
+      if (id == null) {
+        defaults.delete(key);
+        return;
+      }
+      if (!(saved.get(key) ?? []).some((item) => item.id === id)) throw new Error(`Saved query "${id}" does not exist.`);
+      defaults.set(key, id);
+    },
+    async saveNamed(key, name, query, savedAt) {
+      const normalizedName = name.trim();
+      if (!normalizedName || normalizedName.length > MAX_SAVED_NAME_LENGTH) {
+        throw new Error(`Saved query name must be between 1 and ${MAX_SAVED_NAME_LENGTH} characters.`);
+      }
+      const items = saved.get(key) ?? [];
+      if (items.length >= MAX_SAVED_QUERIES) throw new Error(`At most ${MAX_SAVED_QUERIES} saved queries are allowed.`);
+      if (items.some((item2) => item2.name === normalizedName)) throw new Error(`Saved query "${normalizedName}" already exists.`);
+      const item = {
+        id: `${savedAt}-${Math.round((savedAt * 9301 + 49297) % 233280)}`,
+        name: normalizedName,
+        savedAt,
+        query: normalizeQueryState(query)
+      };
+      saved.set(key, [...items, item]);
+      return item;
+    },
+    async deleteSaved(key, id) {
+      saved.set(key, (saved.get(key) ?? []).filter((item) => item.id !== id));
+      if (defaults.get(key) === id) defaults.delete(key);
+    }
+  };
+}
+function localStorageAdapter() {
+  const ls = (() => {
+    try {
+      return typeof localStorage !== "undefined" ? localStorage : null;
+    } catch {
+      return null;
+    }
+  })();
+  const readSaved = (key) => {
+    if (!ls) return [];
+    try {
+      const raw = ls.getItem(SAVED_PREFIX + key);
+      return normalizeSavedQueries(raw ? JSON.parse(raw) : []);
+    } catch {
+      return [];
+    }
+  };
+  const writeSaved = (key, items) => {
+    if (ls) ls.setItem(SAVED_PREFIX + key, JSON.stringify(items));
+  };
+  const readDefaultId = (key) => {
+    if (!ls) return null;
+    return ls.getItem(DEFAULT_PREFIX + key);
+  };
+  const writeDefaultId = (key, id) => {
+    if (!ls) return;
+    if (id) ls.setItem(DEFAULT_PREFIX + key, id);
+    else ls.removeItem(DEFAULT_PREFIX + key);
+  };
+  return {
+    async loadLast(key) {
+      if (!ls) return null;
+      try {
+        const raw = ls.getItem(LAST_PREFIX + key);
+        return raw ? normalizeQueryState(JSON.parse(raw)) : null;
+      } catch {
+        return null;
+      }
+    },
+    async saveLast(key, query) {
+      if (ls) ls.setItem(LAST_PREFIX + key, JSON.stringify(normalizeQueryState(query)));
+    },
+    async listSaved(key) {
+      return readSaved(key).sort((a, b) => b.savedAt - a.savedAt);
+    },
+    async loadDefaultSaved(key) {
+      const id = readDefaultId(key);
+      if (!id) return null;
+      const found = readSaved(key).find((q) => q.id === id);
+      if (!found) writeDefaultId(key, null);
+      return found ?? null;
+    },
+    async setDefaultSaved(key, id) {
+      if (id && !readSaved(key).some((q) => q.id === id)) {
+        throw new Error(`Saved query "${id}" does not exist.`);
+      }
+      writeDefaultId(key, id);
+    },
+    async saveNamed(key, name, query, savedAt) {
+      const normalizedName = name.trim();
+      if (!normalizedName || normalizedName.length > MAX_SAVED_NAME_LENGTH) {
+        throw new Error(`Saved query name must be between 1 and ${MAX_SAVED_NAME_LENGTH} characters.`);
+      }
+      const items = readSaved(key);
+      if (items.length >= MAX_SAVED_QUERIES) throw new Error(`At most ${MAX_SAVED_QUERIES} saved queries are allowed.`);
+      if (items.some((q) => q.name === normalizedName)) {
+        throw new Error(`Saved query "${normalizedName}" already exists.`);
+      }
+      const item = {
+        id: `${savedAt}-${Math.round((savedAt * 9301 + 49297) % 233280)}`,
+        name: normalizedName,
+        savedAt,
+        query: normalizeQueryState(query)
+      };
+      items.push(item);
+      writeSaved(key, items);
+      return item;
+    },
+    async deleteSaved(key, id) {
+      writeSaved(
+        key,
+        readSaved(key).filter((q) => q.id !== id)
+      );
+      if (readDefaultId(key) === id) writeDefaultId(key, null);
+    }
+  };
+}
+export {
+  AGG_OPS_BY_TYPE,
+  AGG_OPS_NEEDING_FIELD,
+  EMPTY_QUERY,
+  MAX_AGGREGATIONS,
+  MAX_GROUP_BY_FIELDS,
+  MAX_ORDER_BY_TERMS,
+  MAX_QUERY_LIMIT,
+  MAX_QUERY_OFFSET,
+  MAX_QUERY_TOKEN_LENGTH,
+  MAX_SELECT_COLUMNS,
+  MAX_WHERE_CLAUSES,
+  NULLARY_OPS,
+  OPS_BY_TYPE,
+  aggOpAllowedForType,
+  aggOpNeedsField,
+  aggOpsForField,
+  applyAggregations,
+  applyQuery,
+  coerceValue,
+  decodeQuery,
+  encodeQuery,
+  filterValues,
+  indexFields,
+  isFilterable,
+  isGroupable,
+  isMeasurable,
+  isPushdownFilter,
+  isSelectable,
+  isSortable,
+  loadSchema,
+  localStorageAdapter,
+  matchesClause,
+  memoryStorageAdapter,
+  normalizeQueryState,
+  opAllowedForType,
+  opsForField,
+  queriesEqual,
+  readFieldValue,
+  selectedFields,
+  toAggregationQuery,
+  toServerQuery
+};
+//# sourceMappingURL=index.js.map