okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/c0xevn1h.js

@@ -0,0 +1,312 @@
+import {
+  readSelectFragment,
+  emitSqlSelect,
+  decodeSqlNumber
+} from "./ybdew6j7.js";
+import"./w5d89rb4.js";
+import {
+  refusePrototypeKey
+} from "./0j0jtse1.js";
+import {
+  throwNamed,
+  emitWhere,
+  emitOrder,
+  refuseHidden,
+  emitLimit,
+  parseOrder,
+  projectExpr,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/dialects/pg/ops/window.ts
+var RUNTIME = Symbol.for("okmodel.window");
+function isWindow(value) {
+  return typeof value === "object" && value !== null && RUNTIME in value;
+}
+
+// src/runtime/window.ts
+var AS_NUMBER = (wire) => Number(wire);
+var AS_TEXT = (wire) => wire;
+var NUMERIC = /^(smallint|integer|bigint|real|double precision|numeric|decimal)\b/;
+var OPTION_KEYS = ["as", "orderBy", "partitionBy"];
+function attach(schema, call) {
+  const table = indexesOf(schema, call.table);
+  return { ...call, build: statement(readSpec(table, call.select)) };
+}
+function statement(spec) {
+  return (schema, table, sink, outputs, call, hooks) => {
+    sink.mark(`${call.op}|${table.model.name}|`);
+    if (call.include !== undefined && hooks === undefined) {
+      fail2("OKM1120", "An include needs the include planner.");
+    }
+    const includes = hooks === undefined || call.include === undefined ? [] : hooks.read(schema, table, call.include, call.all);
+    sink.text("select ");
+    let column = 0;
+    for (const item of spec.items) {
+      if (column > 0)
+        sink.text(", ");
+      if (item.kind === "column") {
+        sink.text(projectExpr(`t.${quote(item.column.sql)}`, item.column.dataType));
+        sink.mark(`s:${item.column.field}`);
+        outputs?.fields.push({ key: item.column.field, at: column, decode: item.column.decode });
+      } else if (item.kind === "sql") {
+        emitSqlSelect(table, item.parts, sink, "t");
+        sink.text("::text");
+        sink.mark(`s:${item.as}`);
+        outputs?.fields.push({
+          key: item.as,
+          at: column,
+          decode: item.textual === true ? AS_TEXT : decodeSqlNumber
+        });
+      } else {
+        emitWindow(table, item.window, sink);
+        sink.text("::text");
+        outputs?.fields.push({ key: item.window.as, at: column, decode: item.window.decode });
+      }
+      column += 1;
+    }
+    if (spec.items.length === 0 && includes.length === 0)
+      sink.text("1");
+    for (let index = 0;index < includes.length; index += 1) {
+      const include = includes[index];
+      if (include === undefined || hooks === undefined)
+        continue;
+      column = hooks.select(include, `i${String(index)}`, sink, outputs, column);
+    }
+    sink.text(" from ");
+    sink.text(quote(table.model.sql));
+    sink.text(" t");
+    for (let index = 0;index < includes.length; index += 1) {
+      const include = includes[index];
+      if (include === undefined || hooks === undefined)
+        continue;
+      hooks.join(schema, include, sink, "t", `i${String(index)}`, 0);
+    }
+    emitWhere(schema, table, call.where, sink, "t", 0, false, call.after);
+    emitResultOrder(table, call.orderBy, sink, spec.ordinals);
+    emitLimit(call, sink);
+    call.tail?.(sink);
+  };
+}
+function emitResultOrder(table, orderBy, sink, ordinals) {
+  if (!isRecord(orderBy) || !mentionsOrdinal(orderBy, ordinals)) {
+    emitOrder(table, orderBy, sink, "t");
+    return;
+  }
+  const keys = Object.keys(orderBy);
+  sink.text(" order by ");
+  for (let index = 0;index < keys.length; index += 1) {
+    const key = keys[index];
+    if (key === undefined)
+      continue;
+    const parsed = parseOrder(key, orderBy[key]);
+    if (index > 0)
+      sink.text(", ");
+    const ordinal = ordinals.get(key);
+    if (ordinal !== undefined) {
+      sink.text(ordinal);
+    } else {
+      const column = table.columns.get(key);
+      if (column === undefined) {
+        throwNamed("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+      }
+      refuseHidden(column);
+      sink.text("t.");
+      sink.text(quote(column.sql));
+    }
+    sink.text(parsed.dir === "asc" ? " asc" : " desc");
+    sink.text(parsed.nulls === "first" ? " nulls first" : " nulls last");
+    sink.mark(`o:${key}:${parsed.dir}:${parsed.nulls}`);
+  }
+}
+function mentionsOrdinal(orderBy, ordinals) {
+  if (ordinals.size === 0)
+    return false;
+  for (const key of Object.keys(orderBy)) {
+    if (ordinals.has(key))
+      return true;
+  }
+  return false;
+}
+function emitWindow(table, win, sink) {
+  sink.mark(`w:${win.fn}:${win.as}:p:${win.partition.map((column) => column.field).join("+")}`);
+  if (win.fn === "sum") {
+    const column = win.column;
+    if (column === undefined)
+      fail2("OKM1120", "runningTotal needs a column.");
+    sink.text("sum(t.");
+    sink.text(quote(column.sql));
+    sink.text(")");
+  } else {
+    sink.text(win.fn);
+    sink.text("()");
+  }
+  sink.text(" over (");
+  if (win.partition.length > 0) {
+    sink.text("partition by ");
+    for (let index = 0;index < win.partition.length; index += 1) {
+      const column = win.partition[index];
+      if (column === undefined)
+        continue;
+      if (index > 0)
+        sink.text(", ");
+      sink.text("t.");
+      sink.text(quote(column.sql));
+    }
+  }
+  emitOrder(table, win.orderBy, sink, "t");
+  if (win.tieBreak) {
+    const named = isRecord(win.orderBy) ? Object.keys(win.orderBy) : [];
+    for (const field of table.model.primary) {
+      if (named.includes(field))
+        continue;
+      const column = table.columns.get(field);
+      if (column === undefined)
+        continue;
+      sink.text(", t.");
+      sink.text(quote(column.sql));
+      sink.text(" asc");
+    }
+  }
+  sink.text(")");
+}
+function readSpec(table, select) {
+  if (!Array.isArray(select))
+    fail2("OKM1120", "select must be a list of field names.");
+  const items = [];
+  const ordinals = new Map;
+  const names = new Set;
+  for (const entry of select) {
+    if (typeof entry === "string") {
+      const column = columnOn(table, entry, "select");
+      names.add(column.field);
+      items.push({ kind: "column", column });
+      continue;
+    }
+    const sql = readSelectFragment(entry);
+    if (sql !== undefined) {
+      const as = readAs(sql.as, "fragment");
+      if (names.has(as) || table.columns.has(as)) {
+        fail2("OKM1120", `fragment as ${as} clashes with a column of ${table.model.name}.`, "Pick an as name that is not a column.");
+      }
+      names.add(as);
+      ordinals.set(as, String(items.length + 1));
+      items.push(sql.textual === true ? { kind: "sql", as, parts: sql.parts, textual: true } : { kind: "sql", as, parts: sql.parts });
+      continue;
+    }
+    if (!isWindow(entry)) {
+      fail2("OKM1120", "select takes field names or a window helper. A plain object is not a window.", "Pass rowNumber, rank, denseRank, or runningTotal.");
+    }
+    const win = readWindow(table, entry, names);
+    names.add(win.as);
+    ordinals.set(win.as, String(items.length + 1));
+    items.push({ kind: "window", window: win });
+  }
+  return { items, ordinals };
+}
+function readWindow(table, call, taken) {
+  if (!isRecord(call))
+    fail2("OKM1120", "A window helper was not created by its function.");
+  for (const key of Object.keys(call)) {
+    if (key === "label" || key === "fn" || key === "column")
+      continue;
+    if (OPTION_KEYS.includes(key))
+      continue;
+    fail2("OKM1120", `${call.label} does not take ${key}. Accepted: partitionBy, orderBy, as.`, "Pass partitionBy, orderBy, and as.");
+  }
+  const as = readAs(call.as, call.label);
+  if (taken.has(as) || table.columns.has(as)) {
+    fail2("OKM1120", `${call.label} as ${as} clashes with a column of ${table.model.name}.`, "Pick an as name that is not a column.");
+  }
+  const partition = readPartition(table, call.partitionBy, call.label);
+  if (!isRecord(call.orderBy) || Object.keys(call.orderBy).length === 0) {
+    fail2("OKM1120", `${call.label} needs orderBy, the order inside the group.`, 'Pass orderBy: { field: "desc" }.');
+  }
+  for (const field of Object.keys(call.orderBy))
+    columnOn(table, field, `${call.label} orderBy`);
+  let column;
+  let decode = AS_NUMBER;
+  if (call.fn === "sum") {
+    if (typeof call.column !== "string") {
+      fail2("OKM1120", "runningTotal needs the column to total.");
+    }
+    column = columnOn(table, call.column, "runningTotal");
+    if (!NUMERIC.test(column.dataType)) {
+      fail2("OKM1124", `runningTotal does not apply to ${column.dataType} column ${column.field}. It takes integer, real, and numeric columns.`);
+    }
+    decode = totalDecode(column);
+  }
+  return {
+    fn: call.fn,
+    label: call.label,
+    column,
+    partition,
+    orderBy: call.orderBy,
+    as,
+    decode,
+    tieBreak: call.fn === "row_number" || call.fn === "sum"
+  };
+}
+function readPartition(table, value, label) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value) || value.length === 0) {
+    fail2("OKM1120", `${label} partitionBy needs the fields that form the group.`, 'Pass partitionBy: ["status"], or leave it out to use the whole result.');
+  }
+  const columns = [];
+  const seen = new Set;
+  for (const name of value) {
+    if (typeof name !== "string") {
+      fail2("OKM1120", `${label} partitionBy takes field names.`);
+    }
+    const column = columnOn(table, name, `${label} partitionBy`);
+    if (seen.has(column.field)) {
+      fail2("OKM1120", `${label} partitionBy lists ${column.field} twice.`);
+    }
+    seen.add(column.field);
+    columns.push(column);
+  }
+  return columns;
+}
+function readAs(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    fail2("OKM1120", `${label} needs as, the name of the result key.`, "Set as to a name, such as n.");
+  }
+  for (let index = 0;index < value.length; index += 1) {
+    if ((value.charCodeAt(index) ?? 0) < 32) {
+      fail2("OKM1120", `${label} as has a control character.`);
+    }
+  }
+  refusePrototypeKey(value, `${label} as`);
+  return value;
+}
+function totalDecode(column) {
+  const kind = typeof (column.decode?.("0") ?? "");
+  if (kind === "string")
+    return AS_TEXT;
+  if (kind === "number")
+    return AS_NUMBER;
+  return fail2("OKM1124", `runningTotal needs a column whose value is a number or a string. ${column.field} reads as ${kind}.`);
+}
+function columnOn(table, name, where) {
+  const column = table.columns.get(name);
+  if (column === undefined) {
+    throwNamed("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. ${where} accepts: ${list(table.names)}.`);
+  }
+  if (where !== "select")
+    refuseHidden(column);
+  return column;
+}
+function indexesOf(schema, name) {
+  const table = indexes(schema).get(name);
+  if (table === undefined)
+    fail2("OKM1120", `Table ${name} is not in the schema.`);
+  return table;
+}
+export {
+  attach
+};

package/dist/tooling/shared/dhatassp.js

@@ -0,0 +1,134 @@
+import {
+  withHttp,
+  attachHttp,
+  mapOptions
+} from "./jr2nmr81.js";
+import {
+  OkmError,
+  POSTGRES_FLOOR,
+  isPostgresMajor,
+  parsePostgresFloor,
+  serverNeedsPostgres
+} from "./hfq3n3bd.js";
+
+// src/runtime/artifact-file.ts
+function artifactDir(catalogDir) {
+  if (catalogDir !== undefined)
+    return catalogDir.replace(/[/\\]+$/, "");
+  const cwd = globalThis.process?.cwd?.() ?? ".";
+  return `${cwd}/.okm`;
+}
+async function readText(path) {
+  const bun = globalThis.Bun;
+  if (bun !== undefined) {
+    const file = bun.file(path);
+    if (!await file.exists())
+      return;
+    return file.text();
+  }
+  const loader = globalThis.process?.getBuiltinModule;
+  if (loader === undefined)
+    return;
+  try {
+    return await loader("node:fs/promises").readFile(path, "utf8");
+  } catch {
+    return;
+  }
+}
+
+// src/runtime/server-check.ts
+var versionQuery = "select current_setting('server_version_num'), version(), (select (xpath('//catalog_hash/text()', query_to_xml('select catalog_hash from okm_meta where id = ''head''', true, false, '')))[1]::text where to_regclass('okm_meta') is not null)";
+var historyQuery = "select migration_id, class, catalog_hash from okm_history order by migration_id, step_index";
+async function versionSql(namespace) {
+  if (namespace === "public")
+    return versionQuery;
+  const relation = await qualified("okm_meta", namespace);
+  const literal = relation.replaceAll("'", "''");
+  return `select current_setting('server_version_num'), version(), (select (xpath('//catalog_hash/text()', query_to_xml('select catalog_hash from ${literal} where id = ''head''', true, false, '')))[1]::text where to_regclass('${literal}') is not null)`;
+}
+async function historySql2(namespace) {
+  if (namespace === "public")
+    return historyQuery;
+  return `select migration_id, class, catalog_hash from ${await qualified("okm_history", namespace)} order by migration_id, step_index`;
+}
+async function recordedNamespace(catalogDir) {
+  const text = await readText(`${artifactDir(catalogDir)}/namespace`);
+  if (text === undefined)
+    return "public";
+  const line = text.trim();
+  if (line === "" || line === "public")
+    return "public";
+  if (line.includes("\x00") || line.includes(`
+`) || line.includes("\r")) {
+    throw new OkmError("OKM1122", "The catalog namespace file is not one identifier.", {
+      fix: { summary: "Run okm build so .okm/namespace is the schema from defineConfig." }
+    });
+  }
+  return line;
+}
+async function acceptServer2(pool, schema, http, requireMeta, options, source) {
+  const namespace = await recordedNamespace(source.catalogDir);
+  let rows;
+  try {
+    const result = await pool.execute(await versionSql(namespace), undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    const { mapPostgresError } = await import("./yfedr1zb.js");
+    throw mapPostgresError(error, mapOptions(http, false, schema));
+  }
+  for (const name in schema.model) {
+    if (schema.model[name]?.presets !== undefined) {
+      (await import("./5bmksndh.js")).checkSchema(schema);
+      break;
+    }
+  }
+  const version = rows[0]?.[1];
+  if (version === null || version === undefined || !version.startsWith("PostgreSQL")) {
+    throw new OkmError("OKM1801", "The server is not PostgreSQL. The schema dialect is postgres.", withHttp(http, {
+      fix: { summary: "Open the schema with the Postgres driver that matches it." }
+    }));
+  }
+  const recorded = rows[0]?.[2];
+  if (recorded === null || recorded === undefined || recorded.length === 0) {
+    if (requireMeta) {
+      throw new OkmError("OKM1520", "okm_meta has no catalog hash.", withHttp(http, {
+        fix: {
+          summary: "Apply migrations so okm_meta records the catalog, or omit requireMeta to adopt this database."
+        }
+      }));
+    }
+  } else {
+    const { assertCompatible } = await import("./qartgazh.js");
+    try {
+      await assertCompatible(pool, schema, recorded, source, options, namespace);
+    } catch (error) {
+      if (error instanceof OkmError)
+        throw attachHttp(http, error);
+      throw error;
+    }
+  }
+  const major = Math.floor(Number(rows[0]?.[0] ?? "0") / 1e4);
+  const raw = schema.requires?.postgres;
+  if (raw === undefined) {
+    if (major < POSTGRES_FLOOR) {
+      throw new OkmError("OKM1803", serverNeedsPostgres(major, POSTGRES_FLOOR), withHttp(http, {
+        fix: {
+          summary: `Upgrade to PostgreSQL ${String(POSTGRES_FLOOR)} or higher.`
+        }
+      }));
+    }
+    return;
+  }
+  const need = parsePostgresFloor(raw);
+  if (!isPostgresMajor(need) || major < need) {
+    throw new OkmError("OKM1802", serverNeedsPostgres(major, isPostgresMajor(need) ? need : POSTGRES_FLOOR), withHttp(http, {
+      fix: { summary: "Upgrade the server, or lower minPostgres to a major the server meets." }
+    }));
+  }
+}
+async function qualified(table, namespace) {
+  const { quoteIdent } = await import("./zx3v9phv.js");
+  return `${quoteIdent(namespace)}.${table}`;
+}
+
+export { artifactDir, readText, historySql2, acceptServer2 };