okmodel 0.2.1 → 0.4.0

package/dist/shared/{d2whjz4k.js → 8jb4ymh2.js}

@@ -1,8 +1,22 @@
+import {
+  functionObject,
+  triggerObject
+} from "./9x25fxhc.js";
+import {
+  viewObject,
+  materializedViewObject,
+  materializedViewIndex
+} from "./y005b761.js";
+import {
+  extensionObject
+} from "./8ktwd3rh.js";
 import {
   dependencyOrder,
   catalog,
-  enumType
-} from "./qxa0yb9j.js";
+  enumType,
+  domainType,
+  isDomain
+} from "./g7ez901n.js";
 import {
   canonicalJson,
   staticNamespace2,
@@ -18,7 +32,9 @@ import {
   index3,
   constraint2,
   sequence2,
-  compareText
+  normaliseEdges,
+  compareText,
+  assertProvenance
 } from "./t4tbsy9h.js";
 import {
   OWNERS2,
@@ -27,7 +43,9 @@ import {
   CATALOG_VERSION2
 } from "./4e4c6vq2.js";
 import {
-  sha2562
+  sha2562,
+  assertIdentifier2,
+  fitIdentifier2
 } from "./nfzc5z0w.js";
 import {
   catalogError2
@@ -89,6 +107,60 @@ function isIdentPart(char) {
   return isIdentStart(char) || char >= "0" && char <= "9";
 }
 
+// src/contracts/catalog/privilege.ts
+function roleObject(input) {
+  assertIdentifier2(input.name, "role");
+  assertProvenance(input.provenance);
+  return {
+    kind: "role",
+    identity: { kind: "role", name: input.name },
+    owner: input.owner ?? "managed",
+    definition: {
+      login: input.login === true,
+      inherit: input.inherit !== false
+    },
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function grantObject(input) {
+  assertIdentifier2(input.role, "role");
+  assertProvenance(input.provenance);
+  return {
+    kind: "grant",
+    identity: {
+      kind: "grant",
+      role: input.role,
+      object: input.object,
+      privilege: input.privilege
+    },
+    owner: input.owner ?? "managed",
+    definition: {},
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function defaultPrivilegeObject(input) {
+  assertIdentifier2(input.forRole, "role");
+  assertIdentifier2(input.grantee, "role");
+  assertProvenance(input.provenance);
+  return {
+    kind: "defaultPrivilege",
+    identity: {
+      kind: "defaultPrivilege",
+      forRole: input.forRole,
+      namespace: input.namespace,
+      objectKind: input.objectKind,
+      grantee: input.grantee,
+      privilege: input.privilege
+    },
+    owner: input.owner ?? "managed",
+    definition: {},
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+
 // src/contracts/catalog/document.ts
 function creationOrder2(source) {
   return dependencyOrder(source.objects);
@@ -128,7 +200,7 @@ function renameTable2(source, change) {
   if (!found) {
     catalogError2("OKM1020", `Table ${change.from} is not in the catalog.`);
   }
-  const next = source.objects.map((object) => rewriteTableName(object, change, fromKey, toIdentity));
+  const next = source.objects.map((object) => rewriteTableName(object, change, fromKey, toIdentity, source));
   return catalog(next);
 }
 var serializedText = new WeakMap;
@@ -219,10 +291,60 @@ function rewriteRenamed(object, change, fromKey, toIdentity) {
       return rewriteSequence(object, dependencies);
     case "type":
       return rewriteType(object, dependencies);
+    case "extension":
+      return retargeted(object, dependencies);
+    case "function": {
+      const local = object.dependencies.some((edge) => edge.target.kind === "column" && sameRef2(edge.target.parent, change.parent));
+      return functionObject({
+        namespace: object.identity.namespace,
+        name: object.identity.name,
+        arguments: object.definition.arguments,
+        returns: object.definition.returns,
+        language: object.definition.language,
+        volatility: object.definition.volatility,
+        security: object.definition.security,
+        body: rewriteExpr(object.definition.body, change, local),
+        owner: object.owner,
+        provenance: object.provenance,
+        dependencies,
+        ...object.definition.searchPath !== undefined ? { searchPath: object.definition.searchPath } : {},
+        ...object.definition.atomic === true ? { atomic: true } : {}
+      });
+    }
+    case "view":
+    case "materializedView": {
+      const local = object.dependencies.some((edge) => edge.target.kind === "column" && sameRef2(edge.target.parent, change.parent));
+      return rewriteView(object, dependencies, rewriteExpr(object.definition.query, change, local));
+    }
+    case "role":
+    case "grant":
+    case "defaultPrivilege":
+      return retargeted(object, dependencies);
+    case "trigger": {
+      const local = sameRef2(object.identity.parent, change.parent);
+      return triggerObject({
+        parent: object.identity.parent,
+        name: object.identity.name,
+        timing: object.definition.timing,
+        events: object.definition.events,
+        level: object.definition.level,
+        calls: object.definition.calls,
+        owner: object.owner,
+        provenance: object.provenance,
+        dependencies,
+        ...object.definition.updateOf !== undefined ? {
+          updateOf: local ? renameList(object.definition.updateOf, change.from, change.to) : object.definition.updateOf
+        } : {},
+        ...object.definition.when !== undefined ? { when: rewriteExpr(object.definition.when, change, local) } : {}
+      });
+    }
     default:
       return assertNever(object);
   }
 }
+function retargeted(object, dependencies) {
+  return { ...object, dependencies: dependencies.map((target) => ({ target })) };
+}
 function rewriteTable(object, change, dependencies) {
   const partition = object.definition.partition;
   const renamed = partition !== undefined && object.identity.name === change.parent.name && sameNamespace2(object.identity.namespace, change.parent.namespace);
@@ -266,17 +388,39 @@ function rewriteColumn(object, change, dependencies) {
 function rewriteIndex(object, change, dependencies) {
   const local = sameRef2(object.identity.parent, change.parent);
   const definition = object.definition;
+  return indexAgain(object, object.identity.parent, dependencies, {
+    columns: local ? renameList(definition.columns, change.from, change.to) : [...definition.columns],
+    ...definition.predicate !== undefined ? { predicate: rewriteExpr(definition.predicate, change, local) } : {},
+    ...definition.expression !== undefined ? { expression: rewriteExpr(definition.expression, change, local) } : {}
+  });
+}
+function indexAgain(object, parent, dependencies, patch) {
+  const onView = dependencies.some((edge) => edge.kind === "view" || edge.kind === "materializedView");
+  if (onView) {
+    return materializedViewIndex({
+      parent,
+      name: object.identity.name,
+      nameKey: object.definition.nameKey,
+      columns: patch.columns,
+      unique: object.definition.unique,
+      owner: object.owner,
+      provenance: object.provenance,
+      dependencies,
+      ...patch.predicate !== undefined ? { predicate: patch.predicate } : {},
+      ...patch.expression !== undefined ? { expression: patch.expression } : {}
+    });
+  }
   return index3({
-    parent: object.identity.parent,
+    parent,
     name: object.identity.name,
-    nameKey: definition.nameKey,
-    columns: local ? renameList(definition.columns, change.from, change.to) : [...definition.columns],
-    unique: definition.unique,
+    nameKey: object.definition.nameKey,
+    columns: patch.columns,
+    unique: object.definition.unique,
     owner: object.owner,
     provenance: object.provenance,
     dependencies,
-    ...definition.predicate !== undefined ? { predicate: rewriteExpr(definition.predicate, change, local) } : {},
-    ...definition.expression !== undefined ? { expression: rewriteExpr(definition.expression, change, local) } : {}
+    ...patch.predicate !== undefined ? { predicate: patch.predicate } : {},
+    ...patch.expression !== undefined ? { expression: patch.expression } : {}
   });
 }
 function rewriteConstraint(object, change, dependencies) {
@@ -305,13 +449,31 @@ function rewriteConstraint(object, change, dependencies) {
     ...referenced !== undefined ? { references: referenced } : {}
   });
 }
+function rewriteView(object, dependencies, query) {
+  const input = {
+    namespace: object.identity.namespace,
+    name: object.identity.name,
+    columns: object.definition.columns,
+    query,
+    owner: object.owner,
+    provenance: object.provenance,
+    dependencies
+  };
+  if (object.kind === "materializedView") {
+    return materializedViewObject({
+      ...input,
+      ...object.definition.refresh !== undefined ? { refresh: object.definition.refresh } : {}
+    });
+  }
+  return viewObject(input);
+}
 function rewriteExpr(text, change, active) {
   if (!active)
     return text;
   return replaceIdentifier(text, change.from, change.to);
 }
-function rewriteTableName(object, change, fromKey, toIdentity) {
-  const dependencies = retarget(object.dependencies, fromKey, toIdentity);
+function rewriteTableName(object, change, fromKey, toIdentity, source) {
+  const dependencies = retarget(object.dependencies, fromKey, toIdentity, change);
   const named = object.kind === "table" && object.identity.name === change.from && sameNamespace2(object.identity.namespace, change.namespace);
   if (object.kind === "table") {
     return table3({
@@ -344,15 +506,8 @@ function rewriteTableName(object, change, fromKey, toIdentity) {
       });
     }
     if (object.kind === "index") {
-      return index3({
-        parent,
-        name: object.identity.name,
-        nameKey: object.definition.nameKey,
+      return indexAgain(object, parent, dependencies, {
         columns: [...object.definition.columns],
-        unique: object.definition.unique,
-        owner: object.owner,
-        provenance: object.provenance,
-        dependencies,
         ...object.definition.predicate !== undefined ? {
           predicate: rewriteExpr(object.definition.predicate, { from: change.from, to: change.to }, local)
         } : {},
@@ -390,6 +545,69 @@ function rewriteTableName(object, change, fromKey, toIdentity) {
     return rewriteSequence(object, dependencies);
   if (object.kind === "type")
     return rewriteType(object, dependencies);
+  if (object.kind === "extension") {
+    return { ...object, dependencies: dependencies.map((target) => ({ target })) };
+  }
+  if (object.kind === "function") {
+    const local = object.dependencies.some((edge) => edge.target.kind === "table" && edge.target.name === change.from && sameNamespace2(edge.target.namespace, change.namespace));
+    return functionObject({
+      namespace: object.identity.namespace,
+      name: object.identity.name,
+      arguments: object.definition.arguments,
+      returns: object.definition.returns,
+      language: object.definition.language,
+      volatility: object.definition.volatility,
+      security: object.definition.security,
+      body: rewriteExpr(object.definition.body, { from: change.from, to: change.to }, local),
+      owner: object.owner,
+      provenance: object.provenance,
+      dependencies,
+      ...object.definition.searchPath !== undefined ? { searchPath: object.definition.searchPath } : {},
+      ...object.definition.atomic === true ? { atomic: true } : {}
+    });
+  }
+  if (object.kind === "view" || object.kind === "materializedView") {
+    const local = object.dependencies.some((edge) => {
+      if (edge.target.kind === "table") {
+        return edge.target.name === change.from && sameNamespace2(edge.target.namespace, change.namespace);
+      }
+      if (edge.target.kind === "column") {
+        return edge.target.parent.name === change.from && sameNamespace2(edge.target.parent.namespace, change.namespace);
+      }
+      return false;
+    });
+    return rewriteView(object, dependencies, rewriteExpr(object.definition.query, { from: change.from, to: change.to }, local));
+  }
+  if (object.kind === "role" || object.kind === "defaultPrivilege") {
+    return retargeted(object, dependencies);
+  }
+  if (object.kind === "grant") {
+    return grantObject({
+      role: object.identity.role,
+      object: movedGrantRef(object.identity.object, change, source),
+      privilege: object.identity.privilege,
+      owner: object.owner,
+      provenance: object.provenance,
+      dependencies
+    });
+  }
+  if (object.kind === "trigger") {
+    const parent = movedParent(object.identity.parent, change);
+    const local = parent.name !== object.identity.parent.name;
+    return triggerObject({
+      parent,
+      name: object.identity.name,
+      timing: object.definition.timing,
+      events: object.definition.events,
+      level: object.definition.level,
+      calls: object.definition.calls,
+      owner: object.owner,
+      provenance: object.provenance,
+      dependencies,
+      ...object.definition.updateOf !== undefined ? { updateOf: object.definition.updateOf } : {},
+      ...object.definition.when !== undefined ? { when: rewriteExpr(object.definition.when, { from: change.from, to: change.to }, local) } : {}
+    });
+  }
   return assertNever(object);
 }
 function movedParent(parent, change) {
@@ -399,6 +617,17 @@ function movedParent(parent, change) {
   return parent;
 }
 function rewriteType(object, dependencies) {
+  if (isDomain(object.definition)) {
+    return domainType({
+      namespace: object.identity.namespace,
+      name: object.identity.name,
+      base: object.definition.base,
+      check: object.definition.check,
+      owner: object.owner,
+      provenance: object.provenance,
+      dependencies
+    });
+  }
   return enumType({
     namespace: object.identity.namespace,
     name: object.identity.name,
@@ -424,8 +653,46 @@ function rewriteSequence(object, dependencies) {
 function renameList(names, from, to) {
   return names.map((name) => name === from ? to : name);
 }
-function retarget(edges, fromKey, to) {
-  return edges.map((edge) => identityKey2(edge.target) === fromKey ? to : edge.target);
+function retarget(edges, fromKey, to, change) {
+  return edges.map((edge) => {
+    if (identityKey2(edge.target) === fromKey)
+      return to;
+    if (change === undefined)
+      return edge.target;
+    return movedChild(edge.target, change);
+  });
+}
+function movedChild(target, change) {
+  if (!("parent" in target))
+    return target;
+  if (target.parent.name !== change.from || !sameNamespace2(target.parent.namespace, change.namespace)) {
+    return target;
+  }
+  return { ...target, parent: { namespace: target.parent.namespace, name: change.to } };
+}
+function movedGrantRef(object, change, source) {
+  if (object.kind === "table" && object.name === change.from && sameNamespace2(object.namespace, change.namespace)) {
+    return { ...object, name: change.to };
+  }
+  if (object.kind !== "sequence")
+    return object;
+  const next = renamedIdentitySequence(source, change, object.name);
+  if (next === undefined)
+    return object;
+  return { ...object, name: next };
+}
+function renamedIdentitySequence(source, change, sequenceName) {
+  for (const object of source.objects) {
+    if (object.kind !== "column" || object.definition.identity === undefined)
+      continue;
+    if (object.identity.parent.name !== change.from || !sameNamespace2(object.identity.parent.namespace, change.namespace)) {
+      continue;
+    }
+    if (fitIdentifier2(`${change.from}_${object.identity.name}_seq`) !== sequenceName)
+      continue;
+    return fitIdentifier2(`${change.to}_${object.identity.name}_seq`);
+  }
+  return;
 }
 function dependencyJson(edges) {
   const indexed = edges.map((edge) => ({
@@ -513,7 +780,68 @@ function definitionToJson(object) {
         start: object.definition.start
       };
     case "type":
-      return { labels: object.definition.labels };
+      return isDomain(object.definition) ? { base: object.definition.base, check: object.definition.check } : { labels: object.definition.labels };
+    case "extension": {
+      const definition = object.definition;
+      return {
+        relocatable: definition.relocatable,
+        schema: definition.schema,
+        ...definition.version !== undefined ? { version: definition.version } : {}
+      };
+    }
+    case "function": {
+      const definition = object.definition;
+      return {
+        arguments: definition.arguments.map((argument) => ({
+          name: argument.name,
+          type: argument.type
+        })),
+        body: definition.body,
+        language: definition.language,
+        returns: definition.returns,
+        security: definition.security,
+        volatility: definition.volatility,
+        ...definition.atomic === true ? { atomic: true } : {},
+        ...definition.searchPath !== undefined ? { searchPath: definition.searchPath } : {}
+      };
+    }
+    case "trigger": {
+      const definition = object.definition;
+      return {
+        calls: {
+          argTypes: [...definition.calls.argTypes],
+          name: definition.calls.name,
+          namespace: namespaceToJson(definition.calls.namespace)
+        },
+        events: [...definition.events],
+        level: definition.level,
+        timing: definition.timing,
+        ...definition.updateOf !== undefined ? { updateOf: [...definition.updateOf] } : {},
+        ...definition.when !== undefined ? { when: definition.when } : {}
+      };
+    }
+    case "view":
+      return {
+        columns: object.definition.columns.map((column) => ({
+          dataType: column.dataType,
+          name: column.name
+        })),
+        query: object.definition.query
+      };
+    case "materializedView":
+      return {
+        columns: object.definition.columns.map((column) => ({
+          dataType: column.dataType,
+          name: column.name
+        })),
+        query: object.definition.query,
+        ...object.definition.refresh !== undefined ? { refresh: object.definition.refresh } : {}
+      };
+    case "role":
+      return { inherit: object.definition.inherit, login: object.definition.login };
+    case "grant":
+    case "defaultPrivilege":
+      return {};
     default:
       return assertNever(object);
   }
@@ -546,6 +874,21 @@ function parseObject(value) {
       return parseSequence(identity, definition, owner, provenance, dependencies);
     case "type":
       return parseType(identity, definition, owner, provenance, dependencies);
+    case "extension":
+      return parseExtension(identity, definition, owner, provenance, dependencies);
+    case "function":
+      return parseFunction(identity, definition, owner, provenance, dependencies);
+    case "trigger":
+      return parseTrigger(identity, definition, owner, provenance, dependencies);
+    case "view":
+    case "materializedView":
+      return parseView(kind, identity, definition, owner, provenance, dependencies);
+    case "role":
+      return parseRole(identity, definition, owner, provenance, dependencies);
+    case "grant":
+      return parseGrant(identity, definition, owner, provenance, dependencies);
+    case "defaultPrivilege":
+      return parseDefaultPrivilege(identity, definition, owner, provenance, dependencies);
     default:
       return assertNeverKind(kind);
   }
@@ -668,6 +1011,18 @@ function parseType(identity, definition, owner, provenance, dependencies) {
   if (identity.kind !== "type") {
     catalogError2("OKM1020", `Type object identity is ${identity.kind}, not a type.`);
   }
+  if ("base" in definition || "check" in definition) {
+    rejectUnknown(definition, ["base", "check"], "type definition");
+    return domainType({
+      namespace: identity.namespace,
+      name: identity.name,
+      base: requireString(definition.base, "domain base"),
+      check: requireString(definition.check, "domain check"),
+      owner,
+      provenance,
+      dependencies
+    });
+  }
   rejectUnknown(definition, ["labels"], "type definition");
   return enumType({
     namespace: identity.namespace,
@@ -678,6 +1033,160 @@ function parseType(identity, definition, owner, provenance, dependencies) {
     dependencies
   });
 }
+function parseFunction(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "function") {
+    catalogError2("OKM1020", `Function object identity is ${identity.kind}, not a function.`);
+  }
+  rejectUnknown(definition, ["arguments", "atomic", "body", "language", "returns", "searchPath", "security", "volatility"], "function definition");
+  const language = requireString(definition.language, "function language");
+  if (language !== "sql" && language !== "plpgsql") {
+    catalogError2("OKM1020", `Function ${identity.name} language must be sql or plpgsql.`);
+  }
+  const volatility = parseVolatility(definition.volatility);
+  const security = parseSecurity(definition.security);
+  return functionObject({
+    namespace: identity.namespace,
+    name: identity.name,
+    arguments: parseArguments(definition.arguments),
+    returns: requireString(definition.returns, "function returns"),
+    language,
+    body: requireString(definition.body, "function body"),
+    owner,
+    provenance,
+    dependencies,
+    ...volatility !== undefined ? { volatility } : {},
+    ...security !== undefined ? { security } : {},
+    ...definition.atomic === true ? { atomic: true } : {},
+    ...definition.searchPath !== undefined ? { searchPath: requireString(definition.searchPath, "search path") } : {}
+  });
+}
+function parseArguments(value) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value))
+    catalogError2("OKM1020", "Function arguments must be an array.");
+  return value.map((item) => {
+    const record = requireRecord(item, "function argument");
+    rejectUnknown(record, ["name", "type"], "function argument");
+    return {
+      name: requireString(record.name, "argument name"),
+      type: requireString(record.type, "argument type")
+    };
+  });
+}
+function parseVolatility(value) {
+  if (value === undefined)
+    return;
+  const text = requireString(value, "volatility");
+  if (text !== "volatile" && text !== "stable" && text !== "immutable") {
+    catalogError2("OKM1020", `Volatility ${text} is not supported.`);
+  }
+  return text;
+}
+function parseSecurity(value) {
+  if (value === undefined)
+    return;
+  const text = requireString(value, "security");
+  if (text !== "invoker" && text !== "definer") {
+    catalogError2("OKM1020", `Security ${text} is not supported.`);
+  }
+  return text;
+}
+function parseTrigger(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "trigger") {
+    catalogError2("OKM1020", `Trigger object identity is ${identity.kind}, not a trigger.`);
+  }
+  rejectUnknown(definition, ["calls", "events", "level", "timing", "updateOf", "when"], "trigger definition");
+  const timing = requireString(definition.timing, "trigger timing");
+  if (timing !== "before" && timing !== "after" && timing !== "instead") {
+    catalogError2("OKM1020", `Trigger timing ${timing} is not supported.`);
+  }
+  const level = requireString(definition.level, "trigger level");
+  if (level !== "row" && level !== "statement") {
+    catalogError2("OKM1020", `Trigger level ${level} is not supported.`);
+  }
+  const calls = requireRecord(definition.calls, "trigger call");
+  rejectUnknown(calls, ["argTypes", "name", "namespace"], "trigger call");
+  return triggerObject({
+    parent: identity.parent,
+    name: identity.name,
+    timing,
+    events: requireStrings(definition.events, "trigger events").map(parseEvent),
+    level,
+    calls: {
+      namespace: parseNamespace(calls.namespace),
+      name: requireString(calls.name, "trigger function"),
+      argTypes: requireStrings(calls.argTypes, "trigger argument types")
+    },
+    owner,
+    provenance,
+    dependencies,
+    ...definition.updateOf !== undefined ? { updateOf: requireStrings(definition.updateOf, "update of") } : {},
+    ...definition.when !== undefined ? { when: requireString(definition.when, "when") } : {}
+  });
+}
+function parseView(kind, identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== kind) {
+    catalogError2("OKM1020", `View object identity is ${identity.kind}, not a ${kind}.`);
+  }
+  const fields = kind === "view" ? ["columns", "query"] : ["columns", "query", "refresh"];
+  rejectUnknown(definition, fields, "view definition");
+  const columns = parseViewColumns(definition.columns);
+  const query = requireString(definition.query, "view query");
+  const refresh = definition.refresh;
+  if (refresh !== undefined && refresh !== "concurrently") {
+    catalogError2("OKM1020", `Materialized view ${identity.name} refresh is not supported.`);
+  }
+  const input = {
+    namespace: identity.namespace,
+    name: identity.name,
+    columns,
+    query,
+    owner,
+    provenance,
+    dependencies
+  };
+  if (kind === "materializedView") {
+    return materializedViewObject({
+      ...input,
+      ...refresh === "concurrently" ? { refresh: "concurrently" } : {}
+    });
+  }
+  return viewObject(input);
+}
+function parseViewColumns(value) {
+  if (!Array.isArray(value))
+    catalogError2("OKM1020", "View columns must be a list.");
+  return value.map((item) => {
+    const record = requireRecord(item, "view column");
+    rejectUnknown(record, ["dataType", "name"], "view column");
+    return {
+      name: requireString(record.name, "view column"),
+      dataType: requireString(record.dataType, "view column type")
+    };
+  });
+}
+function parseEvent(value) {
+  if (value !== "insert" && value !== "update" && value !== "delete" && value !== "truncate") {
+    catalogError2("OKM1020", `Trigger event ${value} is not supported.`);
+  }
+  return value;
+}
+function parseExtension(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "extension") {
+    catalogError2("OKM1020", `Extension object identity is ${identity.kind}, not an extension.`);
+  }
+  rejectUnknown(definition, ["relocatable", "schema", "version"], "extension definition");
+  return extensionObject({
+    name: identity.name,
+    schema: requireString(definition.schema, "extension schema"),
+    relocatable: requireBoolean(definition.relocatable, "relocatable"),
+    ...definition.version !== undefined ? { version: requireString(definition.version, "extension version") } : {},
+    owner,
+    provenance,
+    dependencies
+  });
+}
 function parseIdentity(value) {
   const record = requireRecord(value, "identity");
   const kind = requireString(record.kind, "identity kind");
@@ -763,8 +1272,8 @@ function parseGrantObject(value) {
   const record = requireRecord(value, "grant object");
   rejectUnknown(record, ["kind", "name", "namespace"], "grant object");
   const kind = requireString(record.kind, "grant object kind");
-  if (kind !== "table" && kind !== "sequence" && kind !== "namespace") {
-    catalogError2("OKM1020", `Grant object kind ${kind} must be table, sequence, or namespace.`);
+  if (kind !== "table" && kind !== "view" && kind !== "materializedView" && kind !== "sequence" && kind !== "function" && kind !== "namespace") {
+    catalogError2("OKM1020", `Grant object kind ${kind} must be table, view, materializedView, sequence, function, or namespace.`);
   }
   return {
     kind,
@@ -772,6 +1281,50 @@ function parseGrantObject(value) {
     namespace: parseNamespace(record.namespace)
   };
 }
+function parseRole(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "role") {
+    catalogError2("OKM1020", `Role object identity is ${identity.kind}, not a role.`);
+  }
+  rejectUnknown(definition, ["inherit", "login"], "role definition");
+  return roleObject({
+    name: identity.name,
+    login: requireBoolean(definition.login, "login"),
+    inherit: requireBoolean(definition.inherit, "inherit"),
+    owner,
+    provenance,
+    dependencies
+  });
+}
+function parseGrant(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "grant") {
+    catalogError2("OKM1020", `Grant object identity is ${identity.kind}, not a grant.`);
+  }
+  rejectUnknown(definition, [], "grant definition");
+  return grantObject({
+    role: identity.role,
+    object: identity.object,
+    privilege: identity.privilege,
+    owner,
+    provenance,
+    dependencies
+  });
+}
+function parseDefaultPrivilege(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "defaultPrivilege") {
+    catalogError2("OKM1020", `Default privilege object identity is ${identity.kind}, not a default privilege.`);
+  }
+  rejectUnknown(definition, [], "default privilege definition");
+  return defaultPrivilegeObject({
+    forRole: identity.forRole,
+    namespace: identity.namespace,
+    objectKind: identity.objectKind,
+    grantee: identity.grantee,
+    privilege: identity.privilege,
+    owner,
+    provenance,
+    dependencies
+  });
+}
 function parsePartition(value) {
   const record = requireRecord(value, "partition");
   rejectUnknown(record, ["columns", "method"], "partition");
@@ -845,7 +1398,7 @@ function parseDependencies(value) {
   });
 }
 function isBuiltKind(kind) {
-  return BUILT_KINDS2.includes(kind);
+  return kind === "extension" || kind === "function" || kind === "trigger" || kind === "view" || kind === "materializedView" || kind === "role" || kind === "grant" || kind === "defaultPrivilege" || BUILT_KINDS2.includes(kind);
 }
 function isOwner(value) {
   return OWNERS2.includes(value);
@@ -891,4 +1444,4 @@ function assertNeverKind(value) {
   return catalogError2("OKM1020", `Unexpected kind ${JSON.stringify(value)}.`);
 }
 
-export { creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, loadTrustedCatalog2, parseCatalog2 };
+export { roleObject, grantObject, defaultPrivilegeObject, creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, loadTrustedCatalog2, parseCatalog2 };