okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/zs9aymcp.js

@@ -0,0 +1,210 @@
+import {
+  OkmError,
+  tag
+} from "./hfq3n3bd.js";
+
+// src/dialects/pg/filter-parse.ts
+var PARSED = [
+  "eq",
+  "in",
+  "inList",
+  "notIn",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "between",
+  "startsWith",
+  "endsWith",
+  "contains",
+  "like",
+  "ilike",
+  "not",
+  "containedBy",
+  "overlaps",
+  "hasKey",
+  "hasAnyKey"
+];
+var PARSED_OPS = `,${PARSED.join(",")},`;
+var PARSED_FIX = "Use eq, in, notIn, lt, lte, gt, gte, between, startsWith, endsWith, contains, like, ilike, not, containedBy, overlaps, hasKey, or hasAnyKey.";
+function parseQuery(allow, sort, query, relations) {
+  if (typeof query !== "object" || query === null || Array.isArray(query)) {
+    throw new OkmError("OKM1121", "filters parse expects an object of fields.");
+  }
+  for (const field of Object.keys(allow)) {
+    for (const op of allow[field] ?? []) {
+      if (PARSED_OPS.includes(`,${op},`))
+        continue;
+      throw new OkmError("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: PARSED_FIX }
+      });
+    }
+  }
+  const nested = relations ?? {};
+  const whereParts = [];
+  let orderBy;
+  for (const key of Object.keys(query)) {
+    const value = query[key];
+    if (key === "sort" && typeof value === "string" && sort.includes(value)) {
+      orderBy = { [value]: "asc" };
+      continue;
+    }
+    if (Object.hasOwn(allow, key)) {
+      whereParts.push(...clauses(key, allow[key] ?? [], value));
+      continue;
+    }
+    if (Object.hasOwn(nested, key)) {
+      whereParts.push(relationClause(key, nested[key] ?? [], value));
+      continue;
+    }
+    throw new OkmError("OKM1123", `Field ${key} is not in the allow list.`, {
+      fix: { summary: "Remove the field, or add it to filters({ allow }) or relations." }
+    });
+  }
+  const where = combine(whereParts);
+  return orderBy === undefined ? { where } : { where, orderBy };
+}
+function clauses(field, ops, value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    if (!ops.includes("eq")) {
+      throw new OkmError("OKM1120", `filters() cannot apply eq on ${field}.`, {
+        fix: { summary: "Add eq to that field, or send an object of allowed operators." }
+      });
+    }
+    return [{ [field]: value }];
+  }
+  const applied = [];
+  for (const op of Object.keys(value)) {
+    if (!Object.hasOwn(value, op))
+      continue;
+    if (!ops.includes(op) && !(op === "inList" && ops.includes("in"))) {
+      throw new OkmError("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: "Send an operator that field's allow list names." }
+      });
+    }
+    applied.push(one(field, op, value[op]));
+  }
+  if (applied.length === 0) {
+    throw new OkmError("OKM1120", `filters() cannot apply a value on ${field}.`, {
+      fix: { summary: "Send eq as a scalar, or an object of allowed operators." }
+    });
+  }
+  return applied;
+}
+function one(field, op, value) {
+  switch (op) {
+    case "eq":
+      return {
+        [field]: value !== null && typeof value === "object" ? tag("eq", value) : value
+      };
+    case "in":
+    case "inList":
+      return { [field]: tag("inList", list(value, op)) };
+    case "notIn":
+      return { [field]: tag("notIn", list(value, op)) };
+    case "lt":
+      return { [field]: tag("lt", value) };
+    case "lte":
+      return { [field]: tag("lte", value) };
+    case "gt":
+      return { [field]: tag("gt", value) };
+    case "gte":
+      return { [field]: tag("gte", value) };
+    case "between": {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new OkmError("OKM1120", `between on ${field} needs two bounds.`, {
+          fix: { summary: "Send between as [from, to]." }
+        });
+      }
+      return { [field]: tag("between", [value[0], value[1]]) };
+    }
+    case "startsWith":
+      return { [field]: tag("startsWith", text(value, op)) };
+    case "endsWith":
+      return { [field]: tag("endsWith", text(value, op)) };
+    case "contains":
+      return { [field]: tag("contains", value) };
+    case "not":
+      if (value !== null && typeof value === "object") {
+        throw new OkmError("OKM1120", `not on ${field} takes a scalar.`, {
+          fix: { summary: "Send not a scalar or null. Nested operators are not accepted." }
+        });
+      }
+      return { [field]: tag("not", value) };
+    case "containedBy":
+      return { [field]: tag("containedBy", value) };
+    case "overlaps":
+      return { [field]: tag("overlaps", value) };
+    case "hasKey":
+      return { [field]: tag("hasKey", text(value, "hasKey")) };
+    case "hasAnyKey":
+      return { [field]: tag("hasAnyKey", strings(value, field)) };
+    case "like":
+      return { [field]: tag("like", text(value, op)) };
+    case "ilike":
+      return { [field]: tag("ilike", text(value, op)) };
+    default:
+      throw new OkmError("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: "Use an operator parse applies." }
+      });
+  }
+}
+function relationClause(name, fields, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new OkmError("OKM1120", `filters() cannot apply a value on ${name}.`, {
+      fix: { summary: "Send the relation an object of allowlisted fields." }
+    });
+  }
+  const parts = [];
+  for (const field of Object.keys(value)) {
+    if (!Object.hasOwn(value, field))
+      continue;
+    if (!fields.includes(field)) {
+      throw new OkmError("OKM1123", `Field ${field} is not in the allow list.`, {
+        fix: { summary: "Remove the field, or add it to filters({ relations })." }
+      });
+    }
+    parts.push(...clauses(field, PARSED, value[field]));
+  }
+  if (parts.length === 0) {
+    throw new OkmError("OKM1120", `filters() cannot apply a value on ${name}.`, {
+      fix: { summary: "Send the relation an object of allowlisted fields." }
+    });
+  }
+  return { [name]: tag("has", combine(parts)) };
+}
+function combine(parts) {
+  const first = parts[0];
+  if (first === undefined)
+    return {};
+  if (parts.length === 1)
+    return first;
+  return tag("and", parts);
+}
+function list(value, op) {
+  if (!Array.isArray(value)) {
+    throw new OkmError("OKM1120", `${op} needs an array.`, {
+      fix: { summary: "Send that operator an array of values." }
+    });
+  }
+  return value;
+}
+function strings(value, field) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new OkmError("OKM1120", `hasAnyKey on ${field} needs an array of strings.`, {
+      fix: { summary: "Send hasAnyKey an array of strings." }
+    });
+  }
+  return value;
+}
+function text(value, op) {
+  if (typeof value !== "string") {
+    throw new OkmError("OKM1120", `${op} needs a string.`, {
+      fix: { summary: "Send that operator a string." }
+    });
+  }
+  return value;
+}
+export {
+  parseQuery
+};

