@nicia-ai/typegraph 0.34.0 → 0.35.0

package/dist/{chunk-K2TGS3EN.js → chunk-K3PPLHY7.js}

@@ -1,13 +1,13 @@
 import { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
-import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND, getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-CHXTTSC6.js';
-import { defineNodeIndex, defineEdgeIndex } from './chunk-4DIBPQNJ.js';
-import { sha256Hex } from './chunk-K34OPSJK.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, assertJsonValue, isReachable, computeTransitiveClosure, invertClosure, LEGACY_GRAPH_EXTENSION_VERSION, unwrap, validateGraphExtension, KindCollisionError, GraphExtensionUnresolvedEndpointError, assertSchemaKeysAreFree, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS } from './chunk-ZURTTSCM.js';
-import { nowIso } from './chunk-XXVEULWX.js';
-import { isMissingTableError } from './chunk-2MRAX3UE.js';
-import { embedding, searchable } from './chunk-Z5XBMDXU.js';
+import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND, getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-QWEUYILR.js';
+import { defineNodeIndex, defineEdgeIndex } from './chunk-OR5ZA5WP.js';
+import { sha256Hex } from './chunk-W63OVYY4.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, assertJsonValue, isReachable, LEGACY_GRAPH_EXTENSION_VERSION, unwrap, validateGraphExtension, KindCollisionError, GraphExtensionUnresolvedEndpointError, computeTransitiveClosure, invertClosure } from './chunk-QOTI55H7.js';
+import { assertSchemaKeysAreFree, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS } from './chunk-RGPG7EOJ.js';
+import { nowIso, isMissingTableError } from './chunk-I7ZUZKFD.js';
+import { embedding, searchable } from './chunk-KBGQIPRQ.js';
 import { compactUndefined, freezeDeep } from './chunk-ITE4IXAK.js';
-import { ConfigurationError, KindNotFoundError, DatabaseOperationError, MigrationError, ValidationError } from './chunk-TQOYM4LN.js';
+import { ConfigurationError, KindNotFoundError, DatabaseOperationError, MigrationError } from './chunk-MP2JQKSG.js';
 import { z } from 'zod';
 
 // src/core/node.ts
@@ -1025,6 +1025,17 @@ var KindRegistry = class {
     if (concreteKind === targetKind) return true;
     return this.isSubClassOf(concreteKind, targetKind);
   }
+  /**
+   * Checks if a concrete kind is assignable to at least one of the given
+   * target kinds. Shared by every "is this kind usable where one of these
+   * kinds is expected" check (edge endpoint validation, ontology relation
+   * endpoint compatibility) so they can't independently drift.
+   */
+  isAssignableToAny(concreteKind, targetKinds) {
+    return targetKinds.some(
+      (targetKind) => this.isAssignableTo(concreteKind, targetKind)
+    );
+  }
   /**
    * Validates that a kind exists in the registry.
    */
@@ -1312,6 +1323,16 @@ function serializeNodeIndexDeclaration(declaration) {
     unique: declaration.unique,
     scope: declaration.scope,
     where: declaration.where,
+    // `method: "btree"` is canonicalized by absence, like `origin` below.
+    ...declaration.method === void 0 ? {} : { method: declaration.method },
+    // `keySystemColumns: []` is canonicalized by absence, same rule. Checked
+    // against length, not just `undefined` — `NodeIndexDeclaration` is
+    // exported and `defineGraph` accepts pre-built declarations directly
+    // (bypassing `defineNodeIndex`'s own canonicalization and the
+    // `nodeIndexDeclarationZod` parse boundary, which rejects an explicit
+    // `[]` via `.min(1)`), so an in-memory declaration can still carry a
+    // present-but-empty array that must canonicalize to absent here.
+    ...declaration.keySystemColumns === void 0 || declaration.keySystemColumns.length === 0 ? {} : { keySystemColumns: declaration.keySystemColumns },
     // `origin: "compile-time"` is the default and is omitted from the
     // canonical form (absence == compile-time). Only `runtime` is
     // emitted explicitly so the restart loader can route the declaration
@@ -1332,6 +1353,8 @@ function serializeEdgeIndexDeclaration(declaration) {
     unique: declaration.unique,
     scope: declaration.scope,
     where: declaration.where,
+    // `method: "btree"` is canonicalized by absence, like `origin`.
+    ...declaration.method === void 0 ? {} : { method: declaration.method },
     ...declaration.origin === "runtime" ? { origin: "runtime" } : {}
   };
 }
@@ -1507,11 +1530,7 @@ function mapToRecord(map) {
   return result;
 }
 function mapToSimpleRecord(map) {
-  const result = {};
-  for (const [key, value] of map) {
-    result[key] = value;
-  }
-  return result;
+  return Object.fromEntries(map);
 }
 var SCHEMA_PROPERTIES_CACHE = /* @__PURE__ */ new WeakMap();
 function serializeSchemaProperties(schema) {
@@ -2075,6 +2094,94 @@ function resolveOntologyEndpoints(relation, nodeKinds) {
   const to = typeof relation.to === "string" ? nodeKinds.get(relation.to) ?? relation.to : relation.to;
   return { ...relation, from, to };
 }
+
+// src/registry/validate-implies.ts
+function validateImpliesEndpointCompatibility(edgeEndpoints, registry) {
+  for (const [impliedEdgeKind, impliedEndpoints] of edgeEndpoints) {
+    for (const implyingEdgeKind of registry.expandImplyingEdges(
+      impliedEdgeKind
+    )) {
+      if (implyingEdgeKind === impliedEdgeKind) continue;
+      const implyingEndpoints = edgeEndpoints.get(implyingEdgeKind);
+      if (!implyingEndpoints) continue;
+      assertEndpointCompatible(
+        "from",
+        implyingEdgeKind,
+        implyingEndpoints.from,
+        impliedEdgeKind,
+        impliedEndpoints.from,
+        registry
+      );
+      assertEndpointCompatible(
+        "to",
+        implyingEdgeKind,
+        implyingEndpoints.to,
+        impliedEdgeKind,
+        impliedEndpoints.to,
+        registry
+      );
+    }
+  }
+}
+function assertEndpointCompatible(side, implyingEdgeKind, implyingKinds, impliedEdgeKind, impliedKinds, registry) {
+  const incompatibleKinds = implyingKinds.filter(
+    (kind) => !registry.isAssignableToAny(kind, impliedKinds)
+  );
+  if (incompatibleKinds.length === 0) return;
+  throw new ConfigurationError(
+    `implies("${implyingEdgeKind}", "${impliedEdgeKind}") is endpoint-incompatible: ${side} kind(s) [${incompatibleKinds.join(", ")}] declared on "${implyingEdgeKind}" cannot be assigned to any of "${impliedEdgeKind}"'s ${side} kind(s) [${impliedKinds.join(", ")}].`,
+    {
+      metaEdge: META_EDGE_IMPLIES,
+      implyingEdge: implyingEdgeKind,
+      impliedEdge: impliedEdgeKind,
+      endpoint: side,
+      incompatibleKinds,
+      allowedKinds: impliedKinds
+    },
+    {
+      suggestion: `Add a subClassOf relation from each of [${incompatibleKinds.join(", ")}] to one of "${impliedEdgeKind}"'s ${side} kind(s) [${impliedKinds.join(", ")}], narrow "${implyingEdgeKind}"'s ${side} declaration to exclude [${incompatibleKinds.join(", ")}], or remove implies("${implyingEdgeKind}", "${impliedEdgeKind}").`
+    }
+  );
+}
+
+// src/registry/builders.ts
+function buildKindRegistry(graph) {
+  const nodeTypes = extractNodeTypes(graph);
+  const edgeTypes = extractEdgeTypes(graph);
+  const closures = graph.ontology.length > 0 ? computeClosuresFromOntology(graph.ontology) : createEmptyClosures();
+  const registry = new KindRegistry(nodeTypes, edgeTypes, closures);
+  validateImpliesEndpointCompatibility(
+    buildEdgeEndpointKinds(graph.edges),
+    registry
+  );
+  return registry;
+}
+function buildEdgeEndpointKinds(edges) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [kind, registration] of Object.entries(edges)) {
+    result.set(kind, {
+      from: registration.from.map((node) => node.kind),
+      to: registration.to.map((node) => node.kind)
+    });
+  }
+  return result;
+}
+function extractNodeTypes(graph) {
+  const result = /* @__PURE__ */ new Map();
+  for (const typeName of getNodeKinds(graph)) {
+    const registration = graph.nodes[typeName];
+    result.set(typeName, registration.type);
+  }
+  return result;
+}
+function extractEdgeTypes(graph) {
+  const result = /* @__PURE__ */ new Map();
+  for (const typeName of getEdgeKinds(graph)) {
+    const registration = graph.edges[typeName];
+    result.set(typeName, registration.type);
+  }
+  return result;
+}
 var deleteBehaviorZod = z.enum(["restrict", "cascade", "disconnect"]);
 var cardinalityZod = z.enum(["many", "one", "unique", "oneActive"]);
 var endpointExistenceZod = z.enum(["notDeleted", "currentlyValid", "ever"]);
