@osqd/jql 0.1.1 → 0.1.2

package/dist/chunk-VMFEQXBB.js

@@ -0,0 +1,578 @@
+import { FIELD_OPERATORS, QUERY_OPERATORS, reachField, compile, compareValues, CASE_AWARE, validate, planRequest } from './chunk-6PWYYYWU.js';
+import { checkVocabulary } from './chunk-N7DS4QNW.js';
+import { JqlError, describe, isPlainObject, isFieldReference, isDateLiteral, resolveDate } from './chunk-PNBQ2HIJ.js';
+
+// src/group.ts
+function group(source, by, options = {}) {
+  if (typeof by !== "string") throw new JqlError(`a group is named by a field, not ${describe(by)}`, "by");
+  if (options.limit !== void 0 && (!Number.isInteger(options.limit) || options.limit < 0)) {
+    throw new JqlError(`is a whole number of groups, zero or more, not ${describe(options.limit)}`, "limit");
+  }
+  if (options.items !== void 0 && typeof options.items !== "boolean" && (!Number.isInteger(options.items) || options.items < 0)) {
+    throw new JqlError(`is true, false, or how many items to keep, not ${describe(options.items)}`, "items");
+  }
+  const reach = reachField(by, checkVocabulary(options.vocabulary), "by");
+  const test = options.where === void 0 ? void 0 : compile(options.where, options);
+  const keep = options.items === true ? Number.POSITIVE_INFINITY : options.items === void 0 || options.items === false ? 0 : options.items;
+  const groups = /* @__PURE__ */ new Map();
+  const keys = [];
+  const visit = (item) => {
+    if (test !== void 0 && !test(item)) return;
+    keys.length = 0;
+    reach(item, (value) => {
+      collect(value, keys);
+      return false;
+    });
+    for (const key of keys) {
+      let held = groups.get(key);
+      if (held === void 0) {
+        held = { key, count: 0, items: [] };
+        groups.set(key, held);
+      }
+      held.count++;
+      if (held.items.length < keep) held.items.push(item);
+    }
+  };
+  if (Array.isArray(source)) for (let i = 0; i < source.length; i++) visit(source[i]);
+  else if (source instanceof Map) for (const item of source.values()) visit(item);
+  else if (typeof source[Symbol.iterator] === "function") for (const item of source) visit(item);
+  else {
+    const list = source;
+    for (let i = 0; i < list.length; i++) visit(list[i]);
+  }
+  const byKey = options.sort === "key";
+  const found = [...groups.values()].sort((a, b) => byKey ? compareValues(a.key, b.key) : b.count - a.count || compareValues(a.key, b.key));
+  const limited = options.limit === void 0 ? found : found.slice(0, options.limit);
+  return limited.map((held) => keep > 0 ? { key: held.key, count: held.count, items: held.items } : { key: held.key, count: held.count });
+}
+function collect(value, into) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      if (!into.includes(null)) into.push(null);
+      return;
+    }
+    for (const element of value) collect(element, into);
+    return;
+  }
+  const key = value === void 0 || value === null || typeof value === "object" ? null : value;
+  if (!into.includes(key)) into.push(key);
+}
+
+// src/explain.ts
+var FIELD_OPERATOR_SET = new Set(FIELD_OPERATORS);
+function explain(query, item, options = {}) {
+  return node(query, item, "", options);
+}
+function matchedBy(clause, item, options) {
+  return compile(clause, options)(item);
+}
+function node(clause, item, at, options) {
+  if (typeof clause === "function" || !isPlainObject(clause)) {
+    return leaf(clause, item, at, options, typeof clause === "function" ? "a predicate of your own" : "the whole query");
+  }
+  const keys = Object.keys(clause);
+  if (keys.length === 0) return { matched: true, at, clause, because: "an empty query matches everything" };
+  if (keys.length > 1) {
+    const self = keys.filter((key2) => key2 !== "$not" && FIELD_OPERATOR_SET.has(key2));
+    const rest = keys.filter((key2) => !self.includes(key2));
+    const parts = rest.map((key2) => node({ [key2]: clause[key2] }, item, at, options));
+    if (self.length > 0) {
+      const whole = {};
+      for (const key2 of self) whole[key2] = clause[key2];
+      parts.push(leaf(whole, item, at, options, self[0]));
+    }
+    return branch(clause, at, parts, "and");
+  }
+  const key = keys[0];
+  const value = clause[key];
+  const here = join(at, key);
+  switch (key) {
+    case "$and":
+    case "$or":
+    case "$nor": {
+      if (!Array.isArray(value)) break;
+      const parts = value.map((part, index) => node(part, item, `${here}[${index}]`, options));
+      return branch(clause, here, parts, key === "$and" ? "and" : key === "$or" ? "or" : "nor");
+    }
+    case "$not": {
+      const inner = node(value, item, here, options);
+      return {
+        matched: !inner.matched,
+        at: here,
+        clause,
+        because: inner.matched ? "what it negates holds" : "what it negates does not hold",
+        parts: [inner]
+      };
+    }
+  }
+  if (!key.startsWith("$") && isPlainObject(value) && !isFieldReference(value) && Object.keys(value).length > 1 && Object.keys(value).every((name) => name.startsWith("$"))) {
+    const operators = Object.keys(value).filter((name) => name !== "$options");
+    const flags = value.$options === void 0 ? {} : { $options: value.$options };
+    const parts = operators.map((name) => leaf({ [key]: { [name]: value[name], ...CASE_AWARE.has(name) ? flags : {} } }, item, join(here, name), options, key));
+    return branch(clause, here, parts, "and");
+  }
+  return leaf(clause, item, here, options, key);
+}
+function branch(clause, at, parts, kind) {
+  const held = parts.filter((part) => part.matched).length;
+  const matched = kind === "and" ? held === parts.length : kind === "or" ? held > 0 : held === 0;
+  const many = parts.length === 1 ? "part" : "parts";
+  const because = kind === "nor" ? `${held} of ${parts.length} ${many} hold, and none may` : `${held} of ${parts.length} ${many} hold${kind === "or" ? ", and one is enough" : ""}`;
+  return { matched, at, clause, because, parts };
+}
+function leaf(clause, item, at, options, key) {
+  const matched = matchedBy(clause, item, options);
+  return { matched, at, clause, because: reason(clause, item, options, key) };
+}
+function reason(clause, item, options, key) {
+  if (key === "$text") return matchedBy(clause, item, options) ? "the item holds that text" : "no value of the item holds that text";
+  if (key === "$comment") return "a comment decides nothing";
+  if (key.startsWith("$") && FIELD_OPERATOR_SET.has(key)) return `the item itself is ${values(item === void 0 ? [] : [item])}`;
+  if (!isPlainObject(clause)) return "the clause was run as given";
+  const path = Object.keys(clause)[0];
+  if (path === void 0 || path.startsWith("$")) return "the clause was run as given";
+  const found = [];
+  try {
+    reachField(path, options.vocabulary, path)(item, (value) => {
+      if (found.length < 4) found.push(value);
+      return false;
+    });
+  } catch {
+    return "the clause was run as given";
+  }
+  return `${path} is ${values(found)}`;
+}
+function values(found) {
+  if (found.length === 0 || found.length === 1 && found[0] === void 0) return "missing";
+  const written = found.map((value) => value === void 0 ? "missing" : shorten(value));
+  return written.length === 1 ? written[0] : `each of ${written.join(", ")}`;
+}
+function shorten(value) {
+  if (value instanceof Date) return value.toISOString();
+  let text2;
+  try {
+    text2 = JSON.stringify(value) ?? String(value);
+  } catch {
+    return "a value that cannot be written out";
+  }
+  return text2.length > 60 ? `${text2.slice(0, 60)}\u2026` : text2;
+}
+function join(at, key) {
+  return at === "" ? key : `${at}.${key}`;
+}
+
+// src/canonical.ts
+var SETS = /* @__PURE__ */ new Set(["$in", "$nin", "$all", "$contains", "$startsWith", "$endsWith", "$word", "$glob"]);
+var QUERIES = /* @__PURE__ */ new Set(["$elemMatch"]);
+var LOGIC = /* @__PURE__ */ new Set(["$and", "$or", "$nor"]);
+function canonical(query, options) {
+  if (typeof query === "function") throw new TypeError("a compiled predicate has no canonical form: it is code, not a query");
+  compile(query, options);
+  return rewrite(query);
+}
+function fingerprint(query, options) {
+  return checksum(JSON.stringify(canonical(query, options)) ?? "");
+}
+function rewrite(value) {
+  if (!isPlainObject(value)) return value;
+  if (isDateLiteral(value) || isFieldReference(value)) return value;
+  const out = {};
+  const keys = Object.keys(value).sort().filter((key) => key !== "$comment");
+  const alone = keys.length === 1;
+  for (const key of keys) {
+    const held = value[key];
+    if (LOGIC.has(key) && Array.isArray(held)) {
+      const parts = flatten(key, held).map(rewrite).sort(byText);
+      if (parts.length === 1 && key !== "$nor" && alone) return parts[0];
+      out[key] = parts;
+      continue;
+    }
+    if (key === "$not") {
+      out[key] = rewrite(held);
+      continue;
+    }
+    if (key === "$text") {
+      out[key] = text(held);
+      continue;
+    }
+    if (key.startsWith("$")) {
+      out[key] = operand(key, held);
+      continue;
+    }
+    out[key] = condition(held);
+  }
+  return fold(out);
+}
+function fold(out) {
+  const parts = out.$and;
+  if (!Array.isArray(parts) || parts.length === 0) return out;
+  const taken = new Set(Object.keys(out).filter((key) => key !== "$and"));
+  const lifted = {};
+  const kept = [];
+  for (const part of parts) {
+    const keys = isPlainObject(part) ? Object.keys(part) : void 0;
+    if (keys === void 0 || keys.length === 0 || keys.some((key) => taken.has(key))) {
+      kept.push(part);
+      continue;
+    }
+    for (const key of keys) {
+      taken.add(key);
+      lifted[key] = part[key];
+    }
+  }
+  if (Object.keys(lifted).length === 0) return out;
+  const merged = { ...lifted };
+  for (const [key, value] of Object.entries(out)) if (key !== "$and") merged[key] = value;
+  if (kept.length > 0) merged.$and = kept;
+  const sorted = {};
+  for (const key of Object.keys(merged).sort()) sorted[key] = merged[key];
+  return sorted;
+}
+function condition(value) {
+  if (isPlainObject(value) && !isDateLiteral(value) && !isFieldReference(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => key.startsWith("$"))) {
+    const out = {};
+    for (const key of Object.keys(value).sort()) out[key] = key === "$not" ? condition(value[key]) : operand(key, value[key]);
+    return out;
+  }
+  return { $eq: literal(value) };
+}
+function operand(key, value) {
+  if (SETS.has(key) && Array.isArray(value)) return unique(value.map(literal));
+  if (QUERIES.has(key)) return rewrite(value);
+  if (key === "$type" && Array.isArray(value)) {
+    const types = unique(value);
+    return types.length === 1 ? types[0] : types;
+  }
+  if (key === "$options" && typeof value === "string") return [...value].sort().join("");
+  if ((key === "$size" || key === "$length") && isPlainObject(value)) return condition(value);
+  return literal(value);
+}
+function literal(value) {
+  if (Array.isArray(value)) return value.map(literal);
+  if (!isPlainObject(value) || isDateLiteral(value) || isFieldReference(value)) return value;
+  const out = {};
+  for (const key of Object.keys(value).sort()) out[key] = literal(value[key]);
+  return out;
+}
+function text(value) {
+  const search2 = typeof value === "string" ? { $search: value } : isPlainObject(value) ? value : void 0;
+  if (search2 === void 0) return value;
+  const out = { $search: search2.$search };
+  if (Array.isArray(search2.$fields)) out.$fields = unique(search2.$fields);
+  if (search2.$caseSensitive === true) out.$caseSensitive = true;
+  return out;
+}
+function flatten(key, parts) {
+  if (key === "$nor") return [...parts];
+  const out = [];
+  for (const part of parts) {
+    const inner = isPlainObject(part) && Object.keys(part).length === 1 ? part[key] : void 0;
+    if (Array.isArray(inner)) out.push(...flatten(key, inner));
+    else out.push(part);
+  }
+  return out;
+}
+function byText(a, b) {
+  const left = JSON.stringify(a) ?? "";
+  const right = JSON.stringify(b) ?? "";
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function unique(values2) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const value of values2) {
+    const written = JSON.stringify(value) ?? String(value);
+    if (!seen.has(written)) seen.set(written, value);
+  }
+  return [...seen.values()].sort(byText);
+}
+function checksum(text2) {
+  let low = 2166136261;
+  let high = 16777619;
+  for (let i = 0; i < text2.length; i++) {
+    const code = text2.charCodeAt(i);
+    low = Math.imul(low ^ code, 16777619) >>> 0;
+    high = Math.imul(high ^ code + i, 2246822507) >>> 0;
+  }
+  return low.toString(16).padStart(8, "0") + high.toString(16).padStart(8, "0");
+}
+
+// src/plan.ts
+var KNOWN = /* @__PURE__ */ new Set([...FIELD_OPERATORS, ...QUERY_OPERATORS, "$field"]);
+function plan(query, capabilities, options = {}) {
+  if (typeof query === "function") throw new TypeError("a compiled predicate cannot be split: it is code, not a query");
+  const verdict = validate(query, options);
+  if (!verdict.valid) throw verdict.error;
+  const now = options.now === void 0 ? Date.now() : options.now();
+  const vocabulary = options.vocabulary;
+  const fields = capabilities.fields ?? "all";
+  const operators = capabilities.operators ?? "all";
+  const context = {
+    vocabulary,
+    now,
+    fields: fields === "all" ? "all" : new Set(fields),
+    operators: operators === "all" ? "all" : new Set(operators),
+    or: capabilities.or ?? false,
+    not: capabilities.not ?? false,
+    accepts: capabilities.accepts
+  };
+  const pushed = [];
+  const stays = [];
+  const kept = [];
+  for (const { clause, at } of conjuncts(query, "")) {
+    const why = unpushable(clause, context);
+    if (why === void 0) pushed.push(resolve(clause, context));
+    else {
+      stays.push(clause);
+      kept.push({ at, clause, why });
+    }
+  }
+  return {
+    pushed: join2(pushed),
+    remaining: join2(stays),
+    complete: stays.length === 0,
+    kept
+  };
+}
+function conjuncts(query, at) {
+  const out = [];
+  for (const [key, value] of Object.entries(query)) {
+    const here = at === "" ? key : `${at}.${key}`;
+    if (key === "$comment") continue;
+    if (key === "$and" && Array.isArray(value)) {
+      value.forEach((part, index) => {
+        if (isPlainObject(part)) out.push(...conjuncts(part, `${here}[${index}]`));
+      });
+      continue;
+    }
+    out.push({ clause: { [key]: value }, at: here });
+  }
+  return out;
+}
+function join2(parts) {
+  if (parts.length === 0) return void 0;
+  const query = parts.length === 1 ? parts[0] : { $and: parts };
+  return query;
+}
+function unpushable(clause, context, at) {
+  for (const [key, value] of Object.entries(clause)) {
+    if (key.startsWith("$")) {
+      const why2 = unpushableOperator(key, value, context);
+      if (why2 !== void 0) return why2;
+      continue;
+    }
+    const why = unpushableField(key, value, context);
+    if (why !== void 0) return why;
+  }
+  return void 0;
+}
+function unpushableOperator(key, value, context, at) {
+  switch (key) {
+    case "$and":
+      if (!Array.isArray(value)) return "the clause is malformed";
+      for (const part of value) {
+        if (!isPlainObject(part)) return "the clause is malformed";
+        const why = unpushable(part, context);
+        if (why !== void 0) return why;
+      }
+      return void 0;
+    case "$or":
+    case "$nor": {
+      if (!context.or && key === "$or") return "the store cannot answer an $or";
+      if (!context.not && key === "$nor") return "the store cannot answer a negation";
+      if (!context.or && key === "$nor") return "the store cannot answer an $or";
+      if (!Array.isArray(value) || value.length === 0) return "the clause is malformed";
+      for (const part of value) {
+        if (!isPlainObject(part)) return "the clause is malformed";
+        const why = unpushable(part, context);
+        if (why !== void 0) return why;
+      }
+      return void 0;
+    }
+    case "$not": {
+      if (!context.not) return "the store cannot answer a negation";
+      if (!isPlainObject(value)) return "the clause is malformed";
+      return unpushable(value, context);
+    }
+    case "$text":
+      return allows(context, "$text") ? void 0 : "the store cannot answer a text search";
+    default:
+      return `the store cannot test the item itself with "${key}"`;
+  }
+}
+function unpushableField(name, value, context, at) {
+  const field = context.vocabulary?.lookup.get(name.toLowerCase());
+  if (field?.get !== void 0) return `"${name}" is computed here, so the store has no such field`;
+  const stored = storedName(name, context);
+  if (context.fields !== "all" && !context.fields.has(stored)) return `the store cannot filter on "${stored}"`;
+  if (isFieldReference(value)) return allows(context, "$field") ? void 0 : "the store cannot compare two fields";
+  if (!isPlainObject(value) || isDateLiteral(value)) {
+    if (!allows(context, "$eq")) return 'the store cannot answer "$eq"';
+    return accepted(context, stored, { $eq: value });
+  }
+  const keys = Object.keys(value);
+  if (!keys.every((key) => key.startsWith("$"))) {
+    if (!allows(context, "$eq")) return 'the store cannot answer "$eq"';
+    return accepted(context, stored, { $eq: value });
+  }
+  for (const key of keys) {
+    if (key === "$options" || key === "$comment") continue;
+    if (!KNOWN.has(key)) return `"${key}" is an added operator, which only this engine has`;
+    if (!allows(context, key)) return `the store cannot answer "${key}"`;
+    if ((key === "$ne" || key === "$nin" || key === "$not" || key === "$exists" && value[key] === false) && !context.not) {
+      return "the store cannot answer a negation";
+    }
+    const operand2 = value[key];
+    if (isFieldReference(operand2) && !allows(context, "$field")) return "the store cannot compare two fields";
+    if (key === "$elemMatch") {
+      if (!isPlainObject(operand2)) return "the clause is malformed";
+      const why = unpushable(operand2, context);
+      if (why !== void 0) return why;
+    }
+    if (key === "$not") {
+      if (!isPlainObject(operand2)) return "the clause is malformed";
+      const why = unpushableField(name, operand2, context);
+      if (why !== void 0) return why;
+    }
+  }
+  return accepted(context, stored, value);
+}
+function accepted(context, field, condition2) {
+  if (context.accepts === void 0 || context.accepts(field, condition2)) return void 0;
+  return "the store cannot answer this condition's values";
+}
+function allows(context, operator) {
+  return context.operators === "all" || context.operators.has(operator);
+}
+function resolve(value, context) {
+  if (!isPlainObject(value)) return value;
+  const out = {};
+  for (const [key, held] of Object.entries(value)) {
+    switch (key) {
+      case "$and":
+      case "$or":
+      case "$nor":
+        out[key] = Array.isArray(held) ? held.map((part) => resolve(part, context)) : held;
+        break;
+      case "$not":
+        out[key] = resolve(held, context);
+        break;
+      case "$text":
+        out[key] = resolveText(held, context);
+        break;
+      default:
+        if (key.startsWith("$")) out[key] = resolveOperand(key, held, context);
+        else out[storedName(key, context)] = resolveCondition(held, context);
+        break;
+    }
+  }
+  return out;
+}
+function resolveCondition(value, context) {
+  if (!isPlainObject(value)) return resolveLiteral(value, context);
+  if (isDateLiteral(value) || isFieldReference(value)) return resolveOperand("$eq", value, context);
+  const keys = Object.keys(value);
+  if (keys.length === 0 || !keys.every((key) => key.startsWith("$"))) return resolveLiteral(value, context);
+  const out = {};
+  for (const key of keys) out[key] = resolveOperand(key, value[key], context);
+  return out;
+}
+function resolveOperand(key, operand2, context) {
+  if (key === "$elemMatch") return resolve(operand2, context);
+  if (key === "$not") return resolveCondition(operand2, context);
+  if (isFieldReference(operand2)) return { $field: storedName(operand2.$field, context) };
+  if (Array.isArray(operand2)) return operand2.map((item) => isFieldReference(item) ? { $field: storedName(item.$field, context) } : resolveLiteral(item, context));
+  return resolveLiteral(operand2, context);
+}
+function resolveText(value, context) {
+  if (!isPlainObject(value) || !Array.isArray(value.$fields)) return value;
+  return { ...value, $fields: value.$fields.map((name) => typeof name === "string" ? storedName(name, context) : name) };
+}
+function resolveLiteral(value, context) {
+  if (Array.isArray(value)) return value.map((item) => resolveLiteral(item, context));
+  if (!isPlainObject(value)) return value;
+  if (isDateLiteral(value)) {
+    const time = resolveDate(value.$date, context.now);
+    if (Number.isNaN(time)) throw new JqlError(`${JSON.stringify(value.$date)} is not a date`);
+    return { $date: time };
+  }
+  const out = {};
+  for (const [key, held] of Object.entries(value)) out[key] = resolveLiteral(held, context);
+  return out;
+}
+function storedName(key, context) {
+  if (key.startsWith("$") || context.vocabulary === void 0) return key;
+  const field = context.vocabulary.lookup.get(key.toLowerCase());
+  if (field !== void 0) return field.path;
+  const dot = key.indexOf(".");
+  if (dot > 0) {
+    const head = context.vocabulary.lookup.get(key.slice(0, dot).toLowerCase());
+    if (head !== void 0 && head.get === void 0) return `${head.path}${key.slice(dot)}`;
+  }
+  return key;
+}
+
+// src/async.ts
+async function* iterate(source) {
+  if (Array.isArray(source)) {
+    for (let i = 0; i < source.length; i++) yield source[i];
+    return;
+  }
+  if (source instanceof Map) {
+    for (const item of source.values()) yield item;
+    return;
+  }
+  if (typeof source[Symbol.asyncIterator] === "function") {
+    for await (const item of source) yield item;
+    return;
+  }
+  if (typeof source[Symbol.iterator] === "function") {
+    for (const item of source) yield item;
+    return;
+  }
+  const list = source;
+  for (let i = 0; i < list.length; i++) yield list[i];
+}
+async function* filterStream(source, query, options) {
+  const test = compile(query, options);
+  for await (const item of iterate(source)) if (test(item)) yield item;
+}
+async function findAsync(source, query, options) {
+  for await (const item of filterStream(source, query, options)) return item;
+  return void 0;
+}
+async function filterAsync(source, query, options) {
+  const out = [];
+  for await (const item of filterStream(source, query, options)) out.push(item);
+  return out;
+}
+async function countAsync(source, query, options) {
+  let total = 0;
+  const test = compile(query, options);
+  for await (const item of iterate(source)) if (test(item)) total++;
+  return total;
+}
+async function someAsync(source, query, options) {
+  const test = compile(query, options);
+  for await (const item of iterate(source)) if (test(item)) return true;
+  return false;
+}
+async function everyAsync(source, query, options) {
+  const test = compile(query, options);
+  for await (const item of iterate(source)) if (!test(item)) return false;
+  return true;
+}
+async function searchAsync(source, request = {}, options = {}) {
+  const plan2 = planRequest(request, options);
+  const collect2 = plan2.collect();
+  let index = 0;
+  for await (const item of iterate(source)) {
+    const position = index++;
+    if (plan2.test !== void 0 && !plan2.test(item)) continue;
+    if (collect2.offer(item, position)) break;
+  }
+  return plan2.shape(collect2.finish());
+}
+
+export { canonical, countAsync, everyAsync, explain, filterAsync, filterStream, findAsync, fingerprint, group, plan, searchAsync, someAsync };
+//# sourceMappingURL=chunk-VMFEQXBB.js.map
+//# sourceMappingURL=chunk-VMFEQXBB.js.map