okmodel 0.0.0 → 0.1.0

package/dist/shared/g5fhqmwe.js

@@ -0,0 +1,188 @@
+import {
+  CATALOG_VERSION2,
+  assertNamespace2,
+  identityKey2,
+  identityLabel2,
+  normaliseEdges,
+  compareText,
+  assertProvenance
+} from "./j5cn2963.js";
+import {
+  assertIdentifier2,
+  assertStoredText
+} from "./mkjmqjv4.js";
+import {
+  catalogError2
+} from "./ycwz42az.js";
+
+// src/contracts/catalog/order.ts
+function indexObjects(objects) {
+  const seen = new Set;
+  const indexed = [];
+  for (const object of objects) {
+    const key = identityKey2(object.identity);
+    if (seen.has(key)) {
+      catalogError2("OKM1023", `Duplicate identity for ${identityLabel2(object.identity)}.`);
+    }
+    seen.add(key);
+    indexed.push({ key, object });
+  }
+  return indexed;
+}
+function dependencyOrder(objects) {
+  return orderIndexed(indexObjects(objects));
+}
+function orderIndexed(indexed) {
+  const byKey = new Map;
+  for (const item of indexed) {
+    byKey.set(item.key, item.object);
+  }
+  const dependents = new Map;
+  const remaining = new Map;
+  for (const item of indexed) {
+    dependents.set(item.key, []);
+    remaining.set(item.key, 0);
+  }
+  for (const item of indexed) {
+    const seen = new Set;
+    for (const edge of item.object.dependencies) {
+      const dependency = identityKey2(edge.target);
+      if (dependency === item.key) {
+        catalogError2("OKM1020", `${identityLabel2(item.object.identity)} depends on itself.`);
+      }
+      if (!byKey.has(dependency)) {
+        catalogError2("OKM1020", `${identityLabel2(item.object.identity)} depends on ${identityLabel2(edge.target)}, which is not in the catalog.`);
+      }
+      if (seen.has(dependency)) {
+        continue;
+      }
+      seen.add(dependency);
+      remaining.set(item.key, (remaining.get(item.key) ?? 0) + 1);
+      dependents.get(dependency)?.push(item.key);
+    }
+  }
+  const ready = indexed.filter((item) => remaining.get(item.key) === 0).map((item) => item.key);
+  ready.sort(compareText);
+  const ordered = [];
+  let cursor = 0;
+  while (cursor < ready.length) {
+    const key = ready[cursor];
+    if (key === undefined) {
+      break;
+    }
+    cursor += 1;
+    const object = byKey.get(key);
+    if (object === undefined) {
+      catalogError2("OKM1020", "Dependency order lost an object while sorting.");
+    }
+    ordered.push(object);
+    for (const dependent of dependents.get(key) ?? []) {
+      const left = (remaining.get(dependent) ?? 0) - 1;
+      remaining.set(dependent, left);
+      if (left === 0) {
+        insertSorted(ready, cursor, dependent);
+      }
+    }
+  }
+  if (ordered.length !== byKey.size) {
+    catalogError2("OKM1026", "Catalog has a dependency cycle.");
+  }
+  return ordered;
+}
+function insertSorted(ready, from, key) {
+  let index = from;
+  while (index < ready.length && compareText(ready[index] ?? "", key) < 0) {
+    index += 1;
+  }
+  ready.splice(index, 0, key);
+}
+
+// src/contracts/catalog/build.ts
+function catalog(objects) {
+  for (const object of objects) {
+    if (object.kind !== object.identity.kind) {
+      catalogError2("OKM1020", `${identityLabel2(object.identity)} has kind ${object.kind}.`);
+    }
+  }
+  const indexed = indexObjects(objects);
+  const keys = new Set;
+  for (const item of indexed) {
+    keys.add(item.key);
+  }
+  assertForeignKeys(objects, keys);
+  orderIndexed(indexed);
+  const sorted = [...indexed].sort((left, right) => compareText(left.key, right.key));
+  return { version: CATALOG_VERSION2, objects: sorted.map((item) => item.object) };
+}
+function assertForeignKeys(objects, keys) {
+  for (const object of objects) {
+    if (object.kind !== "constraint" || object.definition.constraintKind !== "foreignKey") {
+      continue;
+    }
+    const references = object.definition.references;
+    if (references === undefined) {
+      catalogError2("OKM1021", `Foreign key ${object.identity.name} is missing its target.`);
+    }
+    const tableKey = identityKey2({
+      kind: "table",
+      namespace: references.parent.namespace,
+      name: references.parent.name
+    });
+    if (!keys.has(tableKey)) {
+      catalogError2("OKM1021", `Foreign key ${object.identity.name} references missing table ${references.parent.name}.`);
+    }
+    for (const name of references.columns) {
+      const columnKey = identityKey2({ kind: "column", parent: references.parent, name });
+      if (!keys.has(columnKey)) {
+        catalogError2("OKM1021", `Foreign key ${object.identity.name} references missing column ${name}.`);
+      }
+    }
+  }
+}
+
+// src/contracts/catalog/enum.ts
+function enumType(input) {
+  assertNamespace2(input.namespace);
+  assertIdentifier2(input.name, "type");
+  assertProvenance(input.provenance);
+  if (input.labels.length === 0) {
+    catalogError2("OKM1020", `Enum ${input.name} must list at least one label.`);
+  }
+  const labels = [];
+  const seen = new Set;
+  for (const label of input.labels) {
+    assertStoredText(label, "enum label");
+    if (label.length === 0) {
+      catalogError2("OKM1020", `Enum ${input.name} has an empty label.`);
+    }
+    if (seen.has(label)) {
+      catalogError2("OKM1020", `Enum ${input.name} repeats label ${label}.`);
+    }
+    seen.add(label);
+    labels.push(label);
+  }
+  const identity = {
+    kind: "type",
+    namespace: input.namespace,
+    name: input.name
+  };
+  return {
+    kind: "type",
+    identity,
+    owner: input.owner ?? "managed",
+    definition: { labels },
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function sameEnumLabels(left, right) {
+  if (left.length !== right.length)
+    return false;
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index])
+      return false;
+  }
+  return true;
+}
+
+export { dependencyOrder, catalog, enumType, sameEnumLabels };