okmodel 0.1.1 → 0.3.0

package/dist/shared/n4jqhpqz.js

@@ -0,0 +1,27 @@
+// src/runtime/tx.ts
+async function runWrite(host, statements, options, atomic) {
+  if (statements.length === 0)
+    return [];
+  const first = statements[0];
+  const limit = options?.timeout ?? host.timeouts?.statement;
+  const call = limit === undefined || limit === options?.timeout ? options : { ...options, timeout: limit };
+  const single = statements.length === 1 && first !== undefined && atomic === undefined;
+  const watched = host.hookm !== undefined && !single && host.tx === undefined ? await import("./96ps4g1z.js") : undefined;
+  watched?.phase(host.hookm, "start", 0);
+  let results;
+  try {
+    results = single ? [await host.pool.execute(first.text, first.params, call)] : await host.pool.batch(statements, call);
+  } catch (error) {
+    watched?.phase(host.hookm, "rollback", 0);
+    throw error;
+  }
+  watched?.phase(host.hookm, "commit", 0);
+  if (host.hookm !== undefined) {
+    const heard = results.flatMap((result) => result.notices);
+    if (heard.length > 0)
+      (await import("./96ps4g1z.js")).notices(host.hookm, heard);
+  }
+  return results;
+}
+
+export { runWrite };

package/dist/shared/n7mcc1gk.js

@@ -0,0 +1,132 @@
+import {
+  writeArray
+} from "./tmbdywx0.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/operator-fit.ts
+var FAMILIES = {
+  startsWith: ["text"],
+  endsWith: ["text"],
+  like: ["text"],
+  ilike: ["text"],
+  contains: ["text", "array", "jsonb", "range"],
+  containedBy: ["array", "jsonb", "range"],
+  overlaps: ["array", "range"],
+  hasKey: ["jsonb"],
+  hasAnyKey: ["jsonb"],
+  path: ["json", "jsonb"],
+  matches: ["tsvector"],
+  "json.set": ["json", "jsonb"],
+  "arr.append": ["array"],
+  "arr.remove": ["array"]
+};
+var ACCEPTED = {
+  text: [
+    "eq",
+    "not",
+    "lt",
+    "lte",
+    "gt",
+    "gte",
+    "between",
+    "startsWith",
+    "contains",
+    "endsWith",
+    "like",
+    "ilike",
+    "inList",
+    "notIn"
+  ],
+  array: [
+    "eq",
+    "not",
+    "contains",
+    "containedBy",
+    "overlaps",
+    "inList",
+    "notIn",
+    "arr.append",
+    "arr.remove"
+  ],
+  jsonb: ["eq", "not", "contains", "containedBy", "hasKey", "hasAnyKey", "path", "json.set"],
+  json: ["eq", "not", "path", "json.set"],
+  range: ["eq", "not", "lt", "lte", "gt", "gte", "contains", "containedBy", "overlaps"],
+  tsvector: ["eq", "not", "matches"],
+  scalar: ["eq", "not", "lt", "lte", "gt", "gte", "between", "inList", "notIn", "inc"]
+};
+var SAFE_TYPE = /^[A-Za-z_][A-Za-z0-9_]*(\(\d+\))?(\[\])*$/;
+var REGCONFIG = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/;
+function columnFamily(dataType) {
+  if (dataType.endsWith("[]"))
+    return "array";
+  if (dataType === "jsonb")
+    return "jsonb";
+  if (dataType === "json")
+    return "json";
+  if (dataType === "tsvector")
+    return "tsvector";
+  if (dataType.endsWith("range"))
+    return "range";
+  if (dataType === "text" || dataType === "citext" || dataType.startsWith("varchar(") || dataType.startsWith("char(") || dataType.startsWith("character")) {
+    return "text";
+  }
+  return "scalar";
+}
+function assertOperatorFits(column, name) {
+  const families = FAMILIES[name];
+  if (families === undefined)
+    return;
+  if (families.includes(columnFamily(column.dataType)))
+    return;
+  const accepted = ACCEPTED[columnFamily(column.dataType)];
+  const search = name === "matches" && columnFamily(column.dataType) === "text" ? " Text search needs a tsvector column." : "";
+  throw new OkmError2("OKM1124", `Operator ${name} does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${accepted.join(", ")}.${search}`, { fix: { summary: `Use one of: ${accepted.join(", ")}.` } });
+}
+function sqlType(dataType, column) {
+  if (SAFE_TYPE.test(dataType))
+    return dataType;
+  assertOperatorFits(column, "contains");
+  throw new OkmError2("OKM1124", `Operator contains does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${ACCEPTED[columnFamily(column.dataType)].join(", ")}.`, { fix: { summary: "Use a column type this operator accepts." } });
+}
+function assertNoControl(value, role) {
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) {
+      throw new OkmError2("OKM1122", `${role} contains a control character.`, {
+        fix: { summary: "Remove NUL and other control characters. The value is not sent." }
+      });
+    }
+  }
+}
+function assertBoundText(value, role) {
+  if (value.length === 0) {
+    throw new OkmError2("OKM1122", `${role} is empty.`, {
+      fix: { summary: "Pass a non-empty key or path segment." }
+    });
+  }
+  assertNoControl(value, role);
+}
+function assertRegconfig(config) {
+  if (!REGCONFIG.test(config)) {
+    throw new OkmError2("OKM1122", `Text search config ${config} must be a regconfig name such as english or pg_catalog.simple.`, { fix: { summary: "Pass a regconfig name. Quotes and extra clauses are not accepted." } });
+  }
+}
+function textArray(values, role) {
+  for (const value of values)
+    assertBoundText(value, role);
+  return writeArray(values, 1, (value) => String(value), false);
+}
+function arrayElementType(dataType, column) {
+  if (!dataType.endsWith("[]")) {
+    assertOperatorFits(column, "arr.append");
+  }
+  const element = dataType.slice(0, -2);
+  if (!SAFE_TYPE.test(element)) {
+    throw new OkmError2("OKM1124", `Operator arr.append does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${ACCEPTED.array.join(", ")}.`, { fix: { summary: "Use arr.append on an array column." } });
+  }
+  return element;
+}
+
+export { assertOperatorFits, sqlType, assertNoControl, assertBoundText, assertRegconfig, textArray, arrayElementType };

package/dist/shared/ne02ng5c.js

@@ -0,0 +1,68 @@
+import {
+  open2
+} from "./xw1d69vd.js";
+import"./n442h54c.js";
+import"./t616ynfn.js";
+import {
+  assertRoleHealth
+} from "./hcmdtwgh.js";
+import {
+  errorDoc,
+  selectTarget,
+  openProject
+} from "./5nmdenb6.js";
+import {
+  omitManagedObjects
+} from "./2ssqrv66.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/doctor.ts
+async function doctorProject(cwd, code, flags) {
+  if (code !== undefined) {
+    const doc = errorDoc(code);
+    if (doc === undefined) {
+      throw new OkmError2("invalid", `Unknown code ${code}.`, {
+        fix: { summary: "Pass a code from the registry, or run okm doctor with no argument." }
+      });
+    }
+    return `${doc.code}: ${doc.title}
+${doc.summary}
+${doc.fix}
+`;
+  }
+  const opened = await openProject(cwd);
+  const objects = omitManagedObjects(opened.built.catalog).objects;
+  if (opened.config.roles !== undefined) {
+    const target = selectTarget(opened.config, flags?.target);
+    const pool = open2({ url: target.url, max: 1 });
+    try {
+      await assertRoleHealth(pool, opened.config.roles, objects);
+    } finally {
+      await pool.close();
+    }
+  }
+  return formatTriggers(objects);
+}
+function formatTriggers(objects) {
+  const tables = new Map;
+  for (const object of objects) {
+    if (object.kind !== "trigger")
+      continue;
+    const table = object.identity.parent.name;
+    const names = tables.get(table) ?? [];
+    names.push(object.identity.name);
+    tables.set(table, names);
+  }
+  if (tables.size === 0)
+    return `no triggers
+`;
+  const lines = [...tables.entries()].sort((left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0).map(([table, names]) => `${table}: ${[...names].sort().join(", ")}`);
+  return `${lines.join(`
+`)}
+`;
+}
+export {
+  doctorProject
+};

package/dist/shared/{mkjmqjv4.js → nfzc5z0w.js}

@@ -1,6 +1,6 @@
 import {
   catalogError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/contracts/utf8.ts
 function utf8ByteLength2(value) {
@@ -273,109 +273,7 @@ function toHex(bytes) {
 // src/contracts/catalog/words.ts
 var words;
 function reservedWords() {
-  words ??= new Set([
-    "all",
-    "analyse",
-    "analyze",
-    "and",
-    "any",
-    "array",
-    "as",
-    "asc",
-    "asymmetric",
-    "authorization",
-    "binary",
-    "both",
-    "case",
-    "cast",
-    "check",
-    "collate",
-    "collation",
-    "column",
-    "concurrently",
-    "constraint",
-    "create",
-    "cross",
-    "current_catalog",
-    "current_date",
-    "current_role",
-    "current_schema",
-    "current_time",
-    "current_timestamp",
-    "current_user",
-    "default",
-    "deferrable",
-    "desc",
-    "distinct",
-    "do",
-    "else",
-    "end",
-    "except",
-    "false",
-    "fetch",
-    "for",
-    "foreign",
-    "freeze",
-    "from",
-    "full",
-    "grant",
-    "group",
-    "having",
-    "ilike",
-    "in",
-    "initially",
-    "inner",
-    "intersect",
-    "into",
-    "is",
-    "isnull",
-    "join",
-    "lateral",
-    "leading",
-    "left",
-    "like",
-    "limit",
-    "localtime",
-    "localtimestamp",
-    "natural",
-    "not",
-    "notnull",
-    "null",
-    "offset",
-    "on",
-    "only",
-    "or",
-    "order",
-    "outer",
-    "overlaps",
-    "placing",
-    "primary",
-    "references",
-    "returning",
-    "right",
-    "select",
-    "session_user",
-    "similar",
-    "some",
-    "symmetric",
-    "system_user",
-    "table",
-    "tablesample",
-    "then",
-    "to",
-    "trailing",
-    "true",
-    "union",
-    "unique",
-    "user",
-    "using",
-    "variadic",
-    "verbose",
-    "when",
-    "where",
-    "window",
-    "with"
-  ]);
+  words ??= new Set("all analyse analyze and any array as asc asymmetric authorization binary both case cast check collate collation column concurrently constraint create cross current_catalog current_date current_role current_schema current_time current_timestamp current_user default deferrable desc distinct do else end except false fetch for foreign freeze from full grant group having ilike in initially inner intersect into is isnull join lateral leading left like limit localtime localtimestamp natural not notnull null offset on only or order outer overlaps placing primary references returning right select session_user similar some symmetric system_user table tablesample then to trailing true union unique user using variadic verbose when where window with".split(" "));
   return words;
 }
 

package/dist/shared/nsva2a6b.js

@@ -0,0 +1,42 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/preset.ts
+var RESERVED_PRESETS = new Set([
+  "find",
+  "one",
+  "page",
+  "aggregate",
+  "count",
+  "exists",
+  "insert",
+  "update",
+  "delete",
+  "archive",
+  "restore",
+  "withArchived",
+  "onlyArchived",
+  "then",
+  "lock",
+  "watch",
+  "subscribe",
+  "stream",
+  "inspect",
+  "explain",
+  "with",
+  "for",
+  "as"
+]);
+function checkPresetNames(names, where) {
+  for (const name of names) {
+    if (!RESERVED_PRESETS.has(name))
+      continue;
+    throw new OkmError2("OKM1040", `Preset ${name} on ${where} is a client method or a reserved name. Reserved: ${[...RESERVED_PRESETS].join(", ")}.`, { fix: { summary: `Rename the preset ${name}.` } });
+  }
+}
+function duplicatePreset(name, table, first, second) {
+  throw new OkmError2("OKM1040", `Preset ${name} on ${table} is defined by ${first} and by ${second}.`, { fix: { summary: `Rename the preset in ${first} or in ${second}, or drop one of them.` } });
+}
+
+export { checkPresetNames, duplicatePreset };

package/dist/shared/p24x2334.js

@@ -0,0 +1,195 @@
+import {
+  decodeRows,
+  readHandle,
+  readCall,
+  attachHttp
+} from "./k34e0xf2.js";
+import {
+  selectedColumns,
+  parseOrder,
+  rejectKeys,
+  readLimit,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  registerFailFix,
+  fail
+} from "./xrfnq5k8.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/runtime/page.ts
+registerFailFix("OKM1130", "Request the next page with the same orderBy and the exact next value the previous page returned. The cursor encodes that order.");
+var OPTIONS = [
+  "where",
+  "select",
+  "orderBy",
+  "limit",
+  "include",
+  "after",
+  "signal",
+  "timeout"
+];
+function build(session, table, options, mods, view) {
+  try {
+    return plan(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError2 ? attachHttp(session.http, error) : error;
+  }
+}
+function plan(session, table, options, mods, view) {
+  const record = isRecord(options) ? options : {};
+  rejectKeys(record, OPTIONS, "page");
+  const indexed = indexes(session.schema).get(table);
+  if (indexed === undefined)
+    fail("OKM1120", `Table ${table} is not in the schema.`);
+  if (record.limit === undefined)
+    fail("OKM1101", "page() needs a limit.");
+  const size = readLimit(record.limit);
+  if (size < 1) {
+    throw new OkmError2("invalid", "page() limit must be at least 1.", { kind: "invalid" });
+  }
+  const keys = orderKeys(indexed, record.orderBy);
+  const signature = `${table}:${keys.map((key) => `${key.column.field}.${key.dir}.${key.nulls}`).join(",")}`;
+  const after = record.after === undefined || record.after === null ? undefined : keyset(keys, signature, record.after);
+  const wanted = selectedColumns(indexed, record.select);
+  const extra = keys.filter((key) => !wanted.includes(key.column)).map((key) => key.column.field);
+  const select = extra.length === 0 ? record.select : [...wanted.map((column) => column.field), ...extra];
+  const orderBy = {};
+  for (const key of keys)
+    orderBy[key.column.field] = { dir: key.dir, nulls: key.nulls };
+  const call = {
+    ...readCall("find", table, {
+      where: record.where,
+      select,
+      orderBy,
+      limit: size + 1,
+      include: record.include,
+      signal: record.signal,
+      timeout: record.timeout
+    }, undefined, session.scope, session.schema.model[table], session.schema, view),
+    ...after !== undefined ? { after } : {}
+  };
+  return readHandle(session, table, call, mods, async (compiled, rows) => {
+    const items = await decodeRows(compiled, rows, table);
+    const more = items.length > size;
+    const kept = more ? items.slice(0, size) : items;
+    const last = rows[size - 1];
+    const next = more && last !== undefined ? makeCursor(compiled, last, keys, signature) : null;
+    if (extra.length > 0) {
+      for (const item of kept) {
+        for (const field of extra)
+          delete item[field];
+      }
+    }
+    return { items: kept, next };
+  });
+}
+function orderKeys(table, orderBy) {
+  if (orderBy !== undefined && !isRecord(orderBy)) {
+    fail("OKM1120", "orderBy must be an object of fields.");
+  }
+  const keys = [];
+  for (const field of Object.keys(orderBy ?? {})) {
+    const column = table.columns.get(field);
+    if (column === undefined) {
+      throwNamed2("OKM1120", field, table.names, `Field ${field} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    keys.push({ column, ...parseOrder(field, orderBy?.[field]) });
+  }
+  if (table.model.primary.length === 0) {
+    fail("OKM1120", `page() needs a primary key on ${table.model.name} to break ties.`);
+  }
+  for (const field of table.model.primary) {
+    const column = table.columns.get(field);
+    if (column === undefined || keys.some((key) => key.column === column))
+      continue;
+    keys.push({ column, dir: "asc", nulls: "last" });
+  }
+  return keys;
+}
+function keyset(keys, signature, token) {
+  const values = readCursor(token, signature, keys.length);
+  return (sink, alias) => {
+    sink.mark(`k:${signature}:${values.map((value) => value === null ? "n" : "v").join("")}`);
+    let wrote = false;
+    for (let index = 0;index < keys.length; index += 1) {
+      const key = keys[index];
+      const value = values[index];
+      if (key === undefined || value === undefined)
+        continue;
+      if (value === null && key.nulls === "last")
+        continue;
+      sink.text(wrote ? " or (" : "(");
+      wrote = true;
+      for (let before = 0;before < index; before += 1) {
+        const prior = keys[before];
+        const held = values[before];
+        if (prior === undefined || held === undefined)
+          continue;
+        const ref = `${alias}.${quote(prior.column.sql)}`;
+        if (held === null) {
+          sink.text(`${ref} is null and `);
+        } else {
+          sink.text(`${ref} = `);
+          sink.param(held);
+          sink.text(" and ");
+        }
+      }
+      const ref = `${alias}.${quote(key.column.sql)}`;
+      if (value === null) {
+        sink.text(`${ref} is not null`);
+      } else {
+        sink.text(key.nulls === "last" ? `(${ref} ${compare(key)} ` : `${ref} ${compare(key)} `);
+        sink.param(value);
+        sink.text(key.nulls === "last" ? ` or ${ref} is null)` : "");
+      }
+      sink.text(")");
+    }
+    if (!wrote)
+      sink.text("false");
+  };
+}
+function compare(key) {
+  return key.dir === "asc" ? ">" : "<";
+}
+function makeCursor(plan, row, keys, signature) {
+  const values = keys.map((key) => {
+    const at = plan.outputs.fields.find((field) => field.key === key.column.field)?.at;
+    return at === undefined ? null : row[at] ?? null;
+  });
+  const bytes = new TextEncoder().encode(JSON.stringify([signature, ...values]));
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function readCursor(token, signature, count) {
+  let parsed;
+  if (typeof token === "string") {
+    try {
+      const binary = atob(token.replaceAll("-", "+").replaceAll("_", "/"));
+      const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+      parsed = JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      parsed = undefined;
+    }
+  }
+  if (!Array.isArray(parsed) || typeof parsed[0] !== "string") {
+    fail("OKM1130", "after is not a cursor that page() returned.");
+  }
+  if (parsed[0] !== signature) {
+    fail("OKM1130", `The cursor was made for another order: ${parsed[0]}. This page orders by ${signature}.`);
+  }
+  const values = parsed.slice(1);
+  if (values.length !== count || !values.every((value) => value === null || typeof value === "string")) {
+    fail("OKM1130", "after is not a cursor that page() returned.");
+  }
+  return values;
+}
+export {
+  build
+};

package/dist/shared/qbxzvwwc.js

@@ -0,0 +1,88 @@
+import {
+  assertNamespace2,
+  normaliseEdges,
+  assertProvenance
+} from "./t4tbsy9h.js";
+import {
+  assertIdentifier2,
+  assertStoredText
+} from "./nfzc5z0w.js";
+import {
+  catalogError2
+} from "./52szzakm.js";
+
+// src/contracts/catalog/enum.ts
+function enumType(input) {
+  assertNamespace2(input.namespace);
+  assertIdentifier2(input.name, "type");
+  assertProvenance(input.provenance);
+  if (input.labels.length === 0) {
+    catalogError2("OKM1020", `Enum ${input.name} must list at least one label.`);
+  }
+  const labels = [];
+  const seen = new Set;
+  for (const label of input.labels) {
+    assertStoredText(label, "enum label");
+    if (label.length === 0) {
+      catalogError2("OKM1020", `Enum ${input.name} has an empty label.`);
+    }
+    if (seen.has(label)) {
+      catalogError2("OKM1020", `Enum ${input.name} repeats label ${label}.`);
+    }
+    seen.add(label);
+    labels.push(label);
+  }
+  const identity = {
+    kind: "type",
+    namespace: input.namespace,
+    name: input.name
+  };
+  return {
+    kind: "type",
+    identity,
+    owner: input.owner ?? "managed",
+    definition: { labels },
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function domainType(input) {
+  assertNamespace2(input.namespace);
+  assertIdentifier2(input.name, "type");
+  assertProvenance(input.provenance);
+  if (input.base.length === 0) {
+    catalogError2("OKM1020", `Domain ${input.name} needs a base type.`);
+  }
+  assertStoredText(input.check, "domain check");
+  if (input.check.length === 0) {
+    catalogError2("OKM1020", `Domain ${input.name} needs a check.`);
+  }
+  const identity = {
+    kind: "type",
+    namespace: input.namespace,
+    name: input.name
+  };
+  const definition = { base: input.base, check: input.check };
+  return {
+    kind: "type",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function isDomain(definition) {
+  return "base" in definition;
+}
+function sameEnumLabels(left, right) {
+  if (left.length !== right.length)
+    return false;
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index])
+      return false;
+  }
+  return true;
+}
+
+export { enumType, domainType, isDomain, sameEnumLabels };

package/dist/shared/{w8samvk1.js → qybh48nd.js}

@@ -6,7 +6,7 @@ import {
   catalogHash2,
   loadTrustedCatalog2,
   parseCatalog2
-} from "./y9m15dfv.js";
+} from "./t616ynfn.js";
 export {
   catalogHash2 as catalogHash,
   creationOrder2 as creationOrder,