okmodel 0.6.0 → 0.8.0

package/dist/tooling/shared/smn6kz1p.js

@@ -0,0 +1,157 @@
+import {
+  assertNoControl
+} from "./3tq8pnb8.js";
+import {
+  throwNamed,
+  isOperator,
+  operatorName,
+  operatorValue,
+  tag,
+  refuseHidden,
+  indexes,
+  list,
+  isRecord,
+  fail2
+} from "./f9mphxej.js";
+
+// src/dialects/pg/ops/search-query.ts
+function searchValue(query, options) {
+  return {
+    query,
+    match: options?.match ?? "natural",
+    language: options?.language
+  };
+}
+
+// src/runtime/text-search.ts
+var MATCHES = ["natural", "all-words", "phrase", "advanced"];
+var SEARCH_KEYS = ["for", "in", "match", "language"];
+function applyTextSearch(schema, call) {
+  const table = indexes(schema).get(call.table);
+  if (table === undefined)
+    fail2("OKM1120", `Table ${call.table} is not in the schema.`);
+  const spec = parseSearch(table, call.search);
+  const options = { match: spec.match, language: spec.language };
+  const where = withMatch(call.where, spec.column.field, spec.text, options);
+  const orderBy = call.op === "find" && call.orderBy === undefined ? ranked(table, spec.column.field, spec.text, options) : call.orderBy;
+  const { search: dropped, ...rest } = call;
+  return {
+    ...rest,
+    where,
+    ...orderBy !== undefined ? { orderBy } : {}
+  };
+}
+function parseSearch(table, search) {
+  if (typeof search === "string") {
+    return { text: textOf(search), column: columnFor(table, undefined), ...natural() };
+  }
+  if (!isRecord(search)) {
+    fail2("OKM1120", "search needs the text to look for, or { for, in, match, language }.", "Pass a string, or search: { for, in }.");
+  }
+  for (const key of Object.keys(search)) {
+    if (SEARCH_KEYS.includes(key))
+      continue;
+    fail2("OKM1120", `search does not take ${key}. Accepted: for, in, match, language.`, "Pass for, in, match, and language.");
+  }
+  if (typeof search.for !== "string") {
+    fail2("OKM1120", "search.for needs text to look for.", "Set for to the text you want to find.");
+  }
+  const named = search.in;
+  if (named !== undefined && typeof named !== "string") {
+    fail2("OKM1120", "search.in names the column to search.", "Set in to a column name.");
+  }
+  return {
+    text: textOf(search.for),
+    column: columnFor(table, named),
+    match: matchOf(search.match),
+    language: languageOf(search.language)
+  };
+}
+function natural() {
+  return { match: "natural", language: undefined };
+}
+function textOf(text) {
+  if (text.length === 0) {
+    fail2("OKM1120", "search needs text to look for.", "Pass the words you want to find.");
+  }
+  assertNoControl(text, "search");
+  return text;
+}
+function matchOf(value) {
+  if (value === undefined)
+    return "natural";
+  if (typeof value === "string" && isMatch(value))
+    return value;
+  fail2("OKM1120", "search.match must be natural, all-words, phrase, or advanced.", "Use natural, all-words, phrase, or advanced.");
+}
+function isMatch(value) {
+  return MATCHES.includes(value);
+}
+function languageOf(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string") {
+    fail2("OKM1120", "search.language must be a text search language such as english.", "Pass a language name such as english, or leave it out.");
+  }
+  return value;
+}
+function columnFor(table, name) {
+  const columns = searchable(table);
+  const names = columns.map((column) => column.field);
+  if (name === undefined) {
+    const only = columns[0];
+    if (columns.length === 1 && only !== undefined)
+      return only;
+    if (columns.length === 0) {
+      fail2("OKM1120", `Table ${table.model.name} has no column you can search.`, "Add a column built for search.");
+    }
+    fail2("OKM1120", `Table ${table.model.name} has more than one column you can search. Name one with search: { for, in }. Columns: ${list(names)}.`, `Set in to one of: ${list(names)}.`);
+  }
+  const column = table.columns.get(name);
+  if (column === undefined) {
+    throwNamed("OKM1120", name, names, `Column ${name} is not on ${table.model.name}. Columns you can search: ${list(names)}.`);
+  }
+  if (column.dataType !== "tsvector") {
+    fail2("OKM1120", `Column ${name} cannot be searched. Columns you can search: ${list(names)}.`, names.length === 0 ? "This table has no column you can search." : `Search one of: ${list(names)}.`);
+  }
+  if (column.hidden === true)
+    refuseHidden(column);
+  return column;
+}
+function searchable(table) {
+  const found = [];
+  for (const column of table.model.columns) {
+    if (column.dataType === "tsvector" && column.hidden !== true)
+      found.push(column);
+  }
+  return found;
+}
+function withMatch(where, field, text, options) {
+  const filter = { [field]: tag("matches", searchValue(text, passed(options))) };
+  if (where === undefined)
+    return filter;
+  if (isOperator(where) && operatorName(where) === "and") {
+    const branches = operatorValue(where);
+    if (Array.isArray(branches))
+      return tag("and", [...branches, filter]);
+  }
+  return tag("and", [where, filter]);
+}
+function ranked(table, field, text, options) {
+  const order = {
+    [field]: tag("relevance", searchValue(text, passed(options)))
+  };
+  for (const key of table.model.primary) {
+    if (!Object.hasOwn(order, key))
+      order[key] = "asc";
+  }
+  return order;
+}
+function passed(options) {
+  if (options.language === undefined)
+    return { match: options.match };
+  return { match: options.match, language: options.language };
+}
+export {
+  applyTextSearch
+};