@anvia/neo4j 1.0.5 → 1.0.10

package/dist/{chunk-QNHOT7P2.js → chunk-EUZ5C6OC.js}

@@ -227,14 +227,50 @@ function stableObject(value) {
   );
 }
 
+// src/managed-scope.ts
+function managedScopeParameters(scope, parameters) {
+  return scope === void 0 ? parameters : { graph: scope.graph, namespace: scope.namespace ?? null, ...parameters };
+}
+function managedScopePredicate(scope, variable, prefix) {
+  if (scope === void 0) return "";
+  return `${prefix} ${variable}.${quoteIdentifier("__anvia_graph")} = $graph${namespacePredicate(scope, variable, " AND")}`;
+}
+function namespacePredicate(scope, variable, prefix) {
+  return scope.namespace === void 0 ? "" : `${prefix} ${variable}.${quoteIdentifier("__anvia_namespace")} = $namespace`;
+}
+function tenantScopePredicate(scope, variable, prefix) {
+  return scope.namespace === void 0 ? "" : managedScopePredicate(scope, variable, prefix);
+}
+function managedPathPredicate(scope, relationships) {
+  if (scope === void 0) return "";
+  const item = `item.${quoteIdentifier("__anvia_graph")} = $graph${namespacePredicate(scope, "item", " AND")}`;
+  const nodes = ` AND all(item IN nodes(path) WHERE ${item})`;
+  return relationships ? `${nodes}
+  AND all(item IN relationships(path) WHERE ${item})` : nodes;
+}
+function namespaceMapEntry(scope) {
+  return scope.namespace === void 0 ? "" : `, ${quoteIdentifier("__anvia_namespace")}: $namespace`;
+}
+function tenantMapEntries(scope) {
+  return scope.namespace === void 0 ? "" : `, ${quoteIdentifier("__anvia_graph")}: $graph, ${quoteIdentifier("__anvia_namespace")}: $namespace`;
+}
+function tenantRelationshipProperties(scope) {
+  return scope.namespace === void 0 ? "" : ` {${quoteIdentifier("__anvia_graph")}: $graph, ${quoteIdentifier("__anvia_namespace")}: $namespace}`;
+}
+
 // src/graph.ts
 import {
   isInt as isInt2
 } from "neo4j-driver";