@@ -2124,6 +2231,12 @@ var systemColumnNameZod = z.enum([
   "updated_at",
   "version"
 ]);
+var nodeSystemColumnNameZod = systemColumnNameZod.exclude([
+  "from_kind",
+  "from_id",
+  "to_kind",
+  "to_id"
+]);
 var indexWhereOperandZod = z.discriminatedUnion("__type", [
   z.object({
     __type: z.literal("index_operand_system"),
@@ -2200,7 +2313,13 @@ var indexDeclarationCommonShape = {
 var nodeIndexDeclarationZod = z.object({
   entity: z.literal("node"),
   kind: z.string(),
-  ...indexDeclarationCommonShape
+  ...indexDeclarationCommonShape,
+  // Node-only; canonicalized by absence like `method`, so absent/optional
+  // here matches `defineNodeIndex` only emitting it when non-empty.
+  // `.min(1)` rejects an explicit `[]` at the boundary rather than
+  // silently accepting a present-but-empty array that would have to be
+  // canonicalized away again downstream (see `serializeNodeIndexDeclaration`).
+  keySystemColumns: z.array(nodeSystemColumnNameZod).min(1).optional()
 }).loose();
 var edgeIndexDeclarationZod = z.object({
   entity: z.literal("edge"),
@@ -2599,6 +2718,7 @@ function schemaNotInitializedError(graphId, cause) {
   );
 }
 async function initializeSchema(backend, graph) {
+  buildKindRegistry(graph);
   const schema = serializeSchema(graph, 1);
   const hash = await computeSchemaHash(schema);
   return backend.commitSchemaVersion({
@@ -2618,6 +2738,7 @@ async function migrateSchema(backend, graph, currentVersion) {
   return committed.version;
 }
 async function commitNewSchemaVersion(backend, graph, currentVersion) {
+  buildKindRegistry(graph);
   const newVersion = currentVersion + 1;
   const schema = serializeSchema(graph, newVersion);
   const hash = await computeSchemaHash(schema);
@@ -2660,78 +2781,6 @@ async function getSchemaChanges(backend, graph) {
   return computeSchemaDiff(storedSchema, currentSchema);
 }
 
-// src/errors/validation.ts
-function zodIssuesToValidationIssues(error) {
-  return error.issues.map((issue) => ({
-    path: issue.path.join("."),
-    message: issue.message,
-    code: issue.code
-  }));
-}
-function buildLocationString(context) {
-  if (context.id) {
-    return `${context.kind}/${context.id}`;
-  }
-  return `new ${context.kind}`;
-}
-function validateProps(schema, props, context) {
-  const result = schema.safeParse(props);
-  if (result.success) {
-    return result.data;
-  }
-  const issues = zodIssuesToValidationIssues(result.error);
-  const location = buildLocationString(context);
-  throw new ValidationError(
-    `Invalid ${context.entityType} props for ${location}: ${result.error.message}`,
-    {
-      entityType: context.entityType,
-      kind: context.kind,
-      operation: context.operation,
-      ...context.id !== void 0 && { id: context.id },
-      issues
-    },
-    { cause: result.error }
-  );
-}
-function validateNodeProps(schema, props, context) {
-  return validateProps(schema, props, {
-    entityType: "node",
-    ...context
-  });
-}
-function validateEdgeProps(schema, props, context) {
-  return validateProps(schema, props, {
-    entityType: "edge",
-    ...context
-  });
-}
-function wrapZodError(error, context) {
-  const issues = zodIssuesToValidationIssues(error);
-  const location = buildLocationString(context);
-  return new ValidationError(
-    `Validation failed for ${context.entityType} ${location}: ${error.message}`,
-    {
-      entityType: context.entityType,
-      kind: context.kind,
-      operation: context.operation,
-      ...context.id !== void 0 && { id: context.id },
-      issues
-    },
-    { cause: error }
-  );
-}
-function createValidationError(message, issues, context) {
-  return new ValidationError(message, {
-    ...context?.entityType !== void 0 && {
-      entityType: context.entityType
-    },
-    ...context?.kind !== void 0 && { kind: context.kind },
-    ...context?.operation !== void 0 && { operation: context.operation },
-    ...context?.id !== void 0 && { id: context.id },
-    issues
-  });
-}
-
-export { KindRegistry, META_EDGE_BRAND, applyDeprecatedKinds, assertSchemaCurrent, broader, buildGraphExtensionOntologyKeySet, commitNewSchemaVersion, compileTimeOntologyKey, computeClosuresFromOntology, computeSchemaDiff, computeSchemaHash, core, createEmptyClosures, createValidationError, defineEdge, defineNode, deserializeWherePredicate, differentFrom, disjointWith, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getMigrationActions, getSchemaChanges, getTypeName, hasPart, implies, initializeSchema, inverseOf, isBackwardsCompatible, isMetaEdge, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, loadAndVerifyGraph, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, relatedTo, rollbackSchema, sameAs, serializeSchema, serializeSchemaProperties, subClassOf, validateEdgeProps, validateNodeProps, validateProps, wrapZodError };
-//# sourceMappingURL=chunk-K2TGS3EN.js.map
-//# sourceMappingURL=chunk-K2TGS3EN.js.map
+export { KindRegistry, META_EDGE_BRAND, applyDeprecatedKinds, assertSchemaCurrent, broader, buildGraphExtensionOntologyKeySet, buildKindRegistry, commitNewSchemaVersion, compileTimeOntologyKey, computeSchemaDiff, computeSchemaHash, core, defineEdge, defineNode, deserializeWherePredicate, differentFrom, disjointWith, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getMigrationActions, getSchemaChanges, getTypeName, hasPart, implies, initializeSchema, inverseOf, isBackwardsCompatible, isMetaEdge, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, loadAndVerifyGraph, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, relatedTo, rollbackSchema, sameAs, serializeIndexDeclaration, serializeSchema, serializeSchemaProperties, subClassOf, validateImpliesEndpointCompatibility };
+//# sourceMappingURL=chunk-K3PPLHY7.js.map
+//# sourceMappingURL=chunk-K3PPLHY7.js.map