@utaba/deep-memory-storage-cosmosdb 0.5.1 → 0.7.0

package/dist/index.cjs

@@ -672,12 +672,19 @@ async function updateEntity(conn, repositoryId, entityId, updates) {
     bindings[paramName] = value;
     propParts.push(`.property('${key}', ${paramName})`);
   };
+  const dropProp = (key) => {
+    propParts.push(`.sideEffect(properties('${key}').drop())`);
+  };
+  if (updates.entityType !== void 0) addProp("entityType", updates.entityType);
   if (updates.label !== void 0) addProp("entityLabel", updates.label);
   if (updates.slug !== void 0) addProp("slug", updates.slug);
-  if (updates.summary !== void 0) addProp("summary", updates.summary);
+  if (updates.summary === null) dropProp("summary");
+  else if (updates.summary !== void 0) addProp("summary", updates.summary);
   if (updates.properties !== void 0) addProp("properties", JSON.stringify(updates.properties));
-  if (updates.data !== void 0) addProp("data", updates.data);
-  if (updates.dataFormat !== void 0) addProp("dataFormat", updates.dataFormat);
+  if (updates.data === null) dropProp("data");
+  else if (updates.data !== void 0) addProp("data", updates.data);
+  if (updates.dataFormat === null) dropProp("dataFormat");
+  else if (updates.dataFormat !== void 0) addProp("dataFormat", updates.dataFormat);
   if (updates.embedding !== void 0) addProp("embedding", JSON.stringify(updates.embedding));
   addProp("modifiedBy", updates.provenance.modifiedBy);
   addProp("modifiedByType", updates.provenance.modifiedByType);
@@ -725,9 +732,37 @@ async function findEntities(conn, repositoryId, query) {
     });
     filterClause += `.has('entityType', within(${typeParams.join(", ")}))`;
   }