package/dist/tooling/shared/zx3v9phv.js

@@ -0,0 +1,8 @@
+import {
+  quoteIdent2,
+  renderCatalog2
+} from "./hfq3n3bd.js";
+export {
+  quoteIdent2 as quoteIdent,
+  renderCatalog2 as renderCatalog
+};

package/dist/tooling/testing/index.js

@@ -1,8 +1,8 @@
 import {
   testing2
-} from "../../shared/7k9grvf6.js";
-import"../../shared/9s0ypp87.js";
-import"../../shared/qq3899ht.js";
+} from "../../shared/2szgv6yj.js";
+import"../../shared/fk9vef30.js";
+import"../../shared/12z7aznj.js";
 export {
   testing2 as testing
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okmodel",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "okmodel is a catalog-first TypeScript ORM, PostgreSQL first.",
   "keywords": [
     "migrations",
@@ -63,6 +63,10 @@
       "types": "./dist/runtime/pg/bun.d.ts",
       "import": "./dist/runtime/pg/bun.js"
     },
+    "./pg/neon": {
+      "types": "./dist/runtime/pg/neon.d.ts",
+      "import": "./dist/runtime/pg/neon.js"
+    },
     "./ids": {
       "types": "./dist/runtime/ids/index.d.ts",
       "import": "./dist/runtime/ids/index.js"
@@ -87,6 +91,10 @@
       "types": "./dist/runtime/validate/index.d.ts",
       "import": "./dist/runtime/validate/index.js"
     },
+    "./otel": {
+      "types": "./dist/runtime/otel.d.ts",
+      "import": "./dist/runtime/otel.js"
+    },
     "./ext": {
       "types": "./dist/dialects/pg/ext/index.d.ts",
       "import": "./dist/dialects/pg/ext/index.js"
@@ -106,10 +114,38 @@
     "./pg/pg_trgm": {
       "types": "./dist/dialects/pg/ext/pg-trgm.d.ts",
       "import": "./dist/dialects/pg/ext/pg-trgm.js"
+    },
+    "./pg/unaccent": {
+      "types": "./dist/dialects/pg/ext/unaccent.d.ts",
+      "import": "./dist/dialects/pg/ext/unaccent.js"
+    },
+    "./pg/hstore": {
+      "types": "./dist/dialects/pg/ext/hstore.d.ts",
+      "import": "./dist/dialects/pg/ext/hstore.js"
+    },
+    "./pg/ltree": {
+      "types": "./dist/dialects/pg/ext/ltree.d.ts",
+      "import": "./dist/dialects/pg/ext/ltree.js"
+    },
+    "./pg/btree_gist": {
+      "types": "./dist/dialects/pg/ext/btree-gist.d.ts",
+      "import": "./dist/dialects/pg/ext/btree-gist.js"
+    },
+    "./pg/btree_gin": {
+      "types": "./dist/dialects/pg/ext/btree-gin.d.ts",
+      "import": "./dist/dialects/pg/ext/btree-gin.js"
+    },
+    "./pg/fuzzystrmatch": {
+      "types": "./dist/dialects/pg/ext/fuzzystrmatch.d.ts",
+      "import": "./dist/dialects/pg/ext/fuzzystrmatch.js"
+    },
+    "./pg/pgcrypto": {
+      "types": "./dist/dialects/pg/ext/pgcrypto.d.ts",
+      "import": "./dist/dialects/pg/ext/pgcrypto.js"
     }
   },
   "scripts": {
-    "build": "rm -rf dist && bun build ./src/contracts/index.ts ./src/contracts/internal.ts ./src/dialects/pg/index.ts ./src/runtime/pg/postgresjs.ts ./src/runtime/pg/pglite.ts ./src/runtime/pg/pg.ts ./src/runtime/pg/bun.ts ./src/runtime/ids/index.ts ./src/runtime/safety/index.ts ./src/runtime/traits/index.ts ./src/runtime/tenancy/index.ts ./src/runtime/validate/index.ts ./src/dialects/pg/ext/index.ts ./src/dialects/pg/fn/index.ts ./src/dialects/pg/view/index.ts ./src/dialects/pg/ext/citext.ts ./src/dialects/pg/ext/pg-trgm.ts ./src/tooling/migrate/index.ts ./src/tooling/testing/index.ts ./src/tooling/cli.ts --outdir ./dist --root ./src --format esm --target node --splitting --chunk-naming=shared/[hash].js --external postgres --external @electric-sql/pglite --external pg --external bun && bunx tsc -p tsconfig.build.json && rm -f ./dist/dialects/pg/temporal.local.d.ts && bun ./scripts/write-bin-wrappers.ts",
+    "build": "rm -rf dist && bun build ./src/contracts/index.ts ./src/contracts/internal.ts ./src/dialects/pg/index.ts ./src/runtime/pg/postgresjs.ts ./src/runtime/pg/pglite.ts ./src/runtime/pg/pg.ts ./src/runtime/pg/bun.ts ./src/runtime/pg/neon.ts ./src/runtime/ids/index.ts ./src/runtime/safety/index.ts ./src/runtime/traits/index.ts ./src/runtime/tenancy/index.ts ./src/runtime/validate/index.ts ./src/runtime/otel.ts ./src/dialects/pg/ext/index.ts ./src/dialects/pg/fn/index.ts ./src/dialects/pg/view/index.ts ./src/dialects/pg/ext/citext.ts ./src/dialects/pg/ext/pg-trgm.ts ./src/dialects/pg/ext/unaccent.ts ./src/dialects/pg/ext/hstore.ts ./src/dialects/pg/ext/ltree.ts ./src/dialects/pg/ext/btree-gist.ts ./src/dialects/pg/ext/btree-gin.ts ./src/dialects/pg/ext/fuzzystrmatch.ts ./src/dialects/pg/ext/pgcrypto.ts ./src/tooling/migrate/index.ts ./src/tooling/testing/index.ts ./src/tooling/cli.ts --outdir ./dist --root ./src --format esm --target node --splitting --chunk-naming=shared/[hash].js --external postgres --external @electric-sql/pglite --external pg --external bun --external @neondatabase/serverless && bunx tsc -p tsconfig.build.json && rm -f ./dist/dialects/pg/temporal.local.d.ts && bun build ./packages/harness/src/driver-run.ts --outdir ./dist/tooling --format esm --target node --splitting --chunk-naming=shared/[hash].js --external postgres --external @electric-sql/pglite --external pg --external bun --external @neondatabase/serverless && bun ./scripts/write-bin-wrappers.ts",
     "driver-bench": "bun ./scripts/driver-bench.ts",
     "typecheck": "bunx tsc --noEmit -p tsconfig.json",
     "editor-check": "bun ./scripts/editor-check.ts",
@@ -153,21 +189,23 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
     "@electric-sql/pglite-socket": "^0.2.11",
-    "@types/bun": "^1.4.2",
+    "@types/bun": "^1.4.3",
+    "drizzle-orm": "0.45.4",
     "expect-type": "^1.4.0",
     "fast-check": "^4.10.2",
-    "oxc-parser": "^0.152.0",
-    "oxfmt": "0.71.0",
-    "oxlint": "^1.86.0",
-    "oxlint-tsgolint": "^7.0.2003",
-    "publint": "^0.3.24",
-    "temporal-polyfill": "^1.0.5",
+    "oxc-parser": "0.154.0",
+    "oxfmt": "0.73.0",
+    "oxlint": "^1.88.0",
+    "oxlint-tsgolint": "^7.0.2004",
+    "publint": "^0.3.25",
+    "temporal-polyfill": "^1.0.6",
     "temporal-spec": "^1.0.1",
     "typescript": "7",
     "typescript-editor": "npm:typescript@6.0.3"
   },
   "peerDependencies": {
     "@electric-sql/pglite": "^0.5.8",
+    "@neondatabase/serverless": "^1.2.0",
     "pg": "^8.16.0",
     "postgres": "^3.4.9"
   },
@@ -175,6 +213,9 @@
     "@electric-sql/pglite": {
       "optional": true
     },
+    "@neondatabase/serverless": {
+      "optional": true
+    },
     "pg": {
       "optional": true
     },

package/dist/shared/ktz42yez.js

@@ -1,113 +0,0 @@
-import {
-  open2
-} from "./14vx95q4.js";
-import"./qq3899ht.js";
-import"./n442h54c.js";
-import {
-  openProject
-} from "./gs74dbj5.js";
-import {
-  sessionFailure,
-  finishQuiet,
-  assertTargetPolicy,
-  selectTarget
-} from "./tsvww22q.js";
-import"./9s0ypp87.js";
-import {
-  isExactVersion,
-  compareExtensionVersions
-} from "./r3j8s5y0.js";
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// src/tooling/migrate/ext.ts
-async function extProject(cwd, command, flags) {
-  const opened = await openProject(cwd);
-  const target = selectTarget(opened.config, flags.target);
-  assertTargetPolicy(target, "check", flags.allowProtected);
-  const pool = open2({ url: target.url, max: 1 });
-  try {
-    if (command === "list")
-      return formatList(await readExtensions(pool));
-    return formatCheck(opened.built.catalog.objects, await readExtensions(pool));
-  } catch (error) {
-    throw sessionFailure(error) ?? error;
-  } finally {
-    await finishQuiet(() => pool.close());
-  }
-}
-var LIST_SQL = `
-  select a.name, a.default_version, e.extversion, n.nspname
-  from pg_available_extensions a
-  left join pg_extension e on e.extname = a.name
-  left join pg_namespace n on n.oid = e.extnamespace
-  order by a.name
-`;
-async function readExtensions(pool) {
-  const result = await pool.execute(LIST_SQL);
-  return result.rows.map((row) => ({
-    name: cell(row[0]),
-    defaultVersion: cell(row[1]),
-    installedVersion: cell(row[2]),
-    schema: cell(row[3])
-  }));
-}
-function cell(value) {
-  return typeof value === "string" ? value : "";
-}
-function formatList(rows) {
-  const lines = ["name\tdefault\tinstalled\tschema"];
-  for (const row of rows) {
-    lines.push([row.name, row.defaultVersion, row.installedVersion, row.schema].join("\t"));
-  }
-  return `${lines.join(`
-`)}
-`;
-}
-function formatCheck(objects, server) {
-  const declared = objects.filter((object) => object.kind === "extension");
-  if (declared.length === 0)
-    return `no extensions
-`;
-  const installed = new Map(server.map((row) => [row.name, row.installedVersion]));
-  const lines = ["name\tdeclared\tinstalled"];
-  for (const object of [...declared].sort((left, right) => left.identity.name < right.identity.name ? -1 : 1)) {
-    const name = object.identity.name;
-    const have = installed.get(name) ?? "";
-    if (have.length === 0) {
-      throw new OkmError2("OKM1811", `Extension ${name} is not installed on the server.`, {
-        fix: { summary: "Install the extension, or remove the declaration." }
-      });
-    }
-    const want = object.definition.version;
-    if (!versionAccepted(want, have)) {
-      throw new OkmError2("OKM1812", extensionNeeds(name, want ?? "", have), {
-        fix: { summary: "Install a version the declaration accepts, or change the pin." }
-      });
-    }
-    lines.push([name, want ?? "-", have].join("\t"));
-  }
-  return `${lines.join(`
-`)}
-`;
-}
-function extensionNeeds(name, want, have) {
-  const floor = /^>=(\d+(?:\.\d+)*)$/.exec(want);
-  const need = floor?.[1] ?? want;
-  const higher = floor === null ? "" : " or higher";
-  return `Extension ${name} needs ${need}${higher}. The server has ${have}. Install a version the declaration accepts, or change the pin.`;
-}
-function versionAccepted(declared, installed) {
-  if (declared === undefined)
-    return true;
-  const floor = /^>=(\d+(?:\.\d+)*)$/.exec(declared);
-  const minimum = floor?.[1];
-  if (minimum !== undefined) {
-    return isExactVersion(installed) && compareExtensionVersions(installed, minimum) >= 0;
-  }
-  return declared === installed;
-}
-export {
-  extProject
-};

package/dist/shared/ttsqgp4p.js

@@ -1,71 +0,0 @@
-import {
-  POSTGRES_FLOOR,
-  isPostgresMajor,
-  parsePostgresFloor,
-  serverNeedsPostgres
-} from "./ga9j92qj.js";
-import {
-  withHttp,
-  attachHttp
-} from "./tbrvgw6z.js";
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// 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)";
-async function acceptServer(pool, schema, rows, http, requireMeta, options, source) {
-  for (const name in schema.model) {
-    if (schema.model[name]?.presets !== undefined) {
-      (await import("./m7n9h2a5.js")).checkSchema(schema);
-      break;
-    }
-  }
-  const version = rows[0]?.[1];
-  if (version === null || version === undefined || !version.startsWith("PostgreSQL")) {
-    throw new OkmError2("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 OkmError2("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("./ek2wt2dz.js");
-    try {
-      await assertCompatible(pool, schema, recorded, source, options);
-    } catch (error) {
-      if (error instanceof OkmError2)
-        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 OkmError2("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 OkmError2("OKM1802", serverNeedsPostgres(major, isPostgresMajor(need) ? need : POSTGRES_FLOOR), withHttp(http, {
-      fix: { summary: "Upgrade the server, or lower minPostgres to a major the server meets." }
-    }));
-  }
-}
-export {
-  acceptServer,
-  versionQuery
-};

package/dist/shared/y34a8714.js

@@ -1,150 +0,0 @@
-import {
-  staticNamespace2,
-  assertNamespace2,
-  normaliseEdges,
-  assertProvenance
-} from "./358zsv4r.js";
-import {
-  assertIdentifier2
-} from "./nfzc5z0w.js";
-import {
-  catalogError2
-} from "./52szzakm.js";
-
-// 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.`);
-  }
-}
-
-export { functionObject, triggerObject };