@nicia-ai/typegraph 0.42.1 → 0.44.0

package/dist/{chunk-RAWG2FEU.js → chunk-BEFM74L2.js}

@@ -1,17 +1,17 @@
 import { compareStrings } from './chunk-DRACN6XG.js';
-import { META_EDGE_BRAND, getTypeName, defineEdge, defineNode } from './chunk-2HKIID5K.js';
+import { META_EDGE_BRAND, getTypeName, defineEdge, defineNode } from './chunk-2Y4IFKW7.js';
 import { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
-import { isMissingTableError } from './chunk-CUPJL6TS.js';
-import { getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-3V6D5DEC.js';
-import { nowIso } from './chunk-GT7NEXSU.js';
-import { defineNodeIndex, defineEdgeIndex } from './chunk-ZP2KPDNN.js';
+import { isMissingTableError } from './chunk-B75XRV3O.js';
+import { getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-S4KQ5LV4.js';
+import { nowIso } from './chunk-KCO5EFJU.js';
+import { defineNodeIndex, defineEdgeIndex } from './chunk-TFMVL4QH.js';
 import { sha256Hex } from './chunk-K34OPSJK.js';
 import { requireDefined } from './chunk-QMQLUA66.js';
 import { resolveGraphVectorSlots, embedding, searchable } from './chunk-PC2UBAUB.js';
-import { isReachable, LEGACY_GRAPH_EXTENSION_VERSION, unwrap, validateGraphExtension, KindCollisionError, GraphExtensionUnresolvedEndpointError, computeTransitiveClosure, invertClosure } from './chunk-EQOQOT55.js';
+import { isReachable, LEGACY_GRAPH_EXTENSION_VERSION, unwrap, validateGraphExtension, KindCollisionError, GraphExtensionUnresolvedEndpointError, RemoveCompileTimeKindError, KindHasReferentsError, computeTransitiveClosure, invertClosure } from './chunk-IJTLXNGJ.js';
 import { ALL_META_EDGE_NAMES, META_EDGE_IMPLIES, META_EDGE_INVERSE_OF, META_EDGE_PART_OF, META_EDGE_HAS_PART, META_EDGE_DISJOINT_WITH, META_EDGE_DIFFERENT_FROM, META_EDGE_SAME_AS, META_EDGE_EQUIVALENT_TO, META_EDGE_RELATED_TO, META_EDGE_BROADER, META_EDGE_NARROWER, META_EDGE_SUB_CLASS_OF } from './chunk-GYA4JRP5.js';
 import { compactUndefined, freezeDeep } from './chunk-ITE4IXAK.js';
-import { ConfigurationError, KindNotFoundError, DatabaseOperationError, MigrationError } from './chunk-OYJSYDIH.js';
+import { ConfigurationError, KindNotFoundError, DatabaseOperationError, MigrationError, StaleVersionError } from './chunk-4MB3AQAQ.js';
 import { z } from 'zod';
 
 // src/ontology/core-meta-edges.ts
@@ -2133,6 +2133,183 @@ function resolveOntologyEndpoints(relation, nodeKinds) {
   return { ...relation, from, to };
 }
 
+// src/graph-extension/remove.ts
+function planRemovals(graph, names) {
+  const document = graph.extension;
+  const namesSet = new Set(names);
+  if (namesSet.size === 0) {
+    return { document, removedNodeKinds: [], removedEdgeKinds: [] };
+  }
+  const { nodes: runtimeNodeNames, edges: runtimeEdgeNames } = extensionKindNames(document);
+  const compileTimeNodeNames = new Set(
+    Object.keys(graph.nodes).filter((name) => !runtimeNodeNames.has(name))
+  );
+  const compileTimeEdgeNames = new Set(
+    Object.keys(graph.edges).filter((name) => !runtimeEdgeNames.has(name))
+  );
+  for (const name of namesSet) {
+    if (compileTimeNodeNames.has(name)) {
+      throw new RemoveCompileTimeKindError(name, "node", graph.id);
+    }
+    if (compileTimeEdgeNames.has(name)) {
+      throw new RemoveCompileTimeKindError(name, "edge", graph.id);
+    }
+  }
+  const removedNodeKinds = [...namesSet].filter(
+    (name) => runtimeNodeNames.has(name)
+  );
+  const explicitlyRemovedEdgeKinds = [...namesSet].filter(
+    (name) => runtimeEdgeNames.has(name)
+  );
+  const referentsByKind = buildCompileTimeReferentIndex(
+    graph,
+    runtimeEdgeNames
+  );
+  for (const kindName of removedNodeKinds) {
+    const referents = referentsByKind.get(kindName);
+    if (referents !== void 0 && referents.length > 0) {
+      throw new KindHasReferentsError(kindName, referents, graph.id);
+    }
+  }
+  if (document === void 0) {
+    return {
+      document: void 0,
+      removedNodeKinds: [],
+      removedEdgeKinds: []
+    };
+  }
+  const removedNodeKindsSet = new Set(removedNodeKinds);
+  const explicitlyRemovedEdgeKindsSet = new Set(explicitlyRemovedEdgeKinds);
+  const cascadeEdges = /* @__PURE__ */ new Set();
+  const updatedEdges = {};
+  for (const [edgeName, edgeDocument] of Object.entries(document.edges ?? {})) {
+    if (explicitlyRemovedEdgeKindsSet.has(edgeName)) {
+      cascadeEdges.add(edgeName);
+      continue;
+    }
+    const newFrom = edgeDocument.from.filter(
+      (kind) => !removedNodeKindsSet.has(kind)
+    );
+    const newTo = edgeDocument.to.filter(
+      (kind) => !removedNodeKindsSet.has(kind)
+    );
+    if (newFrom.length === 0 || newTo.length === 0) {
+      cascadeEdges.add(edgeName);
+      continue;
+    }
+    updatedEdges[edgeName] = {
+      ...edgeDocument,
+      from: newFrom,
+      to: newTo
+    };
+  }
+  const updatedNodes = {};
+  for (const [nodeName, nodeDocument] of Object.entries(document.nodes ?? {})) {
+    if (removedNodeKindsSet.has(nodeName)) continue;
+    updatedNodes[nodeName] = nodeDocument;
+  }
+  const survivingOntology = (document.ontology ?? []).filter(
+    (relation) => !removedNodeKindsSet.has(relation.from) && !removedNodeKindsSet.has(relation.to)
+  );
+  const allRemovedKinds = /* @__PURE__ */ new Set([
+    ...removedNodeKindsSet,
+    ...cascadeEdges,
+    ...explicitlyRemovedEdgeKindsSet
+  ]);
+  const survivingIndexes = (document.indexes ?? []).filter(
+    (index) => !allRemovedKinds.has(index.kind)
+  );
+  const newDocument = Object.freeze({
+    ...document.version === void 0 ? {} : { version: document.version },
+    ...Object.keys(updatedNodes).length === 0 ? {} : { nodes: updatedNodes },
+    ...Object.keys(updatedEdges).length === 0 ? {} : { edges: updatedEdges },
+    ...survivingOntology.length === 0 ? {} : { ontology: survivingOntology },
+    ...survivingIndexes.length === 0 ? {} : { indexes: survivingIndexes }
+  });
+  return {
+    document: newDocument,
+    removedNodeKinds,
+    removedEdgeKinds: [
+      ...explicitlyRemovedEdgeKinds,
+      ...[...cascadeEdges].filter(
+        (name) => !explicitlyRemovedEdgeKindsSet.has(name)
+      )
+    ]
+  };
+}
+function stripGraphExtension(graph) {
+  const document = graph.extension;
+  if (document === void 0) return graph;
+  const { nodes: runtimeNodeNames, edges: runtimeEdgeNames } = extensionKindNames(document);
+  const runtimeOntologyKeys = buildGraphExtensionOntologyKeySet(document);
+  const compileNodes = {};
+  for (const [name, registration] of Object.entries(graph.nodes)) {
+    if (runtimeNodeNames.has(name)) continue;
+    compileNodes[name] = registration;
+  }
+  const compileEdges = {};
+  for (const [name, registration] of Object.entries(graph.edges)) {
+    if (runtimeEdgeNames.has(name)) continue;
+    compileEdges[name] = registration;
+  }
+  const compileOntology = graph.ontology.filter(
+    (relation) => !runtimeOntologyKeys.has(compileTimeOntologyKey(relation))
+  );
+  const compileIndexes = (graph.indexes ?? []).filter(
+    (index) => index.origin !== "runtime"
+  );
+  return Object.freeze({
+    ...graph,
+    nodes: compileNodes,
+    edges: compileEdges,
+    ontology: compileOntology,
+    indexes: compileIndexes.length === 0 ? void 0 : compileIndexes,
+    extension: void 0
+  });
+}
+function buildCompileTimeReferentIndex(graph, runtimeEdgeNames) {
+  const index = /* @__PURE__ */ new Map();
+  const append = (kindName, referent) => {
+    const existing = index.get(kindName);
+    if (existing === void 0) index.set(kindName, [referent]);
+    else existing.push(referent);
+  };
+  for (const [edgeName, registration] of Object.entries(graph.edges)) {
+    if (runtimeEdgeNames.has(edgeName)) continue;
+    const reg = registration;
+    const referent = {
+      type: "compile-time-edge",
+      name: edgeName
+    };
+    const seen = /* @__PURE__ */ new Set();
+    for (const endpoint of reg.from ?? []) {
+      if (seen.has(endpoint.kind)) continue;
+      seen.add(endpoint.kind);
+      append(endpoint.kind, referent);
+    }
+    for (const endpoint of reg.to ?? []) {
+      if (seen.has(endpoint.kind)) continue;
+      seen.add(endpoint.kind);
+      append(endpoint.kind, referent);
+    }
+  }
+  const runtimeOntologyKeys = buildGraphExtensionOntologyKeySet(
+    graph.extension
+  );
+  for (const relation of graph.ontology) {
+    if (runtimeOntologyKeys.has(compileTimeOntologyKey(relation))) continue;
+    const fromName = getTypeName(relation.from);
+    const toName = getTypeName(relation.to);
+    const referent = {
+      type: "compile-time-ontology",
+      name: `${relation.metaEdge.name}(${fromName}, ${toName})`
+    };
+    append(fromName, referent);
+    if (toName !== fromName) append(toName, referent);
+  }
+  return index;
+}
+
 // src/registry/validate-implies.ts
 function validateImpliesEndpointCompatibility(edgeEndpoints, registry) {
   for (const [impliedEdgeKind, impliedEndpoints] of edgeEndpoints) {
@@ -2607,7 +2784,8 @@ async function loadAndMergeGraphExtensionDocument(backend, graph) {
 }
 function mergeStoredGraphExtension(graph, activeRow) {
   const storedSchema = parseSerializedSchema(activeRow.schema_doc);
-  const merged = storedSchema.extension === void 0 ? graph : mergeGraphExtension(graph, storedSchema.extension);
+  const compileTimeGraph = stripGraphExtension(graph);
+  const merged = storedSchema.extension === void 0 ? compileTimeGraph : mergeGraphExtension(compileTimeGraph, storedSchema.extension);
   return {
     graph: applyDeprecatedKinds(merged, storedSchema.deprecatedKinds),
     storedSchema
@@ -2681,8 +2859,11 @@ async function ensureSchema(backend, graph, options) {
   }
   const actions = getMigrationActions(diff);
   if (throwOnBreaking) {
+    const removesKind = [...diff.nodes, ...diff.edges].some(
+      (change) => change.type === "removed"
+    );
     throw new MigrationError(
-      `Schema migration required: ${diff.summary}. ${actions.length} migration action(s) needed. Use getSchemaChanges() to review, then migrateSchema() to apply.`,
+      `Schema migration required: ${diff.summary}. ${actions.length} migration action(s) needed. Use getSchemaChanges() to review, then migrateSchema() to apply.` + (removesKind ? ` This diff removes a kind: migrateSchema() refuses to drop one that still holds rows, so export or delete those rows first and retry.` : ""),
       {
         graphId: graph.id,
         fromVersion: activeSchema.version,
@@ -2786,26 +2967,91 @@ async function initializeSchema(backend, graph) {
     schemaDoc: schema
   });
 }
-async function migrateSchema(backend, graph, currentVersion) {
-  const committed = await commitNewSchemaVersion(
+async function migrateSchema(backend, graph, currentVersion, options) {
+  const {
+    graph: target,
+    storedSchema,
+    activeRow
+  } = await loadAndMergeGraphExtensionDocument(backend, graph);
+  if (activeRow !== void 0 && activeRow.version !== currentVersion) {
+    throw new StaleVersionError({
+      graphId: graph.id,
+      expected: currentVersion,
+      actual: activeRow.version
+    });
+  }
+  const dropped = storedSchema === void 0 ? [] : [
+    ...droppedKinds(storedSchema.nodes, getNodeKinds(target), "node"),
+    ...droppedKinds(storedSchema.edges, getEdgeKinds(target), "edge")
+  ];
+  const committed = dropped.length > 0 && options?.discardDroppedKindRows !== true ? await commitDroppedKindsOnlyWhenEmpty(
+    backend,
+    target,
+    currentVersion,
+    dropped
+  ) : await commitNewSchemaVersion(backend, target, currentVersion);
+  return committed.version;
+}
+async function commitDroppedKindsOnlyWhenEmpty(backend, graph, currentVersion, dropped) {
+  const result = await commitNewSchemaVersionIfKindsEmpty(
     backend,
     graph,
-    currentVersion
+    currentVersion,
+    dropped
+  );
+  if (result.status === "committed") return result.row;
+  throwPopulatedKindRemovalError(graph.id, currentVersion, result.kinds);
+}
+function throwPopulatedKindRemovalError(graphId, currentVersion, populated) {
+  const named = populated.map((entry) => `${entry.entity} "${entry.kind}" (${String(entry.count)})`).join(", ");
+  throw new MigrationError(
+    `Refusing to commit a schema for graph "${graphId}" that drops kinds still holding rows: ${named}. Committing would make those rows unreachable, and the next materializeRemovals() would delete them. Export or delete those rows, then retry. Pass { discardDroppedKindRows: true } if losing them is the intent.`,
+    {
+      graphId,
+      fromVersion: currentVersion,
+      toVersion: currentVersion + 1,
+      reason: "kind-removal",
+      droppedKinds: {
+        nodes: populated.filter((entry) => entry.entity === "node").map((entry) => entry.kind),
+        edges: populated.filter((entry) => entry.entity === "edge").map((entry) => entry.kind)
+      }
+    }
   );
-  return committed.version;
+}
+function droppedKinds(committed, present, entity) {
+  const kinds = new Set(present);
+  return Object.keys(committed).filter((name) => !kinds.has(name)).toSorted().map((kind) => ({ kind, entity }));
 }
 async function commitNewSchemaVersion(backend, graph, currentVersion) {
+  const params = await buildNewSchemaVersionCommit(graph, currentVersion);
+  return backend.commitSchemaVersion(params);
+}
+async function commitNewSchemaVersionIfKindsEmpty(backend, graph, currentVersion, probes) {
+  const params = await buildNewSchemaVersionCommit(graph, currentVersion);
+  const commitIfKindsEmpty = backend.commitSchemaVersionIfKindsEmpty;
+  if (commitIfKindsEmpty === void 0) {
+    throw new ConfigurationError(
+      "This backend cannot atomically fence entity writes while checking schema kind emptiness.",
+      {
+        code: "SCHEMA_KIND_EMPTINESS_FENCE_UNSUPPORTED",
+        graphId: graph.id
+      }
+    );
+  }
+  return commitIfKindsEmpty(params, probes);
+}
+async function buildNewSchemaVersionCommit(graph, currentVersion) {
   buildKindRegistry(graph);
   const newVersion = currentVersion + 1;
   const schema = serializeSchema(graph, newVersion);
   const hash = await computeSchemaHash(schema);
-  return backend.commitSchemaVersion({
+  return {
     graphId: graph.id,
     expected: { kind: "active", version: currentVersion },
     version: newVersion,
     schemaHash: hash,
     schemaDoc: schema
-  });
+  };
 }
 async function rollbackSchema(backend, graphId, targetVersion) {
   const activeRow = await backend.getActiveSchema(graphId);
@@ -2855,6 +3101,6 @@ async function getCommittedSchemaVersion(backend, graphId) {
   return row?.version;
 }
 
-export { KindRegistry, applyDeprecatedKinds, assertSchemaCurrent, broader, buildGraphExtensionOntologyKeySet, buildKindRegistry, classifySchemaChanges, commitNewSchemaVersion, compileTimeOntologyKey, computeSchemaDiff, computeSchemaHash, core, deserializeWherePredicate, differentFrom, disjointWith, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getCommittedSchemaVersion, getMigrationActions, getSchemaChanges, hasPart, implies, initializeSchema, inverseOf, isBackwardsCompatible, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, loadAndVerifyGraph, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, relatedTo, requiresMigration, rollbackSchema, sameAs, serializeIndexDeclaration, serializeSchema, serializeSchemaProperties, subClassOf, validateImpliesEndpointCompatibility };
-//# sourceMappingURL=chunk-RAWG2FEU.js.map
-//# sourceMappingURL=chunk-RAWG2FEU.js.map
+export { KindRegistry, applyDeprecatedKinds, assertSchemaCurrent, broader, buildGraphExtensionOntologyKeySet, buildKindRegistry, classifySchemaChanges, commitNewSchemaVersion, commitNewSchemaVersionIfKindsEmpty, compileTimeOntologyKey, computeSchemaDiff, computeSchemaHash, core, deserializeWherePredicate, differentFrom, disjointWith, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getCommittedSchemaVersion, getMigrationActions, getSchemaChanges, hasPart, implies, initializeSchema, inverseOf, isBackwardsCompatible, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, loadAndVerifyGraph, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, planRemovals, relatedTo, requiresMigration, rollbackSchema, sameAs, serializeIndexDeclaration, serializeSchema, serializeSchemaProperties, stripGraphExtension, subClassOf, validateImpliesEndpointCompatibility };
+//# sourceMappingURL=chunk-BEFM74L2.js.map
+//# sourceMappingURL=chunk-BEFM74L2.js.map