-  if (query.searchTerm) {
-    bindings["searchTerm"] = query.searchTerm.toLowerCase();
-    filterClause += ".has('slug', containing(searchTerm))";
+  const hasPropertyFilter = query.properties != null && Object.keys(query.properties).length > 0;
+  const needsClientFilter = Boolean(query.searchTerm) || hasPropertyFilter;
+  if (needsClientFilter) {
+    const dataResult2 = await conn.submit(
+      `g.V()${filterClause}.valueMap(true)`,
+      bindings
+    );
+    let items2 = dataResult2.items.map(entityFromGremlin);
+    if (query.searchTerm) {
+      const term = query.searchTerm.toLowerCase();
+      items2 = items2.filter(
+        (e) => e.label.toLowerCase().includes(term) || e.slug.toLowerCase().includes(term) || e.summary != null && e.summary.toLowerCase().includes(term)
+      );
+    }
+    if (hasPropertyFilter) {
+      items2 = items2.filter((entity) => {
+        for (const [key, value] of Object.entries(query.properties)) {
+          if (entity.properties[key] !== value) return false;
+        }
+        return true;
+      });
+    }
+    const total2 = items2.length;
+    const paged = items2.slice(query.offset, query.offset + query.limit);
+    return {
+      items: paged,
+      total: total2,
+      hasMore: query.offset + query.limit < total2,
+      limit: query.limit,
+      offset: query.offset
+    };
   }
   const countResult = await conn.submit(
     `g.V()${filterClause}.count()`,
@@ -740,15 +775,7 @@ async function findEntities(conn, repositoryId, query) {
     `g.V()${filterClause}.range(rangeStart, rangeEnd).valueMap(true)`,
     bindings
   );
-  let items = dataResult.items.map(entityFromGremlin);
-  if (query.properties && Object.keys(query.properties).length > 0) {
-    items = items.filter((entity) => {
-      for (const [key, value] of Object.entries(query.properties)) {
-        if (entity.properties[key] !== value) return false;
-      }
-      return true;
-    });
-  }
+  const items = dataResult.items.map(entityFromGremlin);
   return {
     items,
     total,
@@ -1319,6 +1346,23 @@ var CosmosDbProvider = class {
       rejectUnauthorized: config.rejectUnauthorized
     });
   }
+  /**
+   * Reject any repositoryId that is not a valid v4 UUID.
+   *
+   * Every partition-scoped query filters on repositoryId. Since repositoryId is
+   * the CosmosDB partition key, a predicate with a different value would target
+   * a different partition. Strict format validation at the provider boundary
+   * prevents injection (e.g. strings containing quotes or Gremlin syntax) from
+   * ever reaching query construction.
+   */
+  assertValidRepositoryId(repositoryId) {
+    if (!(0, import_deep_memory5.isValidUuid)(repositoryId)) {
+      throw new import_deep_memory5.InvalidInputError(
+        "repositoryId",
+        `repositoryId must be a valid v4 UUID; got '${repositoryId}'`
+      );
+    }
+  }
   // ─── Lifecycle ─────────────────────────────────────────────────────
   async initialize() {
     await this.conn.connect();
@@ -1404,93 +1448,195 @@ var CosmosDbProvider = class {
   }
   // ─── Repository ────────────────────────────────────────────────────
   async createRepository(config) {
+    this.assertValidRepositoryId(config.repositoryId);
     return createRepository(this.conn, config);
   }
   async getRepository(repositoryId) {
+    this.assertValidRepositoryId(repositoryId);
     return getRepository(this.conn, repositoryId);
   }
   async listRepositories(filter) {
     return listRepositories(this.conn, filter);
   }
   async updateRepository(repositoryId, updates) {
+    this.assertValidRepositoryId(repositoryId);
     return updateRepository(this.conn, repositoryId, updates);
   }
   async deleteRepository(repositoryId, onProgress) {
+    this.assertValidRepositoryId(repositoryId);
     return deleteRepository(this.conn, repositoryId, onProgress);
   }
   async deleteAllContents(repositoryId, onProgress) {
+    this.assertValidRepositoryId(repositoryId);
     return deleteAllContents(this.conn, repositoryId, onProgress);
   }
   async getRepositoryStats(repositoryId) {
+    this.assertValidRepositoryId(repositoryId);
     return getRepositoryStats(this.conn, repositoryId);
   }
   // ─── Vocabulary ────────────────────────────────────────────────────
   async getVocabulary(repositoryId) {
+    this.assertValidRepositoryId(repositoryId);
     return getVocabulary(this.conn, repositoryId);
   }
   async saveVocabulary(repositoryId, vocabulary) {
+    this.assertValidRepositoryId(repositoryId);
     return saveVocabulary(this.conn, repositoryId, vocabulary);
   }
   async getVocabularyChangeLog(repositoryId, options) {
+    this.assertValidRepositoryId(repositoryId);
     return getVocabularyChangeLog(this.conn, repositoryId, options);
   }
   // ─── Entities ──────────────────────────────────────────────────────
   async createEntity(repositoryId, entity) {
+    this.assertValidRepositoryId(repositoryId);
     return createEntity(this.conn, repositoryId, entity);
   }
   async getEntity(repositoryId, entityId) {
+    this.assertValidRepositoryId(repositoryId);
     return getEntity(this.conn, repositoryId, entityId);
   }
   async getEntityBySlug(repositoryId, slug) {
+    this.assertValidRepositoryId(repositoryId);
     return getEntityBySlug(this.conn, repositoryId, slug);
   }
   async getEntities(repositoryId, entityIds) {
+    this.assertValidRepositoryId(repositoryId);
     return getEntities(this.conn, repositoryId, entityIds);
   }
   async updateEntity(repositoryId, entityId, updates) {
+    this.assertValidRepositoryId(repositoryId);
     return updateEntity(this.conn, repositoryId, entityId, updates);
   }
   async deleteEntity(repositoryId, entityId) {
+    this.assertValidRepositoryId(repositoryId);
     return deleteEntity(this.conn, repositoryId, entityId);
   }
+  async deleteEntities(repositoryId, ids) {
+    if (ids.length === 0) return { deleted: [], notFound: [] };
+    this.assertValidRepositoryId(repositoryId);
+    const deleted = [];
+    const CHUNK = 100;
+    for (let i = 0; i < ids.length; i += CHUNK) {
+      const chunk = ids.slice(i, i + CHUNK);
+      const bindings = { rid: repositoryId };
+      const idParams = [];
+      for (let j = 0; j < chunk.length; j++) {
+        const p = `id${j}`;
+        bindings[p] = chunk[j];
+        idParams.push(p);
+      }
+      const withinExpr = `P.within(${idParams.join(", ")})`;
+      const existResult = await this.conn.submit(
+        `g.V().has('repositoryId', rid).has('id', ${withinExpr}).has('entityType').values('id')`,
+        bindings
+      );
+      const found = existResult.items;
+      if (found.length > 0) {
+        const dropBindings = { rid: repositoryId };
+        const dropIdParams = [];
+        for (let j = 0; j < found.length; j++) {
+          const p = `did${j}`;
+          dropBindings[p] = found[j];
+          dropIdParams.push(p);
+        }
+        const dropWithinExpr = `P.within(${dropIdParams.join(", ")})`;
+        await this.conn.submit(
+          `g.V().has('repositoryId', rid).has('id', ${dropWithinExpr}).has('entityType').drop()`,
+          dropBindings
+        );
+        deleted.push(...found);
+      }
+    }
+    const deletedSet = new Set(deleted);
+    return { deleted, notFound: ids.filter((id) => !deletedSet.has(id)) };
+  }
   async deleteEntitiesByType(repositoryId, entityType) {
+    this.assertValidRepositoryId(repositoryId);
     return deleteEntitiesByType(this.conn, repositoryId, entityType);
   }
   async findEntities(repositoryId, query) {
+    this.assertValidRepositoryId(repositoryId);
     return findEntities(this.conn, repositoryId, query);
   }
   // ─── Relationships ─────────────────────────────────────────────────
   async createRelationship(repositoryId, relationship) {
+    this.assertValidRepositoryId(repositoryId);
     return createRelationship(this.conn, repositoryId, relationship);
   }
   async getRelationship(repositoryId, relationshipId) {
+    this.assertValidRepositoryId(repositoryId);
     return getRelationship(this.conn, repositoryId, relationshipId);
   }
   async getEntityRelationships(repositoryId, entityId, options) {
+    this.assertValidRepositoryId(repositoryId);
     return getEntityRelationships(this.conn, repositoryId, entityId, options);
   }
   async deleteRelationship(repositoryId, relationshipId) {
+    this.assertValidRepositoryId(repositoryId);
     return deleteRelationship(this.conn, repositoryId, relationshipId);
   }
+  async deleteRelationships(repositoryId, ids) {
+    if (ids.length === 0) return { deleted: [], notFound: [] };
+    this.assertValidRepositoryId(repositoryId);
+    const deleted = [];
+    const CHUNK = 100;
+    for (let i = 0; i < ids.length; i += CHUNK) {
+      const chunk = ids.slice(i, i + CHUNK);
+      const bindings = { rid: repositoryId };
+      const idParams = [];
+      for (let j = 0; j < chunk.length; j++) {
+        const p = `id${j}`;
+        bindings[p] = chunk[j];
+        idParams.push(p);
+      }
+      const withinExpr = `P.within(${idParams.join(", ")})`;
+      const existResult = await this.conn.submit(
+        `g.E().has('repositoryId', rid).has('id', ${withinExpr}).values('id')`,
+        bindings
+      );
+      const found = existResult.items;
+      if (found.length > 0) {
+        await cosmosRestBatchDelete(
+          this.getRestEndpoint(),
+          this.config.key,
+          this.config.database,
+          this.config.container,
+          repositoryId,
+          found,
+          this.config.rejectUnauthorized ?? true
+        );
+        deleted.push(...found);
+      }
+    }
+    const deletedSet = new Set(deleted);
+    return { deleted, notFound: ids.filter((id) => !deletedSet.has(id)) };
+  }
   async deleteRelationshipsByType(repositoryId, relationshipType) {
+    this.assertValidRepositoryId(repositoryId);
     return deleteRelationshipsByType(this.conn, repositoryId, relationshipType);
   }
   // ─── Graph Traversal (StorageProvider) ─────────────────────────────
   async exploreNeighborhood(repositoryId, entityId, options) {
+    this.assertValidRepositoryId(repositoryId);
     return exploreNeighborhood(this.conn, repositoryId, entityId, options);
   }
   async findPaths(repositoryId, sourceId, targetId, options) {
+    this.assertValidRepositoryId(repositoryId);
     return findPaths(this.conn, repositoryId, sourceId, targetId, options);
   }
   // ─── Timeline ──────────────────────────────────────────────────────
   async getTimeline(repositoryId, entityId, options) {
+    this.assertValidRepositoryId(repositoryId);
     return getTimeline(this.conn, repositoryId, entityId, options);
   }
   // ─── Bulk Operations ───────────────────────────────────────────────
   exportAll(repositoryId) {
+    this.assertValidRepositoryId(repositoryId);
     return exportAll(this.conn, repositoryId);
   }
   async importBulk(repositoryId, data, options) {
+    this.assertValidRepositoryId(repositoryId);
     return importBulk(this.conn, repositoryId, data, options);
   }
   // ─── GraphTraversalProvider ────────────────────────────────────────
@@ -1507,17 +1653,20 @@ var CosmosDbProvider = class {
       supportsRelationshipSummary: false
     };
   }
-  async traverse(repositoryId, spec, compiledQuery) {
+  async traverse(repositoryId, spec) {
+    this.assertValidRepositoryId(repositoryId);
     const startTime = Date.now();
     const vocabulary = await this.getVocabulary(repositoryId);
-    const compiled = compiledQuery ? { query: compiledQuery, params: {}, estimatedFanOut: 100 } : this.compiler.compile(spec, vocabulary);
+    const compiled = this.compiler.compile(spec, vocabulary);
     const scopedQuery = compiled.query.replace(
       "g.V()",
-      `g.V().has('repositoryId', '${repositoryId}')`
+      "g.V().has('repositoryId', pRid)"
     );
+    const scopedParams = { ...compiled.params, pRid: repositoryId };
     try {
-      const result = await this.conn.submit(scopedQuery, compiled.params);
+      const result = await this.conn.submit(scopedQuery, scopedParams);
       const executionTimeMs = Date.now() - startTime;
+      const detailLevel = spec.detailLevel ?? "summary";
       const entities = [];
       const relationships = [];
       const paths = [];
@@ -1529,7 +1678,8 @@ var CosmosDbProvider = class {
             for (const obj of pathData.objects) {
               const props = obj;
               if (props["entityType"]) {
-                pathEntities.push(entityFromGremlin(props));
+                const stored = entityFromGremlin(props);
+                pathEntities.push((0, import_deep_memory5.projectEntity)(stored, detailLevel));
               }
             }
             if (pathEntities.length > 0) {
@@ -1543,8 +1693,8 @@ var CosmosDbProvider = class {
         }
       } else {
         for (const item of result.items) {
-          const entity = entityFromGremlin(item);
-          entities.push(entity);
+          const stored = entityFromGremlin(item);
+          entities.push((0, import_deep_memory5.projectEntity)(stored, detailLevel));
         }
       }
       const limit = spec.limit ?? 50;
@@ -1576,6 +1726,27 @@ var CosmosDbProvider = class {
       );
     }
   }
+  /**
+   * Execute a raw Gremlin query with caller-supplied bindings.
+   *
+   * ⚠️  ELEVATED PRIVILEGE — SYSTEM-LEVEL OPERATION ⚠️
+   *
+   * This method is an unscoped pass-through: it does not filter by repository,
+   * does not inject the partition key, and performs no validation on the query
+   * string. A single call can read or mutate any vertex or edge in the
+   * container regardless of which repository (partition) it belongs to.
+   *
+   * DO NOT expose this method to AI agents, end users, or any untrusted caller.
+   * It is intended for:
+   *   - administrative tooling (migrations, diagnostics, repairs)
+   *   - internal library operations that need cross-partition reach
+   *
+   * `repositoryId` is accepted for interface symmetry but is intentionally
+   * ignored here — the caller is trusted to scope the query themselves.
+   *
+   * For agent-facing graph queries use {@link traverse}, which enforces the
+   * repositoryId partition predicate.
+   */
   async executeNativeQuery(_repositoryId, query, params) {
     const startTime = Date.now();
     try {
@@ -1654,6 +1825,32 @@ async function cosmosRestPut(restBase, key, urlPath, resourceLink, resourceType,
   const text = await response.text();
   throw new Error(`CosmosDB REST ${response.status}: ${text}`);
 }
+async function cosmosRestBatchDelete(restBase, key, database, container, partitionKeyValue, ids, rejectUnauthorized) {
+  const resourceLink = `dbs/${database}/colls/${container}`;
+  const date = (/* @__PURE__ */ new Date()).toUTCString();
+  const token = cosmosAuthToken("post", "docs", resourceLink, date, key);
+  if (!rejectUnauthorized) {
+    process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = "0";
+  }
+  const ops = ids.map((id) => ({ operationType: "Delete", id }));
+  const response = await fetch(`${restBase}/${resourceLink}/docs`, {
+    method: "POST",
+    headers: {
+      "Authorization": token,
+      "x-ms-version": "2020-07-15",
+      "x-ms-date": date,
+      "Content-Type": "application/json",
+      "x-ms-documentdb-partitionkey": JSON.stringify([partitionKeyValue]),
+      "x-ms-cosmos-is-batch-request": "true",
+      "x-ms-cosmos-batch-atomic": "true"
+    },
+    body: JSON.stringify(ops)
+  });
+  if (response.status !== 200 && response.status !== 207) {
+    const text = await response.text();
+    throw new import_deep_memory5.ProviderError(`CosmosDB batch delete failed (${response.status}): ${text}`);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CosmosDbConnection,