+var tenantScopeBrand = /* @__PURE__ */ Symbol("Neo4jTenantScope");
+function neo4jTenantScope(namespace) {
+  return Object.freeze({ namespace, [tenantScopeBrand]: true });
+}
 var Neo4jKnowledgeGraphBase = class {
-  constructor(owner, schema) {
+  constructor(owner, schema, namespace) {
     this.owner = owner;
     this.schema = schema;
+    this.namespace = namespace;
     if (schema.kind !== "neo4j-graph-schema" && schema.kind !== "graph-schema") {
       throw new TypeError(
         "Neo4j knowledge graphs require defineGraphSchema() or defineNeo4jGraphSchema()."
@@ -243,6 +279,7 @@ var Neo4jKnowledgeGraphBase = class {
   }
   owner;
   schema;
+  namespace;
   async validate(options = {}) {
     throwIfAborted(options.abortSignal);
     await this.assertSupportedVersion(options.abortSignal);
@@ -273,14 +310,14 @@ var Neo4jKnowledgeGraphBase = class {
     );
   }
   async retrieve(options) {
-    const { retrieveGraphContext } = await import("./retrieve-QRQHIVRO.js");
+    const { retrieveGraphContext } = await import("./retrieve-IJVPFOPP.js");
     return retrieveGraphContext({
       ...options,
       graph: this
     });
   }
   async explore(options) {
-    const { exploreGraph } = await import("./explore-RA53GFX2.js");
+    const { exploreGraph } = await import("./explore-HRISJG7V.js");
     return exploreGraph(this, options);
   }
   seed(name) {
@@ -362,9 +399,11 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
   seeds;
   resources;
   name;
-  constructor(owner, options) {
-    super(owner, options.schema);
+  constructor(owner, options, tenantScope) {
+    const namespace = tenantScope?.namespace;
+    super(owner, options.schema, namespace);
     assertName(options.name, "Managed Neo4j graph name");
+    if (namespace !== void 0) assertName(namespace, "Managed Neo4j namespace");
     this.name = options.name;
     this.resources = validateManagedResources(options.resources);
     let chunks = {
@@ -373,6 +412,7 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
         ...this.resources.indexes.chunks.vector,
         property: "__anvia_embedding"
       }),
+      vectorFilterProperties: this.namespace === void 0 ? void 0 : Object.freeze(["__anvia_namespace"]),
       entryRelationshipType: "ANVIA_MENTIONS"
     };
     if (this.resources.indexes.chunks.fulltext !== void 0) {
@@ -380,7 +420,10 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
         ...chunks,
         fulltextIndex: Object.freeze({
           ...this.resources.indexes.chunks.fulltext,
-          properties: Object.freeze(["__anvia_text"])
+          properties: Object.freeze([
+            "__anvia_text",
+            ...this.namespace === void 0 ? [] : ["__anvia_namespace"]
+          ])
         })
       };
     }
@@ -389,16 +432,18 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
       vectorIndex: Object.freeze({
         ...this.resources.indexes.entities.vector,
         property: "__anvia_embedding"
-      })
+      }),
+      vectorFilterProperties: this.namespace === void 0 ? void 0 : Object.freeze(["__anvia_namespace"])
     };
     if (this.resources.indexes.entities.fulltext !== void 0) {
       entities = {
         ...entities,
         fulltextIndex: Object.freeze({
           ...this.resources.indexes.entities.fulltext,
-          properties: Object.freeze(
-            Array.from(this.resources.indexes.entities.fulltext.properties ?? [])
-          )
+          properties: Object.freeze([
+            ...this.resources.indexes.entities.fulltext.properties ?? [],
+            ...this.namespace === void 0 ? [] : ["__anvia_namespace"]
+          ])
         })
       };
     }
@@ -411,30 +456,43 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
     positiveInteger(options.indexTimeoutMs, "Neo4j index timeout");
     throwIfAborted(options.abortSignal);
     const { labels, indexes } = this.resources;
+    const identityPrefix = this.namespace === void 0 ? [] : ["__anvia_namespace"];
     const statements = [
-      uniquenessConstraint(constraintName(this.name, "document"), labels.document, ["__anvia_id"]),
-      uniquenessConstraint(constraintName(this.name, "chunk"), labels.chunk, ["__anvia_id"]),
-      uniquenessConstraint(constraintName(this.name, "entity"), labels.entity, ["__anvia_key"]),
+      uniquenessConstraint(constraintName(this.name, "document"), labels.document, [
+        ...identityPrefix,
+        "__anvia_id"
+      ]),
+      uniquenessConstraint(constraintName(this.name, "chunk"), labels.chunk, [
+        ...identityPrefix,
+        "__anvia_id"
+      ]),
+      uniquenessConstraint(constraintName(this.name, "entity"), labels.entity, [
+        ...identityPrefix,
+        "__anvia_key"
+      ]),
       ...Object.entries(this.schema.nodes).map(
-        ([type, definition]) => uniquenessConstraint(
-          constraintName(this.name, `entity_${type}`),
-          type,
-          definition.identity
-        )
+        ([type, definition]) => uniquenessConstraint(constraintName(this.name, `entity_${type}`), type, [
+          ...identityPrefix,
+          ...definition.identity
+        ])
       ),
-      vectorIndex(indexes.chunks.vector, labels.chunk),
-      vectorIndex(indexes.entities.vector, labels.entity)
+      vectorIndex(indexes.chunks.vector, labels.chunk, this.namespace !== void 0),
+      vectorIndex(indexes.entities.vector, labels.entity, this.namespace !== void 0)
     ];
     if (indexes.chunks.fulltext !== void 0) {
-      statements.push(fulltextIndex(indexes.chunks.fulltext.name, labels.chunk, ["__anvia_text"]));
+      statements.push(
+        fulltextIndex(indexes.chunks.fulltext.name, labels.chunk, [
+          "__anvia_text",
+          ...this.namespace === void 0 ? [] : ["__anvia_namespace"]
+        ])
+      );
     }
     if (indexes.entities.fulltext !== void 0) {
       statements.push(
-        fulltextIndex(
-          indexes.entities.fulltext.name,
-          labels.entity,
-          indexes.entities.fulltext.properties ?? []
-        )
+        fulltextIndex(indexes.entities.fulltext.name, labels.entity, [
+          ...indexes.entities.fulltext.properties ?? [],
+          ...this.namespace === void 0 ? [] : ["__anvia_namespace"]
+        ])
       );
     }
     for (const statement of statements)
@@ -489,30 +547,52 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
       const before = await snapshotGraphState(
         transaction,
         this.name,
+        this.namespace,
         this.resources.labels,
         targets
       );
       await removeDocuments(
         transaction,
         this.name,
+        this.namespace,
         this.resources.labels,
         documentIds,
         options.orphanEntities
       );
-      await writeDocuments(transaction, this.resources.labels, options.documents);
-      await writeChunks(transaction, this.resources.labels, options.chunks);
+      await writeDocuments(
+        transaction,
+        this.name,
+        this.namespace,
+        this.resources.labels,
+        options.documents
+      );
+      await writeChunks(
+        transaction,
+        this.name,
+        this.namespace,
+        this.resources.labels,
+        options.chunks
+      );
       await writeEntities(
         transaction,
         this.name,
+        this.namespace,
         this.resources.labels.entity,
         options.entities,
         options.conflict,
         sourceDocuments
       );
-      await writeMentions(transaction, this.resources.labels, options.mentions);
+      await writeMentions(
+        transaction,
+        this.name,
+        this.namespace,
+        this.resources.labels,
+        options.mentions
+      );
       await writeRelationships(
         transaction,
         this.name,
+        this.namespace,
         this.resources.labels.entity,
         options.relationships,
         options.conflict,
@@ -521,6 +601,7 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
       const after = await snapshotGraphState(
         transaction,
         this.name,
+        this.namespace,
         this.resources.labels,
         expandSnapshotTargets(targets, before)
       );
@@ -536,12 +617,14 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
       const before = await snapshotGraphState(
         transaction,
         this.name,
+        this.namespace,
         this.resources.labels,
         targets
       );
       await removeDocuments(
         transaction,
         this.name,
+        this.namespace,
         this.resources.labels,
         ids,
         options.orphanEntities
@@ -549,6 +632,7 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
       const after = await snapshotGraphState(
         transaction,
         this.name,
+        this.namespace,
         this.resources.labels,
         expandSnapshotTargets(targets, before)
       );
@@ -556,26 +640,27 @@ var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
     });
   }
   expectedConstraints() {
+    const identityPrefix = this.namespace === void 0 ? [] : ["__anvia_namespace"];
     return [
       {
         name: constraintName(this.name, "document"),
         label: this.resources.labels.document,
-        properties: ["__anvia_id"]
+        properties: [...identityPrefix, "__anvia_id"]
       },
       {
         name: constraintName(this.name, "chunk"),
         label: this.resources.labels.chunk,
-        properties: ["__anvia_id"]
+        properties: [...identityPrefix, "__anvia_id"]
       },
       {
         name: constraintName(this.name, "entity"),
         label: this.resources.labels.entity,
-        properties: ["__anvia_key"]
+        properties: [...identityPrefix, "__anvia_key"]
       },
       ...Object.entries(this.schema.nodes).map(([type, definition]) => ({
         name: constraintName(this.name, `entity_${type}`),
         label: type,
-        properties: definition.identity
+        properties: [...identityPrefix, ...definition.identity]
       }))
     ];
   }
@@ -709,7 +794,7 @@ function expectedIndexes(seeds) {
       kind: "vector",
       name: seed.vectorIndex.name,
       labels: seed.labels,
-      properties: [seed.vectorIndex.property],
+      properties: [seed.vectorIndex.property, ...seed.vectorFilterProperties ?? []],
       dimensions: seed.vectorIndex.dimensions,
       similarity: seed.vectorIndex.similarity
     });
