@canon-protocol/sdk 8.5.0 → 8.6.0

package/dist/graph/GraphBuilder.js

@@ -1,5 +1,3 @@
-import { CanonObjectParser } from '../parsing/CanonObjectParser.js';
-import { ResourceTypeClassifier } from '../ctl/ResourceTypeClassifier.js';
 /**
  * Node types in a Canon graph.
  */
@@ -56,61 +54,60 @@ export class GraphBuilder {
      * This is the main entry point — handles imports, resolution, and classification.
      */
     static async buildFromRepository(repository) {
-        const objectParser = new CanonObjectParser();
-        const canons = await objectParser.parseCanons(repository);
+        const documents = await repository.getAllDocumentsAsync();
         const nodes = [];
         const edges = [];
         const knownClassNames = new Set();
-        // First pass: identify all classes
-        for (const canon of canons) {
-            const subject = canon;
-            if (!subject.name)
-                continue;
-            if (ResourceTypeClassifier.isClassType(subject)) {
-                knownClassNames.add(subject.name);
+        // Build a map from "publisher/packageName" to the full namespace string for alias resolution
+        const packageToNamespace = new Map();
+        for (const document of documents) {
+            const ns = document.metadata.namespace_;
+            if (ns) {
+                const namespace = ns.toString();
+                const packageKey = `${ns.publisher}/${ns.package_}`;
+                packageToNamespace.set(packageKey, namespace);
             }
         }
-        // Second pass: build nodes and edges
-        for (const canon of canons) {
-            const subject = canon;
-            if (!subject.name)
-                continue;
-            const nodeType = classifyNode(subject, knownClassNames);
-            const nodeId = subject.namespace
-                ? `${subject.namespace}/${subject.name}`
-                : subject.name;
-            const properties = {};
-            const entity = subject.entity ?? {};
-            // Extract properties from the raw entity for metadata
-            for (const [key, value] of Object.entries(entity)) {
-                if (key === 'type')
-                    continue; // handled by nodeType
-                properties[key] = value;
+        // First pass: identify all classes across all documents
+        for (const document of documents) {
+            for (const [name, entity] of Object.entries(document.body)) {
+                const type = entity?.type;
+                if (!type)
+                    continue;
+                if (isClassTypeName(type)) {
+                    knownClassNames.add(name);
+                }
             }
-            // Also extract from statements if available
-            if (subject.statement) {
-                for (const stmt of subject.statement) {
-                    const predName = stmt.predicate?.subject?.name;
-                    if (!predName || predName === 'type')
+        }
+        // Second pass: build graph
+        for (const document of documents) {
+            const namespace = document.metadata.namespace_
+                ? document.metadata.namespace_.toString()
+                : '';
+            const aliasMap = buildAliasMap(document, packageToNamespace);
+            for (const [name, entity] of Object.entries(document.body)) {
+                if (!entity || typeof entity !== 'object')
+                    continue;
+                const typeName = entity.type;
+                const nodeType = classifyByTypeName(typeName, name, knownClassNames);
+                const nodeId = namespace ? `${namespace}/${name}` : name;
+                const properties = {};
+                for (const [key, value] of Object.entries(entity)) {
+                    if (key === 'type')
                         continue;
-                    const obj = stmt.object;
-                    if (obj?.subject?.name) {
-                        properties[predName] = obj.subject.name;
-                    }
-                    else if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') {
-                        properties[predName] = obj;
+                    if (typeof value !== 'object' || value === null) {
+                        properties[key] = value;
                     }
                 }
+                nodes.push({
+                    id: nodeId,
+                    label: entity.label ?? name,
+                    type: nodeType,
+                    namespace,
+                    properties,
+                });
+                extractEdges(nodeId, entity, nodeType, knownClassNames, edges, namespace, aliasMap);
             }
-            nodes.push({
-                id: nodeId,
-                label: entity.label ?? subject.name,
-                type: nodeType,
-                namespace: subject.namespace ?? '',
-                properties,
-            });
-            // Extract edges from entity properties
-            extractEdges(nodeId, entity, nodeType, knownClassNames, edges, subject.namespace ?? '');
         }
         return { nodes, edges };
     }
@@ -134,6 +131,8 @@ export class GraphBuilder {
                 knownClassNames.add(name);
             }
         }
+        // Build partial alias map from document imports
+        const aliasMap = buildAliasMap(document);
         // Second pass: build graph
         for (const [name, entity] of Object.entries(document.body)) {
             if (!entity || typeof entity !== 'object')
@@ -156,27 +155,27 @@ export class GraphBuilder {
                 namespace,
                 properties,
             });
-            extractEdges(nodeId, entity, nodeType, knownClassNames, edges, namespace);
+            extractEdges(nodeId, entity, nodeType, knownClassNames, edges, namespace, aliasMap);
         }
         return { nodes, edges };
     }
 }
 // --- Helpers ---
-function classifyNode(subject, knownClassNames) {
-    const s = subject;
-    if (ResourceTypeClassifier.isClassType(s))
-        return NodeType.Class;
-    if (ResourceTypeClassifier.isObjectPropertyType(s))
-        return NodeType.ObjectProperty;
-    if (ResourceTypeClassifier.isDatatypePropertyType(s))
-        return NodeType.DatatypeProperty;
-    if (ResourceTypeClassifier.isAnnotationPropertyType(s))
-        return NodeType.AnnotationProperty;
-    if (ResourceTypeClassifier.isDatatypeType(s))
-        return NodeType.Datatype;
-    if (ResourceTypeClassifier.isInstanceOfKnownClass(s, knownClassNames))
-        return NodeType.Instance;
-    return NodeType.Unknown;
+function buildAliasMap(document, packageToNamespace) {
+    const aliasMap = new Map();
+    if (document.metadata?.imports) {
+        for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                const alias = import_.alias ?? import_.packageName;
+                const packageKey = `${publisher}/${import_.packageName}`;
+                // Use resolved namespace from repository if available, otherwise approximate from import
+                const targetNamespace = packageToNamespace?.get(packageKey)
+                    ?? `${publisher}/${import_.packageName}@${import_.version}`;
+                aliasMap.set(alias, targetNamespace);
+            }
+        }
+    }
+    return aliasMap;
 }
 function isClassTypeName(typeName) {
     const name = typeName.split('.').pop() ?? typeName;
@@ -198,13 +197,13 @@ function classifyByTypeName(typeName, entityName, knownClassNames) {
             return NodeType.Unknown;
     }
 }
-function extractEdges(sourceId, entity, nodeType, knownClassNames, edges, namespace) {
+function extractEdges(sourceId, entity, nodeType, knownClassNames, edges, namespace, aliasMap) {
     const type = entity.type;
     // subClassOf → SubClassOf edge
     if (entity.subClassOf && typeof entity.subClassOf === 'string') {
         edges.push({
             source: sourceId,
-            target: resolveLocalId(entity.subClassOf, namespace),
+            target: resolveLocalId(entity.subClassOf, namespace, aliasMap),
             type: EdgeType.SubClassOf,
             label: 'subClassOf',
         });
@@ -213,7 +212,7 @@ function extractEdges(sourceId, entity, nodeType, knownClassNames, edges, namesp
     if (entity.subPropertyOf && typeof entity.subPropertyOf === 'string') {
         edges.push({
             source: sourceId,
-            target: resolveLocalId(entity.subPropertyOf, namespace),
+            target: resolveLocalId(entity.subPropertyOf, namespace, aliasMap),
             type: EdgeType.SubPropertyOf,
             label: 'subPropertyOf',
         });
@@ -222,7 +221,7 @@ function extractEdges(sourceId, entity, nodeType, knownClassNames, edges, namesp
     if (entity.domain && typeof entity.domain === 'string') {
         edges.push({
             source: sourceId,
-            target: resolveLocalId(entity.domain, namespace),
+            target: resolveLocalId(entity.domain, namespace, aliasMap),
             type: EdgeType.Domain,
             label: 'domain',
         });
@@ -231,7 +230,7 @@ function extractEdges(sourceId, entity, nodeType, knownClassNames, edges, namesp
     if (entity.range && typeof entity.range === 'string') {
         edges.push({
             source: sourceId,
-            target: resolveLocalId(entity.range, namespace),
+            target: resolveLocalId(entity.range, namespace, aliasMap),
             type: EdgeType.Range,
             label: 'range',
         });
@@ -241,7 +240,7 @@ function extractEdges(sourceId, entity, nodeType, knownClassNames, edges, namesp
         const typeName = type.split('.').pop() ?? type;
         edges.push({
             source: sourceId,
-            target: resolveLocalId(typeName, namespace),
+            target: resolveLocalId(typeName, namespace, aliasMap),
             type: EdgeType.InstanceOf,
             label: 'type',
         });
@@ -261,19 +260,31 @@ function extractEdges(sourceId, entity, nodeType, knownClassNames, edges, namesp
         const rangeStr = typeof entity.range === 'string' ? entity.range : null;
         if (domainStr && rangeStr) {
             edges.push({
-                source: resolveLocalId(domainStr, namespace),
-                target: resolveLocalId(rangeStr, namespace),
+                source: resolveLocalId(domainStr, namespace, aliasMap),
+                target: resolveLocalId(rangeStr, namespace, aliasMap),
                 type: EdgeType.ObjectRelationship,
                 label: entity.label ?? sourceId.split('/').pop() ?? '',
             });
         }
     }
 }
-function resolveLocalId(name, namespace) {
-    // If name contains a slash, it's already qualified
+function resolveLocalId(name, namespace, aliasMap) {
+    // Already qualified with a slash — return as-is
     if (name.includes('/'))
         return name;
-    // If it contains a dot (alias.Entity), just use the entity part for local resolution
-    const entityName = name.includes('.') ? name : name;
-    return namespace ? `${namespace}/${entityName}` : entityName;
+    // Handle aliased references (e.g., "sdg.gdpr")
+    if (name.includes('.')) {
+        const dotIndex = name.indexOf('.');
+        const alias = name.substring(0, dotIndex);
+        const entityName = name.substring(dotIndex + 1);
+        if (aliasMap) {
+            const targetNamespace = aliasMap.get(alias);
+            if (targetNamespace) {
+                return `${targetNamespace}/${entityName}`;
+            }
+        }
+        // Fallback: use entity name with local namespace
+        return namespace ? `${namespace}/${entityName}` : entityName;
+    }
+    return namespace ? `${namespace}/${name}` : name;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canon-protocol/sdk",
-  "version": "8.5.0",
+  "version": "8.6.0",
   "description": "Canon Protocol SDK - Document repository and parsing implementations for TypeScript",
   "type": "module",
   "main": "./dist/index.js",
@@ -66,7 +66,7 @@
     "yaml-parser"
   ],
   "dependencies": {
-    "@canon-protocol/types": "^8.5.0",
+    "@canon-protocol/types": "^8.6.0",
     "ignore": "^7.0.5",
     "js-yaml": "^4.1.0"
   },