okmodel 0.7.0 → 0.9.0

package/dist/shared/{qq3899ht.js → 12z7aznj.js}

@@ -1,18 +1,6 @@
 import {
   policyObject
 } from "./bdk4sty6.js";
-import {
-  functionObject,
-  triggerObject
-} from "./y34a8714.js";
-import {
-  viewObject,
-  materializedViewObject,
-  materializedViewIndex
-} from "./zy8r7qvz.js";
-import {
-  extensionObject
-} from "./r3j8s5y0.js";
 import {
   dependencyOrder,
   catalog,
@@ -20,10 +8,14 @@ import {
   domainType,
   isDomain
 } from "./ywspezzx.js";
+import {
+  extensionObject
+} from "./r3j8s5y0.js";
 import {
   canonicalJson,
   staticNamespace2,
   templateNamespace2,
+  assertNamespace2,
   identityKey2,
   identityLabel2,
   sameRef2,
@@ -48,7 +40,8 @@ import {
 import {
   sha2562,
   assertIdentifier2,
-  fitIdentifier2
+  fitIdentifier2,
+  deterministicName2
 } from "./nfzc5z0w.js";
 import {
   catalogError2
@@ -164,6 +157,242 @@ function defaultPrivilegeObject(input) {
   };
 }
 
+// src/contracts/catalog/routine.ts
+var VOLATILITY = new Set(["volatile", "stable", "immutable"]);
+var SECURITY = new Set(["invoker", "definer"]);
+var TIMING = new Set(["before", "after", "instead"]);
+var LEVEL = new Set(["row", "statement"]);
+var EVENT_ORDER = ["insert", "update", "delete", "truncate"];
+var TYPE_TEXT = /^[A-Za-z][A-Za-z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])*$/;
+function functionObject(input) {
+  assertIdentifier2(input.name, "function");
+  const namespace = input.namespace ?? staticNamespace2("public");
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  if (input.language !== "sql" && input.language !== "plpgsql") {
+    catalogError2("OKM1020", `Function ${input.name} language must be sql or plpgsql.`);
+  }
+  const volatility = input.volatility ?? "volatile";
+  if (!VOLATILITY.has(volatility)) {
+    catalogError2("OKM1020", `Function ${input.name} volatility ${volatility} is not supported.`);
+  }
+  const security = input.security ?? "invoker";
+  if (!SECURITY.has(security)) {
+    catalogError2("OKM1020", `Function ${input.name} security ${security} is not supported.`);
+  }
+  assertTypeName(input.returns, `function ${input.name} return type`);
+  const args = (input.arguments ?? []).map((argument) => readArgument(input.name, argument));
+  if (input.body.length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} needs a body.`);
+  }
+  const atomic = input.atomic === true;
+  if (atomic && input.language !== "sql") {
+    catalogError2("OKM1020", `Function ${input.name} BEGIN ATOMIC needs language sql.`);
+  }
+  if (input.searchPath !== undefined && input.searchPath.trim().length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} search_path is empty.`);
+  }
+  const definition = {
+    arguments: args,
+    returns: input.returns,
+    language: input.language,
+    volatility,
+    security,
+    body: input.body,
+    ...input.searchPath !== undefined ? { searchPath: input.searchPath } : {},
+    ...atomic ? { atomic: true } : {}
+  };
+  return {
+    kind: "function",
+    identity: {
+      kind: "function",
+      namespace,
+      name: input.name,
+      argTypes: args.map((arg) => arg.type)
+    },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function triggerObject(input) {
+  assertIdentifier2(input.name, "trigger");
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.parent.name, "trigger table");
+  assertProvenance(input.provenance);
+  if (!TIMING.has(input.timing)) {
+    catalogError2("OKM1020", `Trigger ${input.name} timing ${input.timing} is not supported.`);
+  }
+  if (!LEVEL.has(input.level)) {
+    catalogError2("OKM1020", `Trigger ${input.name} level ${input.level} is not supported.`);
+  }
+  const events = EVENT_ORDER.filter((event) => input.events.includes(event));
+  if (events.length === 0) {
+    catalogError2("OKM1020", `Trigger ${input.name} needs an event.`);
+  }
+  const updateOf = input.updateOf === undefined ? undefined : [...input.updateOf];
+  if (updateOf !== undefined) {
+    if (!events.includes("update")) {
+      catalogError2("OKM1020", `Trigger ${input.name} lists UPDATE OF columns without an update event.`);
+    }
+    if (input.level !== "row") {
+      catalogError2("OKM1020", `Trigger ${input.name} UPDATE OF columns need level row.`);
+    }
+    for (const column of updateOf)
+      assertIdentifier2(column, "trigger column");
+  }
+  assertIdentifier2(input.calls.name, "trigger function");
+  assertNamespace2(input.calls.namespace);
+  for (const typeName of input.calls.argTypes)
+    assertTypeName(typeName, `trigger ${input.name}`);
+  const edges = [
+    { kind: "table", namespace: input.parent.namespace, name: input.parent.name },
+    {
+      kind: "function",
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: input.calls.argTypes
+    },
+    ...(updateOf ?? []).map((column) => ({
+      kind: "column",
+      parent: input.parent,
+      name: column
+    })),
+    ...input.dependencies ?? []
+  ];
+  const definition = {
+    timing: input.timing,
+    events,
+    level: input.level,
+    calls: {
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: [...input.calls.argTypes]
+    },
+    ...updateOf !== undefined && updateOf.length > 0 ? { updateOf } : {},
+    ...input.when !== undefined && input.when.length > 0 ? { when: input.when } : {}
+  };
+  return {
+    kind: "trigger",
+    identity: { kind: "trigger", parent: input.parent, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(edges),
+    provenance: input.provenance
+  };
+}
+function readArgument(fn, argument) {
+  assertIdentifier2(argument.name, `function ${fn} argument`);
+  assertTypeName(argument.type, `function ${fn} argument ${argument.name}`);
+  return { name: argument.name, type: argument.type };
+}
+function assertTypeName(typeName, role) {
+  if (!TYPE_TEXT.test(typeName)) {
+    catalogError2("OKM1020", `${role} ${typeName} is not a type name.`);
+  }
+}
+
+// src/contracts/catalog/view.ts
+function normaliseViewQuery(query) {
+  return query.trim().replace(/;\s*$/, "");
+}
+function viewObject(input) {
+  const namespace = input.namespace ?? staticNamespace2("public");
+  const columns = readColumns(input.name, input.columns);
+  const query = readQuery(input.name, input.query);
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  const definition = {
+    columns,
+    query,
+    ...input.securityInvoker === true ? { securityInvoker: true } : {}
+  };
+  return {
+    kind: "view",
+    identity: { kind: "view", namespace, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function materializedViewObject(input) {
+  const namespace = input.namespace ?? staticNamespace2("public");
+  const columns = readColumns(input.name, input.columns);
+  const query = readQuery(input.name, input.query);
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  const definition = {
+    columns,
+    query,
+    ...input.refresh === "concurrently" ? { refresh: "concurrently" } : {}
+  };
+  return {
+    kind: "materializedView",
+    identity: { kind: "materializedView", namespace, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function materializedViewIndex(input) {
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.parent.name, "index parent");
+  assertProvenance(input.provenance);
+  const columns = [...input.columns];
+  for (const name of columns)
+    assertIdentifier2(name, "index column");
+  if (columns.length === 0 && input.expression === undefined) {
+    catalogError2("OKM1020", `Index on ${input.parent.name} needs a column or an expression.`);
+  }
+  const nameKey = input.nameKey ?? (columns.length > 0 ? columns.join("_") : "expr");
+  const name = input.name === undefined ? deterministicName2({ parent: input.parent.name, purpose: "index", nameKey }) : fitIdentifier2(input.name);
+  const parentView = {
+    kind: "materializedView",
+    namespace: input.parent.namespace,
+    name: input.parent.name
+  };
+  return {
+    kind: "index",
+    identity: { kind: "index", parent: input.parent, name },
+    owner: input.owner ?? "managed",
+    definition: {
+      columns,
+      unique: input.unique === true,
+      nameKey,
+      ...input.expression !== undefined ? { expression: input.expression } : {},
+      ...input.predicate !== undefined ? { predicate: input.predicate } : {}
+    },
+    dependencies: normaliseEdges(input.dependencies ?? [parentView]),
+    provenance: input.provenance
+  };
+}
+function readColumns(view, columns) {
+  assertIdentifier2(view, "view");
+  if (columns.length === 0)
+    catalogError2("OKM1020", `View ${view} needs a column.`);
+  const seen = new Set;
+  return columns.map((column) => {
+    assertIdentifier2(column.name, `view ${view} column`);
+    if (seen.has(column.name)) {
+      catalogError2("OKM1020", `View ${view} lists column ${column.name} twice.`);
+    }
+    seen.add(column.name);
+    if (column.dataType.length === 0 || /[;'"\\]/.test(column.dataType)) {
+      catalogError2("OKM1020", `View ${view} column ${column.name} type is not a type name.`);
+    }
+    return { name: column.name, dataType: column.dataType };
+  });
+}
+function readQuery(view, query) {
+  const text = normaliseViewQuery(query);
+  if (text.length === 0)
+    catalogError2("OKM1020", `View ${view} needs a query.`);
+  return text;
+}
+
 // src/contracts/catalog/document.ts
 function creationOrder2(source) {
   return dependencyOrder(source.objects);
@@ -1565,4 +1794,4 @@ function assertNeverKind(value) {
   return catalogError2("OKM1020", `Unexpected kind ${JSON.stringify(value)}.`);
 }
 
-export { roleObject, grantObject, defaultPrivilegeObject, creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, startupCatalog2, startupHash2, loadTrustedCatalog2, catalogFileText2, parseCatalog2 };
+export { roleObject, grantObject, defaultPrivilegeObject, functionObject, triggerObject, normaliseViewQuery, viewObject, materializedViewObject, materializedViewIndex, creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, startupCatalog2, startupHash2, loadTrustedCatalog2, catalogFileText2, parseCatalog2 };

package/dist/shared/{gzaveazc.js → 1d9q9cv2.js}

@@ -1,9 +1,16 @@
+import {
+  emitSqlSelect,
+  decodeSqlNumber
+} from "./3bb7wsqt.js";
 import {
   refusePrototypeKey
-} from "./q5c6ngn3.js";
+} from "./a62rb2da.js";
 import {
   isWindow
 } from "./9a4ae4p8.js";
+import {
+  readSelectFragment
+} from "./bsek72fg.js";
 import {
   emitWhere,
   emitOrder,
@@ -16,7 +23,7 @@ import {
   list,
   isRecord,
   fail2
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 import {
   throwNamed2
 } from "./52szzakm.js";
@@ -46,6 +53,15 @@ function statement(spec) {
         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");
@@ -171,6 +187,17 @@ function readSpec(table, select) {
       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.");
     }

package/dist/shared/{w79hsckn.js → 1mxm04fy.js}

@@ -1,14 +1,14 @@
 import {
   noticeBuffer,
   WireSession
-} from "./1qa0qajz.js";
+} from "./e275q7sd.js";
 import {
   NODE_POSTGRES_CAPABILITIES,
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall
-} from "./kb2sdhfb.js";
+} from "./mfvx6kjx.js";
 
 // src/adapters/pg/nodepostgres.ts
 import net from "node:net";
@@ -55,7 +55,7 @@ function open4(config) {
     counters.busy = Math.max(0, counters.busy - 1);
   }, inflight);
   const held = { pool, acquireMs, counters, notices, named, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./zp9fmend.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./ebhz8vh6.js").then((mod) => mod.checkout(held));
   return {
     capabilities: NODE_POSTGRES_CAPABILITIES,
     execute(text, params, options) {
@@ -88,14 +88,14 @@ function open4(config) {
     reserve: () => checkout(),
     stream(text, params) {
       return async function* () {
-        const { streamRows } = await import("./zp9fmend.js");
+        const { streamRows } = await import("./ebhz8vh6.js");
         yield* streamRows(checkout, text, params);
       }();
     },
     listen(channel, onNotify) {
       if (closed)
         return rejectClosed();
-      return import("./zp9fmend.js").then((mod) => mod.listen(held, channel, onNotify));
+      return import("./ebhz8vh6.js").then((mod) => mod.listen(held, channel, onNotify));
     },
     cancel() {
       for (const pending of inflight)

package/dist/shared/{7k9grvf6.js → 2szgv6yj.js}

@@ -1,13 +1,13 @@
 import {
-  renderCatalog
-} from "./9s0ypp87.js";
+  renderCatalog2
+} from "./fk9vef30.js";
 import {
   viewGlobalReason,
   viewMentions
-} from "./5e3tf63j.js";
+} from "./760ppr76.js";
 import {
   createClient
-} from "./tbrvgw6z.js";
+} from "./npdftanb.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -1301,7 +1301,7 @@ async function testing2(schema, options) {
   const seed = options.seed ?? 1;
   const pool = await options.driver;
   if (options.migrate !== false) {
-    for (const statement of renderCatalog(schema.catalog, "public")) {
+    for (const statement of renderCatalog2(schema.catalog, "public")) {
       if (statement.trim().length === 0)
         continue;
       await pool.execute(statement);