@@ -820,8 +905,9 @@ function uniquenessConstraint(name, label, properties) {
   const expression = properties.length === 1 ? `n.${quoteIdentifier(properties[0])}` : `(${properties.map((property) => `n.${quoteIdentifier(property)}`).join(", ")})`;
   return `CREATE CONSTRAINT ${quoteIdentifier(name)} IF NOT EXISTS FOR (n:${quoteIdentifier(label)}) REQUIRE ${expression} IS UNIQUE`;
 }
-function vectorIndex(index, label) {
-  return `CREATE VECTOR INDEX ${quoteIdentifier(index.name)} IF NOT EXISTS FOR (n:${quoteIdentifier(label)}) ON (n.${quoteIdentifier("__anvia_embedding")}) OPTIONS {indexConfig: {\`vector.dimensions\`: ${index.dimensions}, \`vector.similarity_function\`: '${index.similarity}'}}`;
+function vectorIndex(index, label, namespaced) {
+  const filterProperties = namespaced ? ` WITH [n.${quoteIdentifier("__anvia_namespace")}]` : "";
+  return `CREATE VECTOR INDEX ${quoteIdentifier(index.name)} IF NOT EXISTS FOR (n:${quoteIdentifier(label)}) ON (n.${quoteIdentifier("__anvia_embedding")})${filterProperties} OPTIONS {indexConfig: {\`vector.dimensions\`: ${index.dimensions}, \`vector.similarity_function\`: '${index.similarity}'}}`;
 }
 function fulltextIndex(name, label, properties) {
   if (properties.length === 0) throw new TypeError(`Full-text index ${name} requires properties.`);
@@ -1089,32 +1175,38 @@ function expandSnapshotTargets(targets, snapshot) {
     mentions: [...mentions.values()]
   };
 }
-async function snapshotGraphState(transaction, graphName, labels, targets) {
+async function snapshotGraphState(transaction, graphName, namespace, labels, targets) {
   const documentsResult = await transaction.run(
     `MATCH (d:${quoteIdentifier(labels.document)})
-WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds
+WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds${tenantPredicate("d", namespace, " AND")}
 RETURN d.${quoteIdentifier("__anvia_id")} AS key, properties(d) AS properties`,
-    { documentIds: targets.documentIds }
+    managedParameters(graphName, namespace, { documentIds: targets.documentIds })
   );
   const chunksResult = await transaction.run(
     `MATCH (c:${quoteIdentifier(labels.chunk)})
 OPTIONAL MATCH (d:${quoteIdentifier(labels.document)})-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c)
-WITH c, d WHERE c.${quoteIdentifier("__anvia_id")} IN $chunkIds OR d.${quoteIdentifier("__anvia_id")} IN $documentIds
+WITH c, d WHERE (c.${quoteIdentifier("__anvia_id")} IN $chunkIds OR d.${quoteIdentifier("__anvia_id")} IN $documentIds)${tenantPredicate("c", namespace, " AND")}
 RETURN c.${quoteIdentifier("__anvia_id")} AS key, properties(c) AS properties`,
-    { chunkIds: targets.chunkIds, documentIds: targets.documentIds }
+    managedParameters(graphName, namespace, {
+      chunkIds: targets.chunkIds,
+      documentIds: targets.documentIds
+    })
   );
   const entitiesResult = await transaction.run(
     `MATCH (e:${quoteIdentifier(labels.entity)})
-WHERE e.${quoteIdentifier("__anvia_graph")} = $graph AND (
+WHERE e.${quoteIdentifier("__anvia_graph")} = $graph${namespacePredicate2("e", namespace, " AND")} AND (
   e.${quoteIdentifier("__anvia_key")} IN $entityKeys OR
   any(id IN coalesce(e.${quoteIdentifier("__anvia_source_document_ids")}, []) WHERE id IN $documentIds)
 )
 RETURN e.${quoteIdentifier("__anvia_key")} AS key, labels(e) AS labels, properties(e) AS properties`,
-    { graph: graphName, entityKeys: targets.entityKeys, documentIds: targets.documentIds }
+    managedParameters(graphName, namespace, {
+      entityKeys: targets.entityKeys,
+      documentIds: targets.documentIds
+    })
   );
   const relationshipsResult = await transaction.run(
     `MATCH ()-[r]->()
-WHERE r.${quoteIdentifier("__anvia_graph")} = $graph AND (
+WHERE r.${quoteIdentifier("__anvia_graph")} = $graph${namespacePredicate2("r", namespace, " AND")} AND (
   r.${quoteIdentifier("__anvia_key")} IN $relationshipKeys OR
   any(id IN coalesce(r.${quoteIdentifier("__anvia_source_document_ids")}, []) WHERE id IN $documentIds)
 )
@@ -1123,19 +1215,22 @@ RETURN r.${quoteIdentifier("__anvia_key")} AS key,
        startNode(r).${quoteIdentifier("__anvia_key")} AS source,
        endNode(r).${quoteIdentifier("__anvia_key")} AS target,
        properties(r) AS properties`,
-    {
-      graph: graphName,
+    managedParameters(graphName, namespace, {
       relationshipKeys: targets.relationshipKeys,
       documentIds: targets.documentIds
-    }
+    })
   );
   const mentionsResult = await transaction.run(
     `MATCH (c:${quoteIdentifier(labels.chunk)})-[:${quoteIdentifier("ANVIA_MENTIONS")}]->(e:${quoteIdentifier(labels.entity)})
 OPTIONAL MATCH (d:${quoteIdentifier(labels.document)})-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c)
-WITH c, e, d WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds OR
+WITH c, e, d WHERE (d.${quoteIdentifier("__anvia_id")} IN $documentIds OR
   any(item IN $mentions WHERE item.chunkId = c.${quoteIdentifier("__anvia_id")} AND item.entityKey = e.${quoteIdentifier("__anvia_key")})
+)${tenantPredicate("c", namespace, " AND")}
 RETURN c.${quoteIdentifier("__anvia_id")} AS chunkId, e.${quoteIdentifier("__anvia_key")} AS entityKey`,
-    { documentIds: targets.documentIds, mentions: targets.mentions }
+    managedParameters(graphName, namespace, {
+      documentIds: targets.documentIds,
+      mentions: targets.mentions
+    })
   );
   return {
     documents: snapshotProperties(documentsResult.records, "document"),
@@ -1262,54 +1357,71 @@ function emptyWriteResult() {
     mentions: empty()
   };
 }
-async function removeDocuments(transaction, graphName, labels, documentIds, orphanEntities) {
+function managedParameters(graph, namespace, parameters) {
+  return managedScopeParameters({ graph, namespace }, parameters);
+}
+function namespacePredicate2(variable, namespace, prefix) {
+  return namespacePredicate({ graph: "", namespace }, variable, prefix);
+}
+function tenantPredicate(variable, namespace, prefix) {
+  return tenantScopePredicate({ graph: "", namespace }, variable, prefix);
+}
+function namespaceMapEntry2(namespace) {
+  return namespaceMapEntry({ graph: "", namespace });
+}
+function tenantMapEntries2(namespace) {
+  return tenantMapEntries({ graph: "", namespace });
+}
+function tenantRelationshipProperties2(namespace) {
+  return tenantRelationshipProperties({ graph: "", namespace });
+}
+async function removeDocuments(transaction, graphName, namespace, labels, documentIds, orphanEntities) {
   const chunks = await transaction.run(
-    `MATCH (d:${quoteIdentifier(labels.document)})-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c:${quoteIdentifier(labels.chunk)}) WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds RETURN collect(c.${quoteIdentifier("__anvia_id")}) AS chunkIds`,
-    { documentIds }
+    `MATCH (d:${quoteIdentifier(labels.document)})-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c:${quoteIdentifier(labels.chunk)}) WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds${tenantPredicate("d", namespace, " AND")} RETURN collect(c.${quoteIdentifier("__anvia_id")}) AS chunkIds`,
+    managedParameters(graphName, namespace, { documentIds })
   );
   const chunkIdsValue = chunks.records[0]?.get("chunkIds");
   const chunkIds = requiredStringArray(chunkIdsValue, "Neo4j replacement chunk ids");
   await transaction.run(
-    `MATCH ()-[r]->() WHERE r.${quoteIdentifier("__anvia_graph")} = $graph AND any(id IN r.${quoteIdentifier("__anvia_source_document_ids")} WHERE id IN $documentIds)
+    `MATCH ()-[r]->() WHERE r.${quoteIdentifier("__anvia_graph")} = $graph${namespacePredicate2("r", namespace, " AND")} AND any(id IN r.${quoteIdentifier("__anvia_source_document_ids")} WHERE id IN $documentIds)
 SET r.${quoteIdentifier("__anvia_source_document_ids")} = [id IN r.${quoteIdentifier("__anvia_source_document_ids")} WHERE NOT id IN $documentIds]
 SET r.${quoteIdentifier("__anvia_source_chunk_ids")} = [id IN coalesce(r.${quoteIdentifier("__anvia_source_chunk_ids")}, []) WHERE NOT id IN $chunkIds]
 WITH r WHERE size(r.${quoteIdentifier("__anvia_source_document_ids")}) = 0 DELETE r`,
-    { graph: graphName, documentIds, chunkIds }
+    managedParameters(graphName, namespace, { documentIds, chunkIds })
   );
   await transaction.run(
-    `MATCH (d:${quoteIdentifier(labels.document)}) WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds
+    `MATCH (d:${quoteIdentifier(labels.document)}) WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds${tenantPredicate("d", namespace, " AND")}
 OPTIONAL MATCH (d)-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c:${quoteIdentifier(labels.chunk)})
 DETACH DELETE c, d`,
-    { documentIds }
+    managedParameters(graphName, namespace, { documentIds })
   );
   await transaction.run(
     `MATCH (e:${quoteIdentifier(labels.entity)})
-WHERE e.${quoteIdentifier("__anvia_graph")} = $graph AND
+WHERE e.${quoteIdentifier("__anvia_graph")} = $graph${namespacePredicate2("e", namespace, " AND")} AND
       any(id IN coalesce(e.${quoteIdentifier("__anvia_source_document_ids")}, []) WHERE id IN $documentIds)
 SET e.${quoteIdentifier("__anvia_source_document_ids")} = [id IN e.${quoteIdentifier("__anvia_source_document_ids")} WHERE NOT id IN $documentIds],
     e.${quoteIdentifier("__anvia_source_chunk_ids")} = [id IN coalesce(e.${quoteIdentifier("__anvia_source_chunk_ids")}, []) WHERE NOT id IN $chunkIds]
 WITH e WHERE $deleteOrphans AND size(e.${quoteIdentifier("__anvia_source_document_ids")}) = 0
 DETACH DELETE e`,
-    {
-      graph: graphName,
+    managedParameters(graphName, namespace, {
       documentIds,
       chunkIds,
       deleteOrphans: orphanEntities === "delete"
-    }
+    })
   );
 }
-async function writeDocuments(transaction, labels, documents) {
+async function writeDocuments(transaction, graphName, namespace, labels, documents) {
   await transaction.run(
-    `UNWIND $rows AS row MERGE (d:${quoteIdentifier(labels.document)} {${quoteIdentifier("__anvia_id")}: row.id}) SET d += row.properties`,
-    {
+    `UNWIND $rows AS row MERGE (d:${quoteIdentifier(labels.document)} {${quoteIdentifier("__anvia_id")}: row.id${namespaceMapEntry2(namespace)}}) ${namespace === void 0 ? "SET d += row.properties" : `SET d.${quoteIdentifier("__anvia_graph")} = $graph, d += row.properties`}`,
+    managedParameters(graphName, namespace, {
       rows: documents.map((document) => ({
         id: document.id,
         properties: document.properties ?? {}
       }))
-    }
+    })
   );
 }
-async function writeChunks(transaction, labels, chunks) {
+async function writeChunks(transaction, graphName, namespace, labels, chunks) {
   const rows = chunks.map((chunk) => ({
     id: chunk.id,
     documentId: chunk.document.documentId,
@@ -1321,10 +1433,11 @@ async function writeChunks(transaction, labels, chunks) {
   await transaction.run(
     `UNWIND $rows AS row
 MATCH (d:${quoteIdentifier(labels.document)} {${quoteIdentifier("__anvia_id")}: row.documentId})
-CREATE (c:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.id, ${quoteIdentifier("__anvia_document_id")}: row.documentId, ${quoteIdentifier("__anvia_index")}: row.index, ${quoteIdentifier("__anvia_text")}: row.text, ${quoteIdentifier("__anvia_embedding")}: row.embedding})
+${tenantPredicate("d", namespace, " WHERE")}
+CREATE (c:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.id, ${quoteIdentifier("__anvia_document_id")}: row.documentId, ${quoteIdentifier("__anvia_index")}: row.index, ${quoteIdentifier("__anvia_text")}: row.text, ${quoteIdentifier("__anvia_embedding")}: row.embedding${tenantMapEntries2(namespace)}})
 SET c += row.metadata
-CREATE (d)-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c)`,
-    { rows }
+CREATE (d)-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}${tenantRelationshipProperties2(namespace)}]->(c)`,
+    managedParameters(graphName, namespace, { rows })
   );
   const pairs = [...rows].sort(
     (left, right) => left.documentId.localeCompare(right.documentId) || left.index - right.index
@@ -1334,12 +1447,12 @@ CREATE (d)-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c)`,
   });
   if (pairs.length > 0) {
     await transaction.run(
-      `UNWIND $rows AS row MATCH (a:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.from}), (b:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.to}) CREATE (a)-[:${quoteIdentifier("ANVIA_NEXT_CHUNK")}]->(b)`,
-      { rows: pairs }
+      `UNWIND $rows AS row MATCH (a:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.from${namespaceMapEntry2(namespace)}}), (b:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.to${namespaceMapEntry2(namespace)}}) CREATE (a)-[:${quoteIdentifier("ANVIA_NEXT_CHUNK")}${tenantRelationshipProperties2(namespace)}]->(b)`,
+      managedParameters(graphName, namespace, { rows: pairs })
     );
   }
 }
-async function writeEntities(transaction, graphName, entityLabel, entities, conflict, sourceDocuments) {
+async function writeEntities(transaction, graphName, namespace, entityLabel, entities, conflict, sourceDocuments) {
   const grouped = groupBy(entities, (entity) => entity.document.type);
   for (const [type, values] of grouped) {
     const rows = values.map((entity) => ({
@@ -1349,26 +1462,28 @@ async function writeEntities(transaction, graphName, entityLabel, entities, conf
       sourceDocumentIds: sourceDocuments(entity.document.sourceChunkIds),
       sourceChunkIds: entity.document.sourceChunkIds
     }));
-    if (conflict === "error") await assertEntityConflicts(transaction, entityLabel, rows);
+    if (conflict === "error")
+      await assertEntityConflicts(transaction, graphName, namespace, entityLabel, rows);
     const propertySet = conflictPropertySet("e", conflict);
     const embedding = entityEmbeddingExpression(conflict);
     await transaction.run(
       `UNWIND $rows AS row
-MERGE (e:${quoteIdentifier(entityLabel)}:${quoteIdentifier(type)} {${quoteIdentifier("__anvia_key")}: row.key})
+MERGE (e:${quoteIdentifier(entityLabel)}:${quoteIdentifier(type)} {${quoteIdentifier("__anvia_key")}: row.key${namespaceMapEntry2(namespace)}})
 ${propertySet}
 SET e.${quoteIdentifier("__anvia_key")} = row.key,
     e.${quoteIdentifier("__anvia_graph")} = $graph,
+    e.${quoteIdentifier("__anvia_namespace")} = coalesce($namespace, e.${quoteIdentifier("__anvia_namespace")}),
     e.${quoteIdentifier("__anvia_embedding")} = ${embedding},
     e.${quoteIdentifier("__anvia_source_document_ids")} = reduce(all = existingDocumentIds, id IN row.sourceDocumentIds | CASE WHEN id IN all THEN all ELSE all + id END),
     e.${quoteIdentifier("__anvia_source_chunk_ids")} = reduce(all = existingChunkIds, id IN row.sourceChunkIds | CASE WHEN id IN all THEN all ELSE all + id END)`,
-      { rows, graph: graphName }
+      managedParameters(graphName, namespace, { rows })
     );
   }
 }
-async function assertEntityConflicts(transaction, entityLabel, rows) {
+async function assertEntityConflicts(transaction, graphName, namespace, entityLabel, rows) {
   const result = await transaction.run(
-    `UNWIND $keys AS key MATCH (e:${quoteIdentifier(entityLabel)} {${quoteIdentifier("__anvia_key")}: key}) RETURN key, properties(e) AS properties`,
-    { keys: rows.map((row) => row.key) }
+    `UNWIND $keys AS key MATCH (e:${quoteIdentifier(entityLabel)} {${quoteIdentifier("__anvia_key")}: key${namespaceMapEntry2(namespace)}}) WHERE e.${quoteIdentifier("__anvia_graph")} = $graph RETURN key, properties(e) AS properties`,
+    managedParameters(graphName, namespace, { keys: rows.map((row) => row.key) })
   );
   const incoming = new Map(rows.map((row) => [row.key, row.properties]));
   for (const record of result.records) {
@@ -1379,16 +1494,17 @@ async function assertEntityConflicts(transaction, entityLabel, rows) {
     }
   }
 }
-async function writeMentions(transaction, labels, mentions) {
+async function writeMentions(transaction, graphName, namespace, labels, mentions) {
   if (mentions.length === 0) return;
   await transaction.run(
     `UNWIND $rows AS row
-MATCH (c:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.chunkId}), (e:${quoteIdentifier(labels.entity)} {${quoteIdentifier("__anvia_key")}: row.entityKey})
-MERGE (c)-[:${quoteIdentifier("ANVIA_MENTIONS")}]->(e)`,
-    { rows: mentions }
+MATCH (c:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.chunkId${namespaceMapEntry2(namespace)}}), (e:${quoteIdentifier(labels.entity)} {${quoteIdentifier("__anvia_key")}: row.entityKey${namespaceMapEntry2(namespace)}})
+${namespace === void 0 ? "" : `WHERE c.${quoteIdentifier("__anvia_graph")} = $graph AND e.${quoteIdentifier("__anvia_graph")} = $graph`}
+MERGE (c)-[:${quoteIdentifier("ANVIA_MENTIONS")}${tenantRelationshipProperties2(namespace)}]->(e)`,
+    managedParameters(graphName, namespace, { rows: mentions })
   );
 }
-async function writeRelationships(transaction, graphName, entityLabel, relationships, conflict, sourceDocuments) {
+async function writeRelationships(transaction, graphName, namespace, entityLabel, relationships, conflict, sourceDocuments) {
   const grouped = groupBy(relationships, (relationship) => relationship.type);
   for (const [type, values] of grouped) {
     const rows = values.map((relationship) => ({
@@ -1401,8 +1517,8 @@ async function writeRelationships(transaction, graphName, entityLabel, relations
     }));
     if (conflict === "error") {
       const existing = await transaction.run(
-        `UNWIND $keys AS key MATCH ()-[r:${quoteIdentifier(type)} {${quoteIdentifier("__anvia_key")}: key}]->() RETURN key, properties(r) AS properties`,
-        { keys: rows.map((row) => row.key) }
+        `UNWIND $keys AS key MATCH ()-[r:${quoteIdentifier(type)} {${quoteIdentifier("__anvia_key")}: key${namespaceMapEntry2(namespace)}}]->() WHERE r.${quoteIdentifier("__anvia_graph")} = $graph RETURN key, properties(r) AS properties`,
+        managedParameters(graphName, namespace, { keys: rows.map((row) => row.key) })
       );
       const incoming = new Map(rows.map((row) => [row.key, row.properties]));
       for (const record of existing.records) {
@@ -1415,14 +1531,16 @@ async function writeRelationships(transaction, graphName, entityLabel, relations
     const propertySet = conflictPropertySet("r", conflict);
     await transaction.run(
       `UNWIND $rows AS row
-MATCH (a:${quoteIdentifier(entityLabel)} {${quoteIdentifier("__anvia_key")}: row.from}), (b:${quoteIdentifier(entityLabel)} {${quoteIdentifier("__anvia_key")}: row.to})
-MERGE (a)-[r:${quoteIdentifier(type)} {${quoteIdentifier("__anvia_key")}: row.key}]->(b)
+MATCH (a:${quoteIdentifier(entityLabel)} {${quoteIdentifier("__anvia_key")}: row.from${namespaceMapEntry2(namespace)}}), (b:${quoteIdentifier(entityLabel)} {${quoteIdentifier("__anvia_key")}: row.to${namespaceMapEntry2(namespace)}})
+WHERE a.${quoteIdentifier("__anvia_graph")} = $graph AND b.${quoteIdentifier("__anvia_graph")} = $graph
+MERGE (a)-[r:${quoteIdentifier(type)} {${quoteIdentifier("__anvia_key")}: row.key${namespaceMapEntry2(namespace)}}]->(b)
 ${propertySet}
 SET r.${quoteIdentifier("__anvia_key")} = row.key,
     r.${quoteIdentifier("__anvia_graph")} = $graph,
+    r.${quoteIdentifier("__anvia_namespace")} = coalesce($namespace, r.${quoteIdentifier("__anvia_namespace")}),
     r.${quoteIdentifier("__anvia_source_document_ids")} = reduce(all = existingDocumentIds, id IN row.sourceDocumentIds | CASE WHEN id IN all THEN all ELSE all + id END),
     r.${quoteIdentifier("__anvia_source_chunk_ids")} = reduce(all = existingChunkIds, id IN row.sourceChunkIds | CASE WHEN id IN all THEN all ELSE all + id END)`,
-      { rows, graph: graphName }
+      managedParameters(graphName, namespace, { rows })
     );
   }
 }
@@ -1479,8 +1597,13 @@ export {
   positiveInteger,
   finiteScore,
   strictProperties,
+  managedScopeParameters,
+  managedScopePredicate,
+  tenantScopePredicate,
+  managedPathPredicate,
+  neo4jTenantScope,
   Neo4jKnowledgeGraphBase,
   Neo4jKnowledgeGraph,
   ManagedNeo4jKnowledgeGraph
 };
-//# sourceMappingURL=chunk-QNHOT7P2.js.map
+//# sourceMappingURL=chunk-EUZ5C6OC.js.map