@semiont/graph 0.2.45 → 0.3.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { components, ResourceUri, UpdateResourceInput, ResourceFilter, CreateAnnotationInternal, AnnotationUri, ResourceId, AnnotationCategory, AnnotationId, GraphConnection, GraphPath, EntityTypeStats, EnvironmentConfig, Logger } from '@semiont/core';
+import { components, ResourceId, UpdateResourceInput, ResourceFilter, CreateAnnotationInternal, AnnotationId, AnnotationCategory, GraphConnection, GraphPath, EntityTypeStats, GraphServiceConfig, Logger } from '@semiont/core';
 
 type ResourceDescriptor$4 = components['schemas']['ResourceDescriptor'];
 type Annotation$4 = components['schemas']['Annotation'];
@@ -7,18 +7,18 @@ interface GraphDatabase {
     disconnect(): Promise<void>;
     isConnected(): boolean;
     createResource(resource: ResourceDescriptor$4): Promise<ResourceDescriptor$4>;
-    getResource(id: ResourceUri): Promise<ResourceDescriptor$4 | null>;
-    updateResource(id: ResourceUri, input: UpdateResourceInput): Promise<ResourceDescriptor$4>;
-    deleteResource(id: ResourceUri): Promise<void>;
+    getResource(id: ResourceId): Promise<ResourceDescriptor$4 | null>;
+    updateResource(id: ResourceId, input: UpdateResourceInput): Promise<ResourceDescriptor$4>;
+    deleteResource(id: ResourceId): Promise<void>;
     listResources(filter: ResourceFilter): Promise<{
         resources: ResourceDescriptor$4[];
         total: number;
     }>;
     searchResources(query: string, limit?: number): Promise<ResourceDescriptor$4[]>;
     createAnnotation(input: CreateAnnotationInternal): Promise<Annotation$4>;
-    getAnnotation(id: AnnotationUri): Promise<Annotation$4 | null>;
-    updateAnnotation(id: AnnotationUri, updates: Partial<Annotation$4>): Promise<Annotation$4>;
-    deleteAnnotation(id: AnnotationUri): Promise<void>;
+    getAnnotation(id: AnnotationId): Promise<Annotation$4 | null>;
+    updateAnnotation(id: AnnotationId, updates: Partial<Annotation$4>): Promise<Annotation$4>;
+    deleteAnnotation(id: AnnotationId): Promise<void>;
     listAnnotations(filter: {
         resourceId?: ResourceId;
         type?: AnnotationCategory;
@@ -31,7 +31,7 @@ interface GraphDatabase {
     getReferences(resourceId: ResourceId): Promise<Annotation$4[]>;
     getEntityReferences(resourceId: ResourceId, entityTypes?: string[]): Promise<Annotation$4[]>;
     getResourceAnnotations(resourceId: ResourceId): Promise<Annotation$4[]>;
-    getResourceReferencedBy(resourceUri: ResourceUri, motivation?: string): Promise<Annotation$4[]>;
+    getResourceReferencedBy(resourceId: ResourceId, motivation?: string): Promise<Annotation$4[]>;
     getResourceConnections(resourceId: ResourceId): Promise<GraphConnection[]>;
     findPath(fromResourceId: ResourceId, toResourceId: ResourceId, maxDepth?: number): Promise<GraphPath[]>;
     getEntityTypeStats(): Promise<EntityTypeStats[]>;
@@ -73,8 +73,8 @@ interface GraphDatabaseConfig {
     janusStorageBackend?: 'cassandra' | 'hbase' | 'berkeleydb';
     janusIndexBackend?: 'elasticsearch' | 'solr' | 'lucene';
 }
-declare function createGraphDatabase(config: GraphDatabaseConfig, envConfig: EnvironmentConfig): GraphDatabase;
-declare function getGraphDatabase(envConfig: EnvironmentConfig): Promise<GraphDatabase>;
+declare function createGraphDatabase(config: GraphDatabaseConfig): GraphDatabase;
+declare function getGraphDatabase(graphConfig: GraphServiceConfig): Promise<GraphDatabase>;
 declare function closeGraphDatabase(): Promise<void>;
 
 type ResourceDescriptor$3 = components['schemas']['ResourceDescriptor'];
@@ -98,18 +98,18 @@ declare class Neo4jGraphDatabase implements GraphDatabase {
     private getSession;
     private ensureSchemaExists;
     createResource(resource: ResourceDescriptor$3): Promise<ResourceDescriptor$3>;
-    getResource(id: ResourceUri): Promise<ResourceDescriptor$3 | null>;
-    updateResource(id: ResourceUri, input: UpdateResourceInput): Promise<ResourceDescriptor$3>;
-    deleteResource(id: ResourceUri): Promise<void>;
+    getResource(id: ResourceId): Promise<ResourceDescriptor$3 | null>;
+    updateResource(id: ResourceId, input: UpdateResourceInput): Promise<ResourceDescriptor$3>;
+    deleteResource(id: ResourceId): Promise<void>;
     listResources(filter: ResourceFilter): Promise<{
         resources: ResourceDescriptor$3[];
         total: number;
     }>;
     searchResources(query: string, limit?: number): Promise<ResourceDescriptor$3[]>;
     createAnnotation(input: CreateAnnotationInternal): Promise<Annotation$3>;
-    getAnnotation(id: AnnotationUri): Promise<Annotation$3 | null>;
-    updateAnnotation(id: AnnotationUri, updates: Partial<Annotation$3>): Promise<Annotation$3>;
-    deleteAnnotation(id: AnnotationUri): Promise<void>;
+    getAnnotation(id: AnnotationId): Promise<Annotation$3 | null>;
+    updateAnnotation(id: AnnotationId, updates: Partial<Annotation$3>): Promise<Annotation$3>;
+    deleteAnnotation(id: AnnotationId): Promise<void>;
     listAnnotations(filter: {
         resourceId?: ResourceId;
         type?: AnnotationCategory;
@@ -122,7 +122,7 @@ declare class Neo4jGraphDatabase implements GraphDatabase {
     getReferences(resourceId: ResourceId): Promise<Annotation$3[]>;
     getEntityReferences(resourceId: ResourceId, entityTypes?: string[]): Promise<Annotation$3[]>;
     getResourceAnnotations(resourceId: ResourceId): Promise<Annotation$3[]>;
-    getResourceReferencedBy(resourceUri: ResourceUri, motivation?: string): Promise<Annotation$3[]>;
+    getResourceReferencedBy(resourceId: ResourceId, motivation?: string): Promise<Annotation$3[]>;
     getResourceConnections(resourceId: ResourceId): Promise<GraphConnection[]>;
     findPath(fromResourceId: string, toResourceId: string, maxDepth?: number): Promise<GraphPath[]>;
     getEntityTypeStats(): Promise<EntityTypeStats[]>;
@@ -175,18 +175,18 @@ declare class NeptuneGraphDatabase implements GraphDatabase {
     disconnect(): Promise<void>;
     isConnected(): boolean;
     createResource(resource: ResourceDescriptor$2): Promise<ResourceDescriptor$2>;
-    getResource(id: ResourceUri): Promise<ResourceDescriptor$2 | null>;
-    updateResource(id: ResourceUri, input: UpdateResourceInput): Promise<ResourceDescriptor$2>;
-    deleteResource(id: ResourceUri): Promise<void>;
+    getResource(id: ResourceId): Promise<ResourceDescriptor$2 | null>;
+    updateResource(id: ResourceId, input: UpdateResourceInput): Promise<ResourceDescriptor$2>;
+    deleteResource(id: ResourceId): Promise<void>;
     listResources(filter: ResourceFilter): Promise<{
         resources: ResourceDescriptor$2[];
         total: number;
     }>;
     searchResources(query: string, limit?: number): Promise<ResourceDescriptor$2[]>;
     createAnnotation(input: CreateAnnotationInternal): Promise<Annotation$2>;
-    getAnnotation(id: AnnotationUri): Promise<Annotation$2 | null>;
-    updateAnnotation(id: AnnotationUri, updates: Partial<Annotation$2>): Promise<Annotation$2>;
-    deleteAnnotation(id: AnnotationUri): Promise<void>;
+    getAnnotation(id: AnnotationId): Promise<Annotation$2 | null>;
+    updateAnnotation(id: AnnotationId, updates: Partial<Annotation$2>): Promise<Annotation$2>;
+    deleteAnnotation(id: AnnotationId): Promise<void>;
     listAnnotations(filter: {
         resourceId?: ResourceId;
         type?: AnnotationCategory;
@@ -199,7 +199,7 @@ declare class NeptuneGraphDatabase implements GraphDatabase {
     getReferences(resourceId: ResourceId): Promise<Annotation$2[]>;
     getEntityReferences(resourceId: ResourceId, entityTypes?: string[]): Promise<Annotation$2[]>;
     getResourceAnnotations(resourceId: ResourceId): Promise<Annotation$2[]>;
-    getResourceReferencedBy(resourceUri: ResourceUri, _motivation?: string): Promise<Annotation$2[]>;
+    getResourceReferencedBy(resourceId: ResourceId, _motivation?: string): Promise<Annotation$2[]>;
     getResourceConnections(resourceId: ResourceId): Promise<GraphConnection[]>;
     findPath(fromResourceId: string, toResourceId: string, maxDepth?: number): Promise<GraphPath[]>;
     getEntityTypeStats(): Promise<EntityTypeStats[]>;
@@ -232,7 +232,6 @@ type ResourceDescriptor$1 = components['schemas']['ResourceDescriptor'];
 type Annotation$1 = components['schemas']['Annotation'];
 declare class JanusGraphDatabase implements GraphDatabase {
     private graphConfig;
-    private envConfig;
     private connected;
     private connection;
     private g;
@@ -244,7 +243,7 @@ declare class JanusGraphDatabase implements GraphDatabase {
         storageBackend?: 'cassandra' | 'hbase' | 'berkeleydb';
         indexBackend?: 'elasticsearch' | 'solr' | 'lucene';
         logger?: Logger;
-    }, envConfig: EnvironmentConfig);
+    });
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
@@ -254,18 +253,18 @@ declare class JanusGraphDatabase implements GraphDatabase {
     private fetchAnnotationsWithEntityTypes;
     private vertexToAnnotation;
     createResource(resource: ResourceDescriptor$1): Promise<ResourceDescriptor$1>;
-    getResource(id: ResourceUri): Promise<ResourceDescriptor$1 | null>;
-    updateResource(id: ResourceUri, input: UpdateResourceInput): Promise<ResourceDescriptor$1>;
-    deleteResource(id: ResourceUri): Promise<void>;
+    getResource(id: ResourceId): Promise<ResourceDescriptor$1 | null>;
+    updateResource(id: ResourceId, input: UpdateResourceInput): Promise<ResourceDescriptor$1>;
+    deleteResource(id: ResourceId): Promise<void>;
     listResources(filter: ResourceFilter): Promise<{
         resources: ResourceDescriptor$1[];
         total: number;
     }>;
     searchResources(query: string, limit?: number): Promise<ResourceDescriptor$1[]>;
     createAnnotation(input: CreateAnnotationInternal): Promise<Annotation$1>;
-    getAnnotation(id: AnnotationUri): Promise<Annotation$1 | null>;
-    updateAnnotation(id: AnnotationUri, updates: Partial<Annotation$1>): Promise<Annotation$1>;
-    deleteAnnotation(id: AnnotationUri): Promise<void>;
+    getAnnotation(id: AnnotationId): Promise<Annotation$1 | null>;
+    updateAnnotation(id: AnnotationId, updates: Partial<Annotation$1>): Promise<Annotation$1>;
+    deleteAnnotation(id: AnnotationId): Promise<void>;
     listAnnotations(filter: {
         resourceId?: ResourceId;
         type?: AnnotationCategory;
@@ -278,7 +277,7 @@ declare class JanusGraphDatabase implements GraphDatabase {
     getReferences(resourceId: ResourceId): Promise<Annotation$1[]>;
     getEntityReferences(resourceId: ResourceId, entityTypes?: string[]): Promise<Annotation$1[]>;
     getResourceAnnotations(resourceId: ResourceId): Promise<Annotation$1[]>;
-    getResourceReferencedBy(resourceUri: ResourceUri, _motivation?: string): Promise<Annotation$1[]>;
+    getResourceReferencedBy(resourceId: ResourceId, _motivation?: string): Promise<Annotation$1[]>;
     getResourceConnections(resourceId: ResourceId): Promise<GraphConnection[]>;
     findPath(_fromResourceId: string, _toResourceId: string, _maxDepth?: number): Promise<GraphPath[]>;
     getEntityTypeStats(): Promise<EntityTypeStats[]>;
@@ -312,18 +311,18 @@ declare class MemoryGraphDatabase implements GraphDatabase {
     disconnect(): Promise<void>;
     isConnected(): boolean;
     createResource(resource: ResourceDescriptor): Promise<ResourceDescriptor>;
-    getResource(id: ResourceUri): Promise<ResourceDescriptor | null>;
-    updateResource(id: ResourceUri, input: UpdateResourceInput): Promise<ResourceDescriptor>;
-    deleteResource(id: ResourceUri): Promise<void>;
+    getResource(id: ResourceId): Promise<ResourceDescriptor | null>;
+    updateResource(id: ResourceId, input: UpdateResourceInput): Promise<ResourceDescriptor>;
+    deleteResource(id: ResourceId): Promise<void>;
     listResources(filter: ResourceFilter): Promise<{
         resources: ResourceDescriptor[];
         total: number;
     }>;
     searchResources(query: string, limit?: number): Promise<ResourceDescriptor[]>;
     createAnnotation(input: CreateAnnotationInternal): Promise<Annotation>;
-    getAnnotation(id: AnnotationUri): Promise<Annotation | null>;
-    updateAnnotation(id: AnnotationUri, updates: Partial<Annotation>): Promise<Annotation>;
-    deleteAnnotation(id: AnnotationUri): Promise<void>;
+    getAnnotation(id: AnnotationId): Promise<Annotation | null>;
+    updateAnnotation(id: AnnotationId, updates: Partial<Annotation>): Promise<Annotation>;
+    deleteAnnotation(id: AnnotationId): Promise<void>;
     listAnnotations(filter: {
         resourceId?: ResourceId;
         type?: AnnotationCategory;
@@ -336,7 +335,7 @@ declare class MemoryGraphDatabase implements GraphDatabase {
     getReferences(resourceId: ResourceId): Promise<Annotation[]>;
     getEntityReferences(resourceId: ResourceId, entityTypes?: string[]): Promise<Annotation[]>;
     getResourceAnnotations(resourceId: ResourceId): Promise<Annotation[]>;
-    getResourceReferencedBy(resourceUri: ResourceUri, _motivation?: string): Promise<Annotation[]>;
+    getResourceReferencedBy(resourceId: ResourceId, _motivation?: string): Promise<Annotation[]>;
     getResourceConnections(resourceId: ResourceId): Promise<GraphConnection[]>;
     findPath(fromResourceId: string, toResourceId: string, maxDepth?: number): Promise<GraphPath[]>;
     getEntityTypeStats(): Promise<EntityTypeStats[]>;

package/dist/index.js

@@ -524,9 +524,9 @@ var NeptuneGraphDatabase = class {
       throw error;
     }
   }
-  async getResourceReferencedBy(resourceUri3, _motivation) {
+  async getResourceReferencedBy(resourceId, _motivation) {
     try {
-      const results = await this.g.V().hasLabel("Annotation").has("resolvedResourceId", resourceUri3).elementMap().toList();
+      const results = await this.g.V().hasLabel("Annotation").has("resolvedResourceId", resourceId).elementMap().toList();
       return await this.fetchAnnotationsWithEntityTypes(results);
     } catch (error) {
       this.logger?.error("Failed to get resource referenced by from Neptune", { error });
@@ -1383,16 +1383,16 @@ var Neo4jGraphDatabase = class {
       await session.close();
     }
   }
-  async getResourceReferencedBy(resourceUri3, motivation) {
+  async getResourceReferencedBy(resourceId, motivation) {
     const session = this.getSession();
     try {
-      this.logger?.debug("Searching for annotations referencing resource", { resourceUri: resourceUri3, motivation });
+      this.logger?.debug("Searching for annotations referencing resource", { resourceId, motivation });
       const motivationLabel = motivation ? `:${motivationToLabel(motivation)}` : "";
-      const cypher = `MATCH (a:Annotation${motivationLabel})-[:REFERENCES]->(d:Resource {id: $resourceUri})
+      const cypher = `MATCH (a:Annotation${motivationLabel})-[:REFERENCES]->(d:Resource {id: $resourceId})
          OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
          RETURN a, collect(et.name) as entityTypes
          ORDER BY a.created DESC`;
-      const result = await session.run(cypher, { resourceUri: resourceUri3 });
+      const result = await session.run(cypher, { resourceId });
       this.logger?.debug("Found annotations", { count: result.records.length });
       return result.records.map(
         (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
@@ -1776,7 +1776,7 @@ var Neo4jGraphDatabase = class {
 
 // src/implementations/janusgraph.ts
 import gremlin2 from "gremlin";
-import { resourceUri, annotationIdToURI } from "@semiont/core";
+import { resourceId as makeResourceId } from "@semiont/core";
 import {
   getBodySource as getBodySource3,
   getPrimaryRepresentation as getPrimaryRepresentation3,
@@ -1788,9 +1788,8 @@ import { v4 as uuidv43 } from "uuid";
 var traversal = gremlin2.process.AnonymousTraversalSource.traversal;
 var DriverRemoteConnection = gremlin2.driver.DriverRemoteConnection;
 var JanusGraphDatabase = class {
-  constructor(graphConfig, envConfig) {
+  constructor(graphConfig) {
     this.graphConfig = graphConfig;
-    this.envConfig = envConfig;
     this.logger = graphConfig.logger;
   }
   connected = false;
@@ -2120,10 +2119,9 @@ var JanusGraphDatabase = class {
     return annotations;
   }
   async resolveReference(annotationId, source) {
-    const publicURL = this.envConfig.services.backend.publicURL;
-    const annotation = await this.getAnnotation(annotationIdToURI(annotationId, publicURL));
+    const annotation = await this.getAnnotation(annotationId);
     if (!annotation) throw new Error("Annotation not found");
-    await this.updateAnnotation(annotationIdToURI(annotationId, publicURL), {
+    await this.updateAnnotation(annotationId, {
       body: [
         {
           type: "SpecificResource",
@@ -2133,7 +2131,7 @@ var JanusGraphDatabase = class {
       ]
     });
     await this.g.V().has("Annotation", "id", annotationId).addE("REFERENCES").to(this.g.V().has("Resource", "id", source)).next();
-    const updatedAnnotation = await this.getAnnotation(annotationIdToURI(annotationId, publicURL));
+    const updatedAnnotation = await this.getAnnotation(annotationId);
     if (!updatedAnnotation) {
       throw new Error("Annotation not found after update");
     }
@@ -2163,8 +2161,8 @@ var JanusGraphDatabase = class {
     const { annotations } = await this.listAnnotations({ resourceId });
     return annotations;
   }
-  async getResourceReferencedBy(resourceUri3, _motivation) {
-    const vertices = await this.g.V().hasLabel("Annotation").has("source", resourceUri3).toList();
+  async getResourceReferencedBy(resourceId, _motivation) {
+    const vertices = await this.g.V().hasLabel("Annotation").has("source", resourceId).toList();
     return await this.fetchAnnotationsWithEntityTypes(vertices);
   }
   async getResourceConnections(resourceId) {
@@ -2175,7 +2173,7 @@ var JanusGraphDatabase = class {
     for (const ref of refs) {
       const bodySource = getBodySource3(ref.body);
       if (bodySource) {
-        const targetDoc = await this.getResource(resourceUri(bodySource));
+        const targetDoc = await this.getResource(makeResourceId(bodySource));
         if (targetDoc) {
           const existing = connections.find((c) => c.targetResource.id === targetDoc.id);
           if (existing) {
@@ -2327,7 +2325,7 @@ var JanusGraphDatabase = class {
 };
 
 // src/implementations/memorygraph.ts
-import { resourceId as makeResourceId, uriToResourceId, resourceUri as resourceUri2 } from "@semiont/core";
+import { resourceId as makeResourceId2 } from "@semiont/core";
 import { v4 as uuidv44 } from "uuid";
 import {
   getBodySource as getBodySource4,
@@ -2364,30 +2362,22 @@ var MemoryGraphDatabase = class {
     return resource;
   }
   async getResource(id) {
-    try {
-      const resourceId = uriToResourceId(id);
-      return this.resources.get(resourceId) || null;
-    } catch {
-      return null;
-    }
+    return this.resources.get(String(id)) || null;
   }
   async updateResource(id, input) {
     if (Object.keys(input).length !== 1 || input.archived === void 0) {
       throw new Error("Resources are immutable. Only archiving is allowed.");
     }
-    const resourceId = uriToResourceId(id);
-    const doc = resourceId ? this.resources.get(resourceId) : null;
+    const doc = this.resources.get(String(id));
     if (!doc) throw new Error("Resource not found");
     doc.archived = input.archived;
     return doc;
   }
   async deleteResource(id) {
-    const resourceId = uriToResourceId(id);
-    if (resourceId) {
-      this.resources.delete(resourceId);
-    }
+    this.resources.delete(String(id));
+    const idStr = String(id);
     for (const [selId, sel] of this.annotations) {
-      if (getTargetSource3(sel.target) === id || getBodySource4(sel.body) === id) {
+      if (getTargetSource3(sel.target) === idStr || getBodySource4(sel.body) === idStr) {
         this.annotations.delete(selId);
       }
     }
@@ -2457,11 +2447,7 @@ var MemoryGraphDatabase = class {
     let results = Array.from(this.annotations.values());
     if (filter.resourceId) {
       const resourceIdStr = String(filter.resourceId);
-      results = results.filter((a) => {
-        const targetSource = getTargetSource3(a.target);
-        const targetResourceId = targetSource ? uriToResourceId(targetSource) : null;
-        return targetResourceId === resourceIdStr;
-      });
+      results = results.filter((a) => getTargetSource3(a.target) === resourceIdStr);
     }
     if (filter.type) {
       const motivation = filter.type === "highlight" ? "highlighting" : "linking";
@@ -2471,24 +2457,18 @@ var MemoryGraphDatabase = class {
   }
   async getHighlights(resourceId) {
     const resourceIdStr = String(resourceId);
-    const highlights = Array.from(this.annotations.values()).filter((sel) => {
-      const targetSource = getTargetSource3(sel.target);
-      const targetResourceId = targetSource ? uriToResourceId(targetSource) : null;
-      return targetResourceId === resourceIdStr && sel.motivation === "highlighting";
-    });
+    const highlights = Array.from(this.annotations.values()).filter((sel) => getTargetSource3(sel.target) === resourceIdStr && sel.motivation === "highlighting");
     this.logger?.debug("Got highlights for resource", { resourceId, count: highlights.length });
     return highlights;
   }
   async resolveReference(annotationId, source) {
     const annotation = this.annotations.get(annotationId);
     if (!annotation) throw new Error("Annotation not found");
-    const sourceResource = this.resources.get(String(source));
-    if (!sourceResource) throw new Error("Source resource not found");
     const updated = {
       ...annotation,
       body: {
         type: "SpecificResource",
-        source: sourceResource["@id"],
+        source: String(source),
         purpose: "linking"
       }
     };
@@ -2497,22 +2477,16 @@ var MemoryGraphDatabase = class {
   }
   async getReferences(resourceId) {
     const resourceIdStr = String(resourceId);
-    const references = Array.from(this.annotations.values()).filter((sel) => {
-      const targetSource = getTargetSource3(sel.target);
-      const targetResourceId = targetSource ? uriToResourceId(targetSource) : null;
-      return targetResourceId === resourceIdStr && sel.motivation === "linking";
-    });
+    const references = Array.from(this.annotations.values()).filter((sel) => getTargetSource3(sel.target) === resourceIdStr && sel.motivation === "linking");
     this.logger?.debug("Got references for resource", { resourceId, count: references.length });
     return references;
   }
   async getEntityReferences(resourceId, entityTypes) {
     const resourceIdStr = String(resourceId);
     let refs = Array.from(this.annotations.values()).filter((sel) => {
-      const targetSource = getTargetSource3(sel.target);
-      const targetResourceId = targetSource ? uriToResourceId(targetSource) : null;
+      if (getTargetSource3(sel.target) !== resourceIdStr) return false;
       const bodyEntityTypes = sel.body?.entityTypes;
-      const hasEntityTypes = Array.isArray(bodyEntityTypes) && bodyEntityTypes.length > 0;
-      return targetResourceId === resourceIdStr && hasEntityTypes;
+      return Array.isArray(bodyEntityTypes) && bodyEntityTypes.length > 0;
     });
     if (entityTypes && entityTypes.length > 0) {
       refs = refs.filter((sel) => {
@@ -2524,62 +2498,48 @@ var MemoryGraphDatabase = class {
   }
   async getResourceAnnotations(resourceId) {
     const resourceIdStr = String(resourceId);
-    return Array.from(this.annotations.values()).filter((sel) => {
-      const targetSource = getTargetSource3(sel.target);
-      const targetResourceId = targetSource ? uriToResourceId(targetSource) : null;
-      return targetResourceId === resourceIdStr;
-    });
+    return Array.from(this.annotations.values()).filter((sel) => getTargetSource3(sel.target) === resourceIdStr);
   }
-  async getResourceReferencedBy(resourceUri3, _motivation) {
-    return Array.from(this.annotations.values()).filter((sel) => getBodySource4(sel.body) === resourceUri3);
+  async getResourceReferencedBy(resourceId, _motivation) {
+    return Array.from(this.annotations.values()).filter((sel) => getBodySource4(sel.body) === String(resourceId));
   }
   async getResourceConnections(resourceId) {
     const connections = [];
     const refs = await this.getReferences(resourceId);
+    const resourceIdStr = String(resourceId);
     for (const ref of refs) {
       const bodySource = getBodySource4(ref.body);
       if (bodySource) {
-        const targetDoc = await this.getResource(resourceUri2(bodySource));
+        const targetDoc = await this.getResource(makeResourceId2(bodySource));
         if (targetDoc) {
-          const bodySourceId = uriToResourceId(bodySource);
-          if (bodySourceId) {
-            const reverseRefs = await this.getReferences(makeResourceId(bodySourceId));
-            const resourceIdStr = String(resourceId);
-            const bidirectional = reverseRefs.some((r) => {
-              const reverseBodySource = getBodySource4(r.body);
-              const reverseBodyResourceId = reverseBodySource ? uriToResourceId(reverseBodySource) : null;
-              return reverseBodyResourceId === resourceIdStr;
-            });
-            connections.push({
-              targetResource: targetDoc,
-              annotations: [ref],
-              bidirectional
-            });
-          }
+          const reverseRefs = await this.getReferences(makeResourceId2(bodySource));
+          const bidirectional = reverseRefs.some((r) => getBodySource4(r.body) === resourceIdStr);
+          connections.push({
+            targetResource: targetDoc,
+            annotations: [ref],
+            bidirectional
+          });
         }
       }
     }
     return connections;
   }
   async findPath(fromResourceId, toResourceId, maxDepth = 5) {
-    const fromUuid = uriToResourceId(fromResourceId);
-    const toUuid = uriToResourceId(toResourceId);
-    if (!fromUuid || !toUuid) return [];
     const visited = /* @__PURE__ */ new Set();
     const queue = [];
-    const fromDoc = await this.getResource(resourceUri2(fromResourceId));
+    const fromDoc = await this.getResource(makeResourceId2(fromResourceId));
     if (!fromDoc) return [];
-    queue.push({ docId: fromUuid, path: [fromDoc], sels: [] });
-    visited.add(fromUuid);
+    queue.push({ docId: fromResourceId, path: [fromDoc], sels: [] });
+    visited.add(fromResourceId);
     const paths = [];
     while (queue.length > 0 && paths.length < 10) {
       const { docId, path, sels } = queue.shift();
       if (path.length > maxDepth) continue;
-      if (docId === toUuid) {
+      if (docId === toResourceId) {
         paths.push({ resources: path, annotations: sels });
         continue;
       }
-      const connections = await this.getResourceConnections(makeResourceId(docId));
+      const connections = await this.getResourceConnections(makeResourceId2(docId));
       for (const conn of connections) {
         const targetId = getResourceId3(conn.targetResource);
         if (targetId && !visited.has(targetId)) {
@@ -2698,7 +2658,7 @@ var MemoryGraphDatabase = class {
 
 // src/factory.ts
 var graphDatabaseInstance = null;
-function createGraphDatabase(config, envConfig) {
+function createGraphDatabase(config) {
   switch (config.type) {
     case "neptune": {
       const neptuneConfig = {};
@@ -2721,7 +2681,7 @@ function createGraphDatabase(config, envConfig) {
       if (config.janusPort !== void 0) janusConfig.port = config.janusPort;
       if (config.janusStorageBackend !== void 0) janusConfig.storageBackend = config.janusStorageBackend;
       if (config.janusIndexBackend !== void 0) janusConfig.indexBackend = config.janusIndexBackend;
-      return new JanusGraphDatabase(janusConfig, envConfig);
+      return new JanusGraphDatabase(janusConfig);
     }
     case "memory":
       return new MemoryGraphDatabase({});
@@ -2739,9 +2699,8 @@ function evaluateEnvVar(value) {
     return envValue;
   });
 }
-async function getGraphDatabase(envConfig) {
+async function getGraphDatabase(graphConfig) {
   if (!graphDatabaseInstance) {
-    const graphConfig = envConfig.services.graph;
     const config = {
       type: graphConfig.type
     };
@@ -2782,7 +2741,7 @@ async function getGraphDatabase(envConfig) {
         config.neo4jDatabase = evaluateEnvVar(graphConfig.database);
       }
     }
-    graphDatabaseInstance = createGraphDatabase(config, envConfig);
+    graphDatabaseInstance = createGraphDatabase(config);
     await graphDatabaseInstance.connect();
   }
   if (!graphDatabaseInstance.isConnected()) {