@querykitjs/core 1.2.0 → 2.1.0

package/dist/internal.cjs

@@ -0,0 +1,507 @@
+'use strict';
+
+var chunk72KNINHB_cjs = require('./chunk-72KNINHB.cjs');
+
+// src/internal/cursor.ts
+function encodeCursor(value) {
+  let normalized = value instanceof Date ? value.toISOString() : value, json = JSON.stringify({ v: normalized });
+  return Buffer.from(json, "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+  if (cursor)
+    try {
+      let json = Buffer.from(cursor, "base64url").toString("utf8");
+      return JSON.parse(json).v;
+    } catch {
+      return;
+    }
+}
+var isScalar = (value) => typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value), scalarOf = (value) => {
+  let normalized = value instanceof Date ? value.toISOString() : typeof value == "object" && value !== null && typeof value.toJSON == "function" ? value.toJSON() : value;
+  return isScalar(normalized) ? normalized : void 0;
+};
+async function sign(body, secret) {
+  let encoder = new TextEncoder(), key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]), signature = await crypto.subtle.sign("HMAC", key, encoder.encode(body));
+  return Buffer.from(signature).toString("base64url");
+}
+function sameSignature(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let index = 0; index < a.length; index++) diff |= a.charCodeAt(index) ^ b.charCodeAt(index);
+  return diff === 0;
+}
+async function encodeCursorToken(payload, secret) {
+  let body = JSON.stringify({ v: 2, k: scalarOf(payload.k) ?? null, id: scalarOf(payload.id) ?? null }), signed = secret ? JSON.stringify({ ...JSON.parse(body), s: await sign(body, secret) }) : body;
+  return Buffer.from(signed, "utf8").toString("base64url");
+}
+async function decodeCursorToken(token, options) {
+  if (!token) return;
+  let refuse = () => {
+    throw new chunk72KNINHB_cjs.QueryKitError({ source: options.source, site: "cursorKey", key: options.key ?? "cursor", reason: "invalid-value" });
+  }, payload;
+  try {
+    payload = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+  } catch {
+    return refuse();
+  }
+  if (typeof payload != "object" || payload === null || payload.v !== 2 || !isScalar(payload.k) || !isScalar(payload.id)) return refuse();
+  if (options.secret) {
+    let body = JSON.stringify({ v: 2, k: payload.k, id: payload.id });
+    if (typeof payload.s != "string" || !sameSignature(payload.s, await sign(body, options.secret))) return refuse();
+  }
+  return { k: payload.k, id: payload.id };
+}
+
+// src/internal/diagnostics.ts
+function reportSkip(diag, info) {
+  if (!diag) return;
+  let full = { ...info, source: diag.source };
+  if (diag.strict) throw new chunk72KNINHB_cjs.QueryKitError(full);
+  diag.onSkipped?.(full);
+}
+
+// src/internal/context.ts
+function loadAsyncLocalStorage() {
+  let asyncHooks = typeof process < "u" && typeof process.getBuiltinModule == "function" ? process.getBuiltinModule("node:async_hooks") : void 0;
+  if (!asyncHooks?.AsyncLocalStorage)
+    throw new Error("querykit: the repository context needs node:async_hooks (Node >= 22.12 or Bun) \u2014 a querykit adapter cannot run in this runtime");
+  return asyncHooks.AsyncLocalStorage;
+}
+function createContextStore() {
+  let AsyncLocalStorage = loadAsyncLocalStorage(), als = new AsyncLocalStorage();
+  return {
+    get: () => als.getStore(),
+    run: (patch, fn) => als.run({ ...als.getStore(), ...patch }, fn)
+  };
+}
+
+// src/internal/sort.ts
+function normalizeSort(sort, diag) {
+  if (!sort) return [];
+  let items = [];
+  for (let item of sort)
+    item && typeof item.key == "string" && item.key ? items.push({ key: item.key, direction: item.direction ?? "asc" }) : reportSkip(diag, { site: "sort", key: "", reason: "invalid-value" });
+  return items;
+}
+
+// src/internal/pagination.ts
+function clampPageSize(requested, fallback, max) {
+  return Math.min(max, Math.max(1, Math.trunc(requested ?? fallback)));
+}
+function clampPage(requested) {
+  return Math.max(1, Math.trunc(requested ?? 1));
+}
+function clampOffset(requested) {
+  return Math.max(0, Math.trunc(requested ?? 0));
+}
+function offsetMeta(page, perPage, totalItems) {
+  let totalPages = Math.ceil(totalItems / perPage);
+  return {
+    total_items: totalItems,
+    total_pages: totalPages,
+    current_page: page,
+    per_page: perPage,
+    has_next: page < totalPages,
+    has_prev: page > 1
+  };
+}
+function offsetPageWithoutTotal(rows, page, perPage) {
+  let hasNext = rows.length > perPage;
+  return {
+    data: hasNext ? rows.slice(0, perPage) : [...rows],
+    meta: { total_items: null, total_pages: null, current_page: page, per_page: perPage, has_next: hasNext, has_prev: page > 1 }
+  };
+}
+function infinitePage(rows, limit, offset) {
+  let hasMore = rows.length > limit, data = hasMore ? rows.slice(0, limit) : [...rows];
+  return {
+    data,
+    meta: { limit, offset, count: data.length, has_more: hasMore, next_offset: hasMore ? offset + limit : null }
+  };
+}
+async function cursorPage(rows, options) {
+  let { limit, direction, hasCursor, cursorField, idField, secret } = options, hasExtra = rows.length > limit, data = hasExtra ? rows.slice(0, limit) : [...rows];
+  direction === "backward" && (data = data.reverse());
+  let first = data[0], last = data[data.length - 1], hasNext = direction === "forward" ? hasExtra : hasCursor, hasPrev = direction === "forward" ? hasCursor : hasExtra;
+  return {
+    data,
+    meta: {
+      limit,
+      has_next: hasNext,
+      has_prev: hasPrev,
+      next_cursor: hasNext && last ? await encodeCursorToken({ k: last[cursorField], id: last[idField] }, secret) : null,
+      prev_cursor: hasPrev && first ? await encodeCursorToken({ k: first[cursorField], id: first[idField] }, secret) : null
+    }
+  };
+}
+
+// src/internal/mutation.ts
+var isPlainObject = (value) => typeof value == "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+function isAllRows(filter) {
+  return isPlainObject(filter) && filter.all === true && Object.keys(filter).length === 1;
+}
+function isEmptyFilter(filter) {
+  return filter == null || Array.isArray(filter) && filter.length === 0 || isPlainObject(filter) && Object.keys(filter).length === 0;
+}
+function refuseEmptyFilter(source, method) {
+  throw new chunk72KNINHB_cjs.QueryKitError({ source, site: "mutation", key: method, reason: "empty-filter" });
+}
+
+// src/internal/scope.ts
+var isPlainObject2 = (value) => typeof value == "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype, isInScope = (value) => isPlainObject2(value) && Object.keys(value).length === 1 && Array.isArray(value.in);
+function scopeConditions(scope) {
+  return Object.entries(scope ?? {}).map(
+    ([key, value]) => isInScope(value) ? { key, operation: "in", value: [...value.in] } : { key, operation: "=", value }
+  );
+}
+function scopeDefaults(scope) {
+  return Object.fromEntries(Object.entries(scope ?? {}).filter(([, value]) => !isInScope(value)));
+}
+
+// src/internal/with.ts
+var isPlainObject3 = (value) => typeof value == "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype, ruleOf = (relations, name) => {
+  let rule = relations && Object.prototype.hasOwnProperty.call(relations, name) ? relations[name] : void 0;
+  return isPlainObject3(rule) && (rule.columns === "*" || Array.isArray(rule.columns)) ? rule : void 0;
+}, selectedKeys = (selection) => {
+  if (typeof selection == "string") return selection.split(/\s+/).filter(Boolean);
+  if (isPlainObject3(selection)) return Object.keys(selection).filter((key) => !!selection[key]);
+};
+function checkWith(withValue, relations, dialect, source, path = "") {
+  if (withValue == null) return;
+  let refuse = (key) => {
+    throw new chunk72KNINHB_cjs.QueryKitError({ source, site: "with", key: path + key, reason: "forbidden-key" });
+  };
+  if (!isPlainObject3(withValue)) return refuse("with");
+  let checked = {};
+  for (let [name, value] of Object.entries(withValue)) {
+    if (value === false || value === void 0) continue;
+    let rule = ruleOf(relations, name) ?? refuse(name), listed = rule.columns === "*" ? void 0 : new Set(rule.columns), selectListed = () => Object.fromEntries([...listed].map((column) => [column, true]));
+    if (value === true) {
+      checked[name] = listed ? { [dialect.columns]: selectListed() } : true;
+      continue;
+    }
+    isPlainObject3(value) || refuse(name);
+    let options = value, out = {};
+    for (let [key, option] of Object.entries(options)) {
+      let at = `${name}.${key}`;
+      if (key === dialect.columns) {
+        let keys = selectedKeys(option) ?? refuse(at);
+        for (let column of keys) listed && (column.startsWith("-") || !listed.has(column)) && refuse(`${name}.${column}`);
+        out[key] = option;
+      } else if (key === dialect.nested)
+        out[key] = checkWith(option, rule.nested, dialect, source, `${name}.`);
+      else if (dialect.filters.includes(key))
+        checkFilterFields(option, rule, dialect, (field) => refuse(`${name}.${field}`)), out[key] = option;
+      else if (dialect.paging.includes(key))
+        out[key] = option;
+      else if (key === dialect.orderBy) {
+        for (let item of Array.isArray(option) ? option : [option])
+          for (let column of selectedKeys(item) ?? refuse(at)) listed && !listed.has(column) && refuse(`${name}.${column}`);
+        out[key] = option;
+      } else if (key === dialect.options) {
+        for (let sub of Object.keys(isPlainObject3(option) ? option : refuse(at))) dialect.paging.includes(sub) || refuse(`${at}.${sub}`);
+        out[key] = option;
+      } else
+        refuse(at);
+    }
+    listed && out[dialect.columns] === void 0 && (out[dialect.columns] = selectListed()), checked[name] = out;
+  }
+  return checked;
+}
+function checkFilterFields(filter, rule, dialect, refuse) {
+  isPlainObject3(filter) || refuse("filter");
+  for (let [key, value] of Object.entries(filter))
+    if (dialect.logical.includes(key))
+      for (let part of Array.isArray(value) ? value : [value]) checkFilterFields(part, rule, dialect, refuse);
+    else (key.startsWith("$") || !rule.filterable || rule.filterable[key] === void 0) && refuse(key);
+}
+
+// src/internal/limits.ts
+var isRecord = (value) => typeof value == "object" && value !== null && !Array.isArray(value), formatLimit = (limit, max) => `${limit} (${max})`;
+function findFilterLimitViolation(filter, limits) {
+  let hit = (limit, path) => ({ limit, max: limits[limit], path }), pending = [], push = (children, depth, path) => {
+    for (let index = children.length - 1; index >= 0; index--) pending.push([children[index], depth, [...path, index]]);
+  };
+  Array.isArray(filter) ? push(filter, 1, []) : filter !== void 0 && pending.push([filter, 1, []]);
+  let conditions = 0;
+  for (let next = pending.pop(); next; next = pending.pop()) {
+    let [node, depth, path] = next;
+    if (depth > limits.maxDepth) return hit("maxDepth", path);
+    if (!isRecord(node)) continue;
+    if ("key" in node) {
+      if (++conditions > limits.maxConditions) return hit("maxConditions", path);
+      let { value } = node, valuePath = [...path, "value"];
+      if (Array.isArray(value) && value.length > limits.maxInItems) return hit("maxInItems", valuePath);
+      let tooLong = (Array.isArray(value) ? value : [value]).findIndex((item) => typeof item == "string" && item.length > limits.maxStringLength);
+      if (tooLong >= 0) return hit("maxStringLength", Array.isArray(value) ? [...valuePath, tooLong] : valuePath);
+      continue;
+    }
+    let group = "and" in node ? "and" : "or" in node ? "or" : void 0;
+    if (group) {
+      let children = node[group];
+      Array.isArray(children) && push(children, depth + 1, [...path, group]);
+    } else "not" in node && pending.push([node.not, depth + 1, [...path, "not"]]);
+  }
+}
+var LIKE_OPERATORS = /* @__PURE__ */ new Set(["like", "ilike", "notLike"]), isLikeOperator = (operation) => LIKE_OPERATORS.has(operation);
+function likeWildcards(pattern) {
+  let count = 0, previous = "";
+  for (let index = 0; index < pattern.length; index++) {
+    let char = pattern[index];
+    if (char === "\\") {
+      index++, previous = "";
+      continue;
+    }
+    (char === "_" || char === "%" && previous !== "%") && count++, previous = char;
+  }
+  return count;
+}
+var offsetOf = (page, perPage) => ((page ?? 1) - 1) * (perPage ?? 20);
+
+// src/internal/policy.ts
+var DEFAULT_OPERATORS = ["=", "in"], OPERATOR_TOKEN = {
+  eq: "=",
+  ne: "!=",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<=",
+  contains: "%_%",
+  startsWith: "%_",
+  endsWith: "_%"
+}, tokenOf = (operation) => OPERATOR_TOKEN[operation] ?? operation, isRecord2 = (value) => typeof value == "object" && value !== null && !Array.isArray(value);
+function filterRules(options, canonical) {
+  let rules = /* @__PURE__ */ new Map();
+  if (options.filterable) {
+    for (let [key, operators] of Object.entries(options.filterable))
+      operators && rules.set(canonical(key), operators === "*" ? "*" : new Set(operators.map(tokenOf)));
+    return rules;
+  }
+  let fields = options.allowedColumns ?? (options.forcedColumns ? Object.keys(options.forcedColumns).filter((key) => options.forcedColumns[key]) : [options.primaryKey]), equality = new Set(DEFAULT_OPERATORS);
+  for (let field of fields) rules.set(canonical(field), equality);
+  return rules;
+}
+function resolvePolicy(options) {
+  let limits = chunk72KNINHB_cjs.resolveLimits(options.limits), canonical = (key) => options.fieldOf(key) ?? key, rules = filterRules(options, canonical), sortable = new Set((options.sortable ?? [options.primaryKey, ...options.createdAt ? [options.createdAt] : []]).map(canonical)), refuse = (site, key, reason, operation) => {
+    throw new chunk72KNINHB_cjs.QueryKitError({ source: options.source, site, key, reason, ...operation ? { operation } : {} });
+  }, checkCondition2 = (node) => {
+    let key = String(node.key), field = options.fieldOf(key);
+    if (field === void 0) return;
+    let operation = typeof node.operation == "string" ? node.operation : "=", rule = rules.get(field);
+    rule || refuse("filter", key, "forbidden-key", operation), rule !== "*" && !rule.has(tokenOf(operation)) && refuse("filter", key, "forbidden-operator", operation), isLikeOperator(operation) && typeof node.value == "string" && likeWildcards(node.value) > limits.maxLikeWildcards && refuse("filter", "maxLikeWildcards", "limit-exceeded", operation);
+  }, checkSortKey = (site, key) => {
+    let field = options.fieldOf(key);
+    field !== void 0 && !sortable.has(field) && refuse(site, key, "forbidden-key");
+  };
+  return {
+    limits,
+    checkFilter(filter) {
+      let violation = findFilterLimitViolation(filter, limits);
+      violation && refuse("filter", violation.limit, "limit-exceeded");
+      let pending = Array.isArray(filter) ? [...filter] : [filter];
+      for (; pending.length > 0; ) {
+        let node = pending.pop();
+        isRecord2(node) && ("key" in node ? checkCondition2(node) : Array.isArray(node.and) ? pending.push(...node.and) : Array.isArray(node.or) ? pending.push(...node.or) : "not" in node ? pending.push(node.not) : !chunk72KNINHB_cjs.isRaw(node) && !options.isNative?.(node) && refuse("filter", Object.keys(node)[0] ?? "", "forbidden-key"));
+      }
+    },
+    checkSort(sort) {
+      if (sort) {
+        sort.length > limits.maxSortFields && refuse("sort", "maxSortFields", "limit-exceeded");
+        for (let item of sort) item && typeof item.key == "string" && item.key && checkSortKey("sort", item.key);
+      }
+    },
+    checkCursorKey(key) {
+      checkSortKey("cursorKey", key);
+    },
+    checkPage(page) {
+      ("offset" in page ? page.offset : offsetOf(page.page, page.perPage)) > limits.maxOffset && refuse("page", "maxOffset", "limit-exceeded");
+    },
+    checkAggregateKey(key) {
+      let field = options.fieldOf(key);
+      field !== void 0 && !rules.has(field) && refuse("aggregate", key, "forbidden-key");
+    }
+  };
+}
+
+// src/internal/wire-checks.ts
+var ALL_OPERATORS = /* @__PURE__ */ new Set(chunk72KNINHB_cjs.FILTER_OPERATORS), isRecord3 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), isScalar2 = (value) => value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value), isFilterValue = (value) => Array.isArray(value) ? value.every(isScalar2) : isScalar2(value), label = (value) => {
+  try {
+    return String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}, wireIssue = (key, path, args = {}) => ({ path, key, args });
+function checkCondition(node, path, walk) {
+  if (!isRecord3(node)) {
+    walk.issues.push(wireIssue("querykit.filter.invalid_node", path));
+    return;
+  }
+  let { key, operation, value } = node;
+  if (typeof key != "string") {
+    walk.issues.push(wireIssue("querykit.filter.missing_key", path));
+    return;
+  }
+  walk.allowedKeys && !walk.allowedKeys.has(key) && walk.issues.push(wireIssue("querykit.filter.unknown_key", path, { key }));
+  let operator;
+  operation !== void 0 && (typeof operation == "string" && walk.operators.has(operation) ? operator = operation : walk.issues.push(wireIssue("querykit.filter.invalid_operator", [...path, "operation"], { operation: label(operation) }))), value !== void 0 && !isFilterValue(value) && walk.issues.push(wireIssue("querykit.filter.invalid_value", [...path, "value"])), walk.strictValue && operator !== void 0 && checkValueShape(operator, value, [...path, "value"], walk);
+}
+function checkValueShape(operator, value, path, walk) {
+  let key = (operator === "in" || operator === "notIn") && !Array.isArray(value) ? "querykit.filter.value_requires_array" : (operator === "between" || operator === "notBetween") && (!Array.isArray(value) || value.length !== 2) ? "querykit.filter.value_requires_tuple" : (operator === "isNull" || operator === "isNotNull") && value !== void 0 ? "querykit.filter.value_forbidden" : void 0;
+  key && walk.issues.push(wireIssue(key, path, { operation: operator }));
+}
+function walkGroup(group, depth, path, walk) {
+  if (!Array.isArray(group)) {
+    walk.issues.push(wireIssue("querykit.filter.invalid_group", path));
+    return;
+  }
+  group.forEach((child, index) => walkNode(child, depth + 1, [...path, index], walk));
+}
+function walkNode(node, depth, path, walk) {
+  if (depth > walk.maxDepth) {
+    walk.issues.push(wireIssue("querykit.filter.max_depth", path, { max: walk.maxDepth }));
+    return;
+  }
+  if (!isRecord3(node)) {
+    walk.issues.push(wireIssue("querykit.filter.invalid_node", path));
+    return;
+  }
+  "key" in node ? checkCondition(node, path, walk) : "and" in node ? walkGroup(node.and, depth, [...path, "and"], walk) : "or" in node ? walkGroup(node.or, depth, [...path, "or"], walk) : "not" in node ? walkNode(node.not, depth + 1, [...path, "not"], walk) : walk.issues.push(wireIssue("querykit.filter.missing_key", path));
+}
+function checkFilter(value, options = {}) {
+  if (value === void 0) return [];
+  let limits = chunk72KNINHB_cjs.resolveLimits(options), violation = findFilterLimitViolation(value, limits);
+  if (violation) {
+    let key = violation.limit === "maxDepth" ? "querykit.filter.max_depth" : "querykit.limit.exceeded";
+    return [wireIssue(key, violation.path, { limit: violation.limit, max: violation.max })];
+  }
+  let walk = {
+    issues: [],
+    allowedKeys: options.allowedKeys ? new Set(options.allowedKeys) : void 0,
+    operators: options.allowedOperators ? new Set(options.allowedOperators) : ALL_OPERATORS,
+    maxDepth: limits.maxDepth,
+    strictValue: options.strictValue ?? false
+  };
+  return Array.isArray(value) ? value.forEach((item, index) => checkCondition(item, [index], walk)) : walkNode(value, 1, [], walk), walk.issues;
+}
+function checkSort(value, options = {}) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) return [wireIssue("querykit.sort.not_array", [])];
+  let { maxSortFields } = chunk72KNINHB_cjs.resolveLimits(options);
+  if (value.length > maxSortFields) return [wireIssue("querykit.limit.exceeded", [], { limit: "maxSortFields", max: maxSortFields })];
+  let allowedKeys = options.allowedKeys ? new Set(options.allowedKeys) : void 0, issues = [];
+  return value.forEach((item, index) => {
+    if (!isRecord3(item)) {
+      issues.push(wireIssue("querykit.sort.invalid_item", [index]));
+      return;
+    }
+    let { key, direction } = item;
+    if (typeof key != "string") {
+      issues.push(wireIssue("querykit.sort.missing_key", [index]));
+      return;
+    }
+    allowedKeys && !allowedKeys.has(key) && issues.push(wireIssue("querykit.sort.unknown_key", [index], { key })), direction !== void 0 && direction !== "asc" && direction !== "desc" && issues.push(wireIssue("querykit.sort.invalid_direction", [index, "direction"]));
+  }), issues;
+}
+var prefixed = (path, issues) => issues.map((found) => ({ ...found, path: [...path, ...found.path] })), accepts = (expected, value) => expected === "object" ? isRecord3(value) : expected === "string or null" ? value === null || typeof value == "string" : typeof value === expected, typed = (expected) => (value, path, issues) => {
+  accepts(expected, value) || issues.push(wireIssue("querykit.params.invalid_type", path, { expected: `${expected === "object" ? "an" : "a"} ${expected}` }));
+}, oneOf = (values) => (value, path, issues) => {
+  (typeof value != "string" || !values.includes(value)) && issues.push(wireIssue("querykit.params.invalid_enum", path, { values: values.join(", ") }));
+}, integer = (min, max, overLimit) => (value, path, issues) => {
+  typeof value != "number" || !Number.isFinite(value) ? issues.push(wireIssue("querykit.params.invalid_type", path, { expected: "a number" })) : Number.isInteger(value) ? value < min ? issues.push(wireIssue("querykit.params.out_of_range", path, { min })) : value > max && overLimit ? issues.push(wireIssue("querykit.limit.exceeded", path, { limit: overLimit, max })) : value > max && issues.push(wireIssue("querykit.params.out_of_range", path, { max })) : issues.push(wireIssue("querykit.params.not_integer", path));
+}, checkColumns = (value, path, issues) => {
+  if (typed("object")(value, path, issues), isRecord3(value)) for (let [name, flag] of Object.entries(value)) typed("boolean")(flag, [...path, name], issues);
+}, serverOwnedCheck = (field) => field === "columns" ? checkColumns : typed(field === "with" ? "object" : "boolean");
+function fieldChecks(kind, options, limits) {
+  let checks = /* @__PURE__ */ new Map();
+  checks.set("filter", (value, path, issues) => issues.push(...prefixed(path, checkFilter(value, limits)))), kind !== "cursor" && checks.set("sort", (value, path, issues) => issues.push(...prefixed(path, checkSort(value, limits))));
+  for (let field of options.allow ?? []) checks.set(field, serverOwnedCheck(field));
+  let maxLimit = options.maxLimit ?? 200;
+  return kind === "offset" ? (checks.set("page", integer(1, Number.POSITIVE_INFINITY)), checks.set("perPage", integer(1, options.maxPerPage ?? 200)), checks.set("withTotal", typed("boolean"))) : kind === "infinite" ? (checks.set("limit", integer(1, maxLimit)), checks.set("offset", integer(0, limits.maxOffset, "maxOffset"))) : (checks.set("limit", integer(1, maxLimit)), checks.set("cursor", typed("string or null")), checks.set("cursorKey", typed("string")), checks.set("order", oneOf(["asc", "desc"])), checks.set("direction", oneOf(["forward", "backward"]))), checks;
+}
+function checkParams(kind, value, options = {}) {
+  if (!isRecord3(value)) return { issues: [wireIssue("querykit.params.invalid_type", [], { expected: "an object" })] };
+  let limits = chunk72KNINHB_cjs.resolveLimits(options.limits), checks = fieldChecks(kind, options, limits), issues = [], accepted = {};
+  for (let [name, field] of Object.entries(value)) {
+    let check = checks.get(name);
+    if (!check || field === void 0) continue;
+    let before = issues.length;
+    check(field, [name], issues), issues.length === before && (accepted[name] = field);
+  }
+  if (kind === "offset" && issues.length === 0) {
+    let page = typeof accepted.page == "number" ? accepted.page : void 0, perPage = typeof accepted.perPage == "number" ? accepted.perPage : void 0;
+    offsetOf(page, perPage) > limits.maxOffset && issues.push(wireIssue("querykit.limit.exceeded", ["page"], { limit: "maxOffset", max: limits.maxOffset }));
+  }
+  return issues.length ? { issues } : { value: accepted, issues };
+}
+
+// src/internal/messages.ts
+var QUERYKIT_MESSAGES_EN = {
+  "querykit.filter.invalid_node": "{path} must be a filter condition or an and/or/not group",
+  "querykit.filter.missing_key": "{path} is missing the required `key` string",
+  "querykit.filter.unknown_key": "{path}: `{key}` is not an allowed filter key",
+  "querykit.filter.invalid_operator": "{path}: `{operation}` is not a supported filter operator",
+  "querykit.filter.invalid_value": "{path} must be a string, number, boolean, null, or an array of those",
+  "querykit.filter.invalid_group": "{path} must be an array of filter nodes",
+  "querykit.filter.max_depth": "{path} exceeds maxDepth ({max})",
+  "querykit.filter.value_requires_array": "{path}: `{operation}` requires an array value",
+  "querykit.filter.value_requires_tuple": "{path}: `{operation}` requires exactly two values",
+  "querykit.filter.value_forbidden": "{path}: `{operation}` must not carry a value",
+  "querykit.sort.not_array": "{path} must be an array of { key, direction } items",
+  "querykit.sort.invalid_item": "{path} must be an object with a `key` string",
+  "querykit.sort.missing_key": "{path} is missing the required `key` string",
+  "querykit.sort.unknown_key": "{path}: `{key}` is not an allowed sort key",
+  "querykit.sort.invalid_direction": "{path}: direction must be `asc` or `desc`",
+  "querykit.limit.exceeded": "{path} exceeds {limit} ({max})"
+}, QUERYKIT_PARAMS_MESSAGES_EN = {
+  "querykit.params.invalid_type": "{path} must be {expected}",
+  "querykit.params.not_integer": "{path} must be an integer",
+  // args carry only the crossed bound (`min` or `max`), so the text names neither
+  "querykit.params.out_of_range": "{path} is out of the allowed range",
+  "querykit.params.invalid_enum": "{path} must be one of: {values}"
+}, PLACEHOLDER = /\{(\w+)\}/g, interpolate = (template, args) => template.replace(PLACEHOLDER, (match, name) => {
+  let value = args[name];
+  return value === void 0 ? match : String(value);
+});
+function formatMessage(key, args = {}, catalog = QUERYKIT_MESSAGES_EN) {
+  return interpolate(catalog[key], args);
+}
+
+Object.defineProperty(exports, "isRaw", {
+  enumerable: true,
+  get: function () { return chunk72KNINHB_cjs.isRaw; }
+});
+exports.QUERYKIT_MESSAGES_EN = QUERYKIT_MESSAGES_EN;
+exports.QUERYKIT_PARAMS_MESSAGES_EN = QUERYKIT_PARAMS_MESSAGES_EN;
+exports.checkFilter = checkFilter;
+exports.checkParams = checkParams;
+exports.checkSort = checkSort;
+exports.checkWith = checkWith;
+exports.clampOffset = clampOffset;
+exports.clampPage = clampPage;
+exports.clampPageSize = clampPageSize;
+exports.createContextStore = createContextStore;
+exports.cursorPage = cursorPage;
+exports.decodeCursor = decodeCursor;
+exports.decodeCursorToken = decodeCursorToken;
+exports.encodeCursor = encodeCursor;
+exports.encodeCursorToken = encodeCursorToken;
+exports.findFilterLimitViolation = findFilterLimitViolation;
+exports.formatLimit = formatLimit;
+exports.formatMessage = formatMessage;
+exports.infinitePage = infinitePage;
+exports.interpolate = interpolate;
+exports.isAllRows = isAllRows;
+exports.isEmptyFilter = isEmptyFilter;
+exports.isLikeOperator = isLikeOperator;
+exports.likeWildcards = likeWildcards;
+exports.normalizeSort = normalizeSort;
+exports.offsetMeta = offsetMeta;
+exports.offsetOf = offsetOf;
+exports.offsetPageWithoutTotal = offsetPageWithoutTotal;
+exports.refuseEmptyFilter = refuseEmptyFilter;
+exports.reportSkip = reportSkip;
+exports.resolvePolicy = resolvePolicy;
+exports.scopeConditions = scopeConditions;
+exports.scopeDefaults = scopeDefaults;
+//# sourceMappingURL=internal.cjs.map
+//# sourceMappingURL=internal.cjs.map