okmodel 0.0.0 → 0.1.0

package/dist/shared/j5cn2963.js

@@ -0,0 +1,701 @@
+import {
+  assertIdentifier2,
+  fitIdentifier2,
+  deterministicName2,
+  assertStoredText
+} from "./mkjmqjv4.js";
+import {
+  catalogError2
+} from "./ycwz42az.js";
+
+// src/contracts/catalog/types.ts
+var OWNERS2 = ["managed", "external", "ignored"];
+var OBJECT_KINDS2 = [
+  "table",
+  "column",
+  "index",
+  "constraint",
+  "sequence",
+  "view",
+  "materializedView",
+  "type",
+  "function",
+  "trigger",
+  "policy",
+  "extension",
+  "role",
+  "grant",
+  "defaultPrivilege"
+];
+var BUILT_KINDS2 = ["table", "column", "index", "constraint", "sequence", "type"];
+var OBJECT_OPERATIONS2 = [
+  "create",
+  "replace",
+  "alter",
+  "drop",
+  "recreateWithDependents"
+];
+var KIND_OPERATIONS2 = {
+  table: ["create", "alter", "drop", "recreateWithDependents"],
+  column: ["create", "alter", "drop", "recreateWithDependents"],
+  index: ["create", "drop", "recreateWithDependents"],
+  constraint: ["create", "alter", "drop", "recreateWithDependents"],
+  sequence: ["create", "alter", "drop"],
+  view: ["create", "replace", "drop", "recreateWithDependents"],
+  materializedView: ["create", "drop", "recreateWithDependents"],
+  type: ["create", "alter", "drop"],
+  function: ["create", "replace", "drop", "recreateWithDependents"],
+  trigger: ["create", "drop", "recreateWithDependents"],
+  policy: ["create", "alter", "drop"],
+  extension: ["create", "alter", "drop"],
+  role: ["create", "alter"],
+  grant: ["create", "drop"],
+  defaultPrivilege: ["create", "alter", "drop"]
+};
+var REFERENTIAL_ACTIONS = [
+  "cascade",
+  "no action",
+  "restrict",
+  "set default",
+  "set null"
+];
+function referentialAction(value) {
+  for (const action of REFERENTIAL_ACTIONS) {
+    if (action === value) {
+      return action;
+    }
+  }
+  return;
+}
+var CATALOG_VERSION2 = 1;
+
+// src/contracts/catalog/json.ts
+function canonicalJson(value) {
+  return encode(value);
+}
+function encode(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) {
+      catalogError2("OKM1020", "Catalog JSON cannot encode a non-integer number.");
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return encodeString(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => encode(item)).join(",")}]`;
+  }
+  if (!isJsonRecord(value)) {
+    catalogError2("OKM1020", "Catalog JSON cannot encode this value.");
+  }
+  const keys = Object.keys(value).sort();
+  const parts = [];
+  for (const key of keys) {
+    const item = value[key];
+    if (item === undefined) {
+      continue;
+    }
+    parts.push(`${encodeString(key)}:${encode(item)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function isJsonRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function encodeString(value) {
+  for (let index = 0;index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code === 34 || code === 92 || code < 32 || code > 126) {
+      return encodeEscaped(value);
+    }
+  }
+  return `"${value}"`;
+}
+function encodeEscaped(value) {
+  const parts = ['"'];
+  let start = 0;
+  for (let index = 0;index < value.length; ) {
+    const code = value.charCodeAt(index);
+    const next = value.charCodeAt(index + 1);
+    if (code >= 55296 && code <= 56319 && next >= 56320 && next <= 57343) {
+      if (index > start) {
+        parts.push(value.slice(start, index));
+      }
+      parts.push(hexEscape(code), hexEscape(next));
+      index += 2;
+      start = index;
+      continue;
+    }
+    if (needsEscape(code)) {
+      if (index > start) {
+        parts.push(value.slice(start, index));
+      }
+      parts.push(escapeUnit(code));
+      index += 1;
+      start = index;
+      continue;
+    }
+    index += 1;
+  }
+  if (start < value.length) {
+    parts.push(value.slice(start));
+  }
+  parts.push('"');
+  return parts.join("");
+}
+function needsEscape(code) {
+  return code === 34 || code === 92 || code < 32 || code > 126;
+}
+function escapeUnit(code) {
+  if (code === 34) {
+    return "\\\"";
+  }
+  if (code === 92) {
+    return "\\\\";
+  }
+  if (code === 8) {
+    return "\\b";
+  }
+  if (code === 12) {
+    return "\\f";
+  }
+  if (code === 10) {
+    return "\\n";
+  }
+  if (code === 13) {
+    return "\\r";
+  }
+  if (code === 9) {
+    return "\\t";
+  }
+  return hexEscape(code);
+}
+function hexEscape(code) {
+  return `\\u${code.toString(16).padStart(4, "0")}`;
+}
+
+// src/contracts/catalog/identity.ts
+var UUID_HEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function staticNamespace2(name) {
+  assertIdentifier2(name, "namespace");
+  return { form: "static", name };
+}
+function templateNamespace2(pattern) {
+  const placeholders = pattern.split("{id}").length - 1;
+  if (placeholders < 1) {
+    catalogError2("OKM1122", `Namespace template ${pattern} must contain {id}.`);
+  }
+  const stripped = pattern.replaceAll("{id}", "");
+  if (!/^[A-Za-z0-9_]*$/.test(stripped)) {
+    catalogError2("OKM1122", `Namespace template ${pattern} may contain only letters, digits, underscores, and {id}.`);
+  }
+  return { form: "template", pattern };
+}
+function assertNamespace2(namespace) {
+  if (namespace.form === "static") {
+    assertIdentifier2(namespace.name, "namespace");
+    return;
+  }
+  templateNamespace2(namespace.pattern);
+}
+function resolveNamespace2(namespace, tenantId = "") {
+  if (namespace.form === "static") {
+    assertIdentifier2(namespace.name, "namespace");
+    return namespace.name;
+  }
+  const resolved = namespace.pattern.replaceAll("{id}", canonicalTenantId(tenantId));
+  assertIdentifier2(resolved, "namespace");
+  return resolved;
+}
+function identityKey2(identity) {
+  const plain = plainIdentityKey(identity);
+  if (plain !== undefined) {
+    return plain;
+  }
+  return canonicalJson(identityToJson(identity));
+}
+function plainIdentityKey(identity) {
+  switch (identity.kind) {
+    case "table":
+    case "view":
+    case "materializedView":
+    case "sequence":
+    case "type":
+      return namespaceIdentityKey(identity.kind, identity.name, identity.namespace);
+    case "column":
+    case "index":
+    case "constraint":
+    case "trigger":
+    case "policy":
+      return anchoredIdentityKey(identity.kind, identity.name, identity.parent);
+    case "role":
+    case "extension":
+      if (!isPlainJsonText(identity.name)) {
+        return;
+      }
+      return `{"kind":"${identity.kind}","name":"${identity.name}"}`;
+    default:
+      return;
+  }
+}
+function namespaceIdentityKey(kind, name, namespace) {
+  const encoded = staticNamespaceKey(namespace);
+  if (encoded === undefined || !isPlainJsonText(name)) {
+    return;
+  }
+  return `{"kind":"${kind}","name":"${name}","namespace":${encoded}}`;
+}
+function anchoredIdentityKey(kind, name, parent) {
+  const encoded = staticNamespaceKey(parent.namespace);
+  if (encoded === undefined || !isPlainJsonText(name) || !isPlainJsonText(parent.name)) {
+    return;
+  }
+  return `{"kind":"${kind}","name":"${name}","parent":{"name":"${parent.name}","namespace":${encoded}}}`;
+}
+function staticNamespaceKey(namespace) {
+  if (namespace.form !== "static" || !isPlainJsonText(namespace.name)) {
+    return;
+  }
+  return `{"form":"static","name":"${namespace.name}"}`;
+}
+function isPlainJsonText(value) {
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 34 || code === 92 || code < 32 || code > 126) {
+      return false;
+    }
+  }
+  return true;
+}
+function identifierLimitApplies2(kind) {
+  return kind !== "grant" && kind !== "defaultPrivilege";
+}
+function identityLabel2(identity) {
+  if (identity.kind === "grant") {
+    return `grant ${identity.role} ${identity.privilege}`;
+  }
+  if (identity.kind === "defaultPrivilege") {
+    return `default privilege ${identity.grantee} ${identity.privilege}`;
+  }
+  return `${identity.kind} ${identity.name}`;
+}
+function sameRef2(left, right) {
+  return left.name === right.name && sameNamespace2(left.namespace, right.namespace);
+}
+function sameNamespace2(left, right) {
+  if (left.form !== right.form) {
+    return false;
+  }
+  if (left.form === "static" && right.form === "static") {
+    return left.name === right.name;
+  }
+  if (left.form === "template" && right.form === "template") {
+    return left.pattern === right.pattern;
+  }
+  return false;
+}
+function identityToJson(identity) {
+  switch (identity.kind) {
+    case "table":
+    case "view":
+    case "materializedView":
+    case "sequence":
+    case "type":
+      return namespaceIdentityJson(identity);
+    case "column":
+    case "index":
+    case "constraint":
+    case "trigger":
+    case "policy":
+      return {
+        kind: identity.kind,
+        name: identity.name,
+        parent: refToJson(identity.parent)
+      };
+    case "function":
+      return functionIdentityJson(identity);
+    case "grant":
+      return grantIdentityJson(identity);
+    case "defaultPrivilege":
+      return defaultPrivilegeIdentityJson(identity);
+    case "role":
+    case "extension":
+      return { kind: identity.kind, name: identity.name };
+    default:
+      return assertNever(identity);
+  }
+}
+function namespaceToJson(namespace) {
+  if (namespace.form === "static") {
+    return { form: "static", name: namespace.name };
+  }
+  return { form: "template", pattern: namespace.pattern };
+}
+function namespaceIdentityJson(identity) {
+  return {
+    kind: identity.kind,
+    name: identity.name,
+    namespace: namespaceToJson(identity.namespace)
+  };
+}
+function functionIdentityJson(identity) {
+  return {
+    argTypes: identity.argTypes,
+    kind: identity.kind,
+    name: identity.name,
+    namespace: namespaceToJson(identity.namespace)
+  };
+}
+function grantIdentityJson(identity) {
+  return {
+    kind: identity.kind,
+    object: {
+      kind: identity.object.kind,
+      name: identity.object.name,
+      namespace: namespaceToJson(identity.object.namespace)
+    },
+    privilege: identity.privilege,
+    role: identity.role
+  };
+}
+function defaultPrivilegeIdentityJson(identity) {
+  return {
+    forRole: identity.forRole,
+    grantee: identity.grantee,
+    kind: identity.kind,
+    namespace: namespaceToJson(identity.namespace),
+    objectKind: identity.objectKind,
+    privilege: identity.privilege
+  };
+}
+function refToJson(ref) {
+  return { name: ref.name, namespace: namespaceToJson(ref.namespace) };
+}
+function canonicalTenantId(tenantId) {
+  if (UUID_HEX.test(tenantId)) {
+    return tenantId.replaceAll("-", "").toLowerCase();
+  }
+  if (/^[a-z0-9_]+$/.test(tenantId)) {
+    return tenantId;
+  }
+  catalogError2("OKM1122", `Tenant id ${tenantId} must be a UUID or lowercase [a-z0-9_].`);
+}
+function assertNever(value) {
+  return catalogError2("OKM1020", `Unexpected identity ${JSON.stringify(value)}.`);
+}
+
+// src/contracts/catalog/object.ts
+function table3(input) {
+  assertNamespace2(input.namespace);
+  assertIdentifier2(input.name, "table");
+  assertProvenance(input.provenance);
+  const identity = {
+    kind: "table",
+    namespace: input.namespace,
+    name: input.name
+  };
+  const definition = input.partition === undefined ? {} : { partition: copyPartition(input.partition) };
+  return {
+    kind: "table",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function column2(input) {
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.name, "column");
+  assertIdentifier2(input.parent.name, "column parent");
+  assertProvenance(input.provenance);
+  assertStoredText(input.dataType, "column type");
+  if (input.dataType.length === 0) {
+    catalogError2("OKM1020", `Column ${input.name} has no data type.`);
+  }
+  const modes = [
+    input.defaultExpression !== undefined,
+    input.identity !== undefined,
+    input.generated !== undefined
+  ].filter(Boolean).length;
+  if (modes > 1) {
+    catalogError2("OKM1020", `Column ${input.name} sets more than one of default, identity, and generated. Set only one.`);
+  }
+  if (input.defaultExpression !== undefined) {
+    assertStoredText(input.defaultExpression, "column default");
+  }
+  if (input.generated !== undefined) {
+    assertStoredText(input.generated.expression, "column generated expression");
+  }
+  const identity = {
+    kind: "column",
+    parent: input.parent,
+    name: input.name
+  };
+  const definition = {
+    dataType: input.dataType,
+    nullable: input.nullable,
+    ...input.defaultExpression !== undefined ? { defaultExpression: input.defaultExpression } : {},
+    ...input.identity !== undefined ? { identity: { always: input.identity.always } } : {},
+    ...input.generated !== undefined ? {
+      generated: {
+        stored: input.generated.stored,
+        expression: input.generated.expression
+      }
+    } : {}
+  };
+  return {
+    kind: "column",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges([tableIdentity(input.parent), ...input.dependencies ?? []]),
+    provenance: input.provenance
+  };
+}
+function index3(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.`);
+  }
+  if (input.predicate !== undefined) {
+    assertStoredText(input.predicate, "index predicate");
+  }
+  if (input.expression !== undefined) {
+    assertStoredText(input.expression, "index expression");
+  }
+  const nameKey = input.nameKey ?? (columns.length > 0 ? columns.join("_") : "expr");
+  assertIdentifierTextKey(nameKey);
+  const name = input.name === undefined ? deterministicName2({ parent: input.parent.name, purpose: "index", nameKey }) : fitIdentifier2(input.name);
+  const identity = {
+    kind: "index",
+    parent: input.parent,
+    name
+  };
+  const definition = {
+    columns,
+    unique: input.unique ?? false,
+    nameKey,
+    ...input.predicate !== undefined ? { predicate: input.predicate } : {},
+    ...input.expression !== undefined ? { expression: input.expression } : {}
+  };
+  return {
+    kind: "index",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges([
+      tableIdentity(input.parent),
+      ...columns.map((columnName) => columnIdentity(input.parent, columnName)),
+      ...input.dependencies ?? []
+    ]),
+    provenance: input.provenance
+  };
+}
+function constraint2(input) {
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.parent.name, "constraint parent");
+  assertProvenance(input.provenance);
+  const columns = [...input.columns ?? []];
+  for (const name of columns) {
+    assertIdentifier2(name, "constraint column");
+  }
+  const deferrable = input.deferrable ?? false;
+  const initially = input.initially ?? "immediate";
+  if (initially === "deferred" && !deferrable) {
+    catalogError2("OKM1020", `Constraint on ${input.parent.name} is initially deferred but not deferrable.`);
+  }
+  const nullsNotDistinct = input.nullsNotDistinct ?? false;
+  if (nullsNotDistinct && input.constraintKind !== "primaryKey" && input.constraintKind !== "unique") {
+    catalogError2("OKM1020", `Constraint on ${input.parent.name} sets nullsNotDistinct on ${input.constraintKind}. nullsNotDistinct applies only to a primary key or a unique constraint.`);
+  }
+  if (input.constraintKind === "foreignKey") {
+    if (input.references === undefined || input.references.columns.length === 0 || columns.length === 0) {
+      catalogError2("OKM1021", `Foreign key on ${input.parent.name} is missing its target.`);
+    }
+  } else if (input.constraintKind === "check") {
+    if (input.expression === undefined || input.expression.length === 0) {
+      catalogError2("OKM1020", `Check on ${input.parent.name} needs an expression.`);
+    }
+  } else if (columns.length === 0) {
+    catalogError2("OKM1020", `${input.constraintKind} on ${input.parent.name} needs a column.`);
+  }
+  if (input.expression !== undefined) {
+    assertStoredText(input.expression, "constraint expression");
+  }
+  const references = input.references;
+  if (references !== undefined) {
+    assertNamespace2(references.parent.namespace);
+    assertIdentifier2(references.parent.name, "referenced table");
+    for (const name of references.columns) {
+      assertIdentifier2(name, "referenced column");
+    }
+    assertAction(references.onDelete, input.parent.name);
+    assertAction(references.onUpdate, input.parent.name);
+  }
+  if (input.constraintKind === "check" && columns.length === 0 && (input.nameKey === undefined || input.nameKey.length === 0)) {
+    catalogError2("OKM1020", `Check on ${input.parent.name} needs a name key.`);
+  }
+  const nameKey = input.nameKey ?? defaultNameKey(input.constraintKind, columns);
+  assertIdentifierTextKey(nameKey);
+  const name = input.name === undefined ? deterministicName2({
+    parent: input.parent.name,
+    purpose: input.constraintKind,
+    nameKey
+  }) : fitIdentifier2(input.name);
+  const identity = {
+    kind: "constraint",
+    parent: input.parent,
+    name
+  };
+  const definition = {
+    constraintKind: input.constraintKind,
+    columns,
+    nameKey,
+    deferrable,
+    initially,
+    nullsNotDistinct,
+    ...input.expression !== undefined ? { expression: input.expression } : {},
+    ...references !== undefined ? {
+      references: {
+        parent: references.parent,
+        columns: [...references.columns],
+        ...references.onDelete !== undefined ? { onDelete: references.onDelete } : {},
+        ...references.onUpdate !== undefined ? { onUpdate: references.onUpdate } : {}
+      }
+    } : {}
+  };
+  const targets = [
+    tableIdentity(input.parent),
+    ...columns.map((columnName) => columnIdentity(input.parent, columnName))
+  ];
+  if (references !== undefined) {
+    targets.push(tableIdentity(references.parent));
+    for (const columnName of references.columns) {
+      targets.push(columnIdentity(references.parent, columnName));
+    }
+  }
+  targets.push(...input.dependencies ?? []);
+  return {
+    kind: "constraint",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(targets),
+    provenance: input.provenance
+  };
+}
+function sequence2(input) {
+  assertNamespace2(input.namespace);
+  assertIdentifier2(input.name, "sequence");
+  assertProvenance(input.provenance);
+  const start = input.start ?? "1";
+  const increment = input.increment ?? "1";
+  assertInteger(start, "sequence start");
+  assertInteger(increment, "sequence increment");
+  if (increment === "0" || increment === "-0") {
+    catalogError2("OKM1020", `Sequence ${input.name} has a zero increment.`);
+  }
+  const identity = {
+    kind: "sequence",
+    namespace: input.namespace,
+    name: input.name
+  };
+  return {
+    kind: "sequence",
+    identity,
+    owner: input.owner ?? "managed",
+    definition: {
+      dataType: input.dataType ?? "bigint",
+      start,
+      increment,
+      cycle: input.cycle ?? false
+    },
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function normaliseEdges(targets) {
+  const byKey = new Map;
+  for (const target of targets) {
+    const key = identityKey2(target);
+    if (!byKey.has(key)) {
+      byKey.set(key, target);
+    }
+  }
+  return [...byKey.entries()].sort((left, right) => compareText(left[0], right[0])).map(([, target]) => ({ target }));
+}
+function compareText(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function tableIdentity(parent) {
+  return { kind: "table", namespace: parent.namespace, name: parent.name };
+}
+function columnIdentity(parent, name) {
+  return { kind: "column", parent, name };
+}
+function defaultNameKey(kind, columns) {
+  if (kind === "primaryKey") {
+    return "pkey";
+  }
+  return columns.join("_");
+}
+function assertIdentifierTextKey(nameKey) {
+  if (nameKey.length === 0) {
+    catalogError2("OKM1122", "Name key is empty.");
+  }
+  if (nameKey.includes("\x00")) {
+    catalogError2("OKM1122", "Name key contains NUL.");
+  }
+  assertStoredText(nameKey, "Name key");
+}
+function assertInteger(value, role) {
+  assertStoredText(value, role);
+  if (!/^-?\d+$/.test(value)) {
+    catalogError2("OKM1020", `${role} ${value} is not an integer.`);
+  }
+}
+function assertAction(action, parent) {
+  if (action === undefined) {
+    return;
+  }
+  if (referentialAction(action) === undefined) {
+    catalogError2("OKM1020", `Foreign key on ${parent} has referential action ${action}. Accepted actions: cascade, no action, restrict, set default, set null.`);
+  }
+}
+function assertProvenance(provenance) {
+  assertStoredText(provenance.name, "provenance");
+  if (provenance.name.length === 0) {
+    catalogError2("OKM1020", "Provenance name is empty.");
+  }
+}
+function copyPartition(partition) {
+  if (partition.columns.length === 0) {
+    catalogError2("OKM1020", "Partition needs a column.");
+  }
+  for (const name of partition.columns) {
+    assertIdentifier2(name, "partition column");
+  }
+  return { method: partition.method, columns: [...partition.columns] };
+}
+
+export { OWNERS2, OBJECT_KINDS2, BUILT_KINDS2, OBJECT_OPERATIONS2, KIND_OPERATIONS2, REFERENTIAL_ACTIONS, referentialAction, CATALOG_VERSION2, canonicalJson, staticNamespace2, templateNamespace2, assertNamespace2, resolveNamespace2, identityKey2, identifierLimitApplies2, identityLabel2, sameRef2, sameNamespace2, identityToJson, namespaceToJson, table3, column2, index3, constraint2, sequence2, normaliseEdges, compareText, assertProvenance };