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

package/dist/index.d.cts

@@ -66,6 +66,10 @@ declare class CosmosDbProvider implements StorageProvider, GraphTraversalProvide
     getEntities(repositoryId: string, entityIds: string[]): Promise<Map<string, StoredEntity>>;
     updateEntity(repositoryId: string, entityId: string, updates: StoredEntityUpdate): Promise<StoredEntity>;
     deleteEntity(repositoryId: string, entityId: string): Promise<void>;
+    deleteEntities(repositoryId: string, ids: string[]): Promise<{
+        deleted: string[];
+        notFound: string[];
+    }>;
     deleteEntitiesByType(repositoryId: string, entityType: string): Promise<{
         deletedEntities: number;
         deletedRelationships: number;
@@ -75,6 +79,10 @@ declare class CosmosDbProvider implements StorageProvider, GraphTraversalProvide
     getRelationship(repositoryId: string, relationshipId: string): Promise<StoredRelationship | null>;
     getEntityRelationships(repositoryId: string, entityId: string, options?: RelationshipQueryOptions): Promise<PaginatedResult<StoredRelationship>>;
     deleteRelationship(repositoryId: string, relationshipId: string): Promise<void>;
+    deleteRelationships(repositoryId: string, ids: string[]): Promise<{
+        deleted: string[];
+        notFound: string[];
+    }>;
     deleteRelationshipsByType(repositoryId: string, relationshipType: string): Promise<{
         deletedRelationships: number;
     }>;

package/dist/index.d.ts

@@ -66,6 +66,10 @@ declare class CosmosDbProvider implements StorageProvider, GraphTraversalProvide
     getEntities(repositoryId: string, entityIds: string[]): Promise<Map<string, StoredEntity>>;
     updateEntity(repositoryId: string, entityId: string, updates: StoredEntityUpdate): Promise<StoredEntity>;
     deleteEntity(repositoryId: string, entityId: string): Promise<void>;
+    deleteEntities(repositoryId: string, ids: string[]): Promise<{
+        deleted: string[];
+        notFound: string[];
+    }>;
     deleteEntitiesByType(repositoryId: string, entityType: string): Promise<{
         deletedEntities: number;
         deletedRelationships: number;
@@ -75,6 +79,10 @@ declare class CosmosDbProvider implements StorageProvider, GraphTraversalProvide
     getRelationship(repositoryId: string, relationshipId: string): Promise<StoredRelationship | null>;
     getEntityRelationships(repositoryId: string, entityId: string, options?: RelationshipQueryOptions): Promise<PaginatedResult<StoredRelationship>>;
     deleteRelationship(repositoryId: string, relationshipId: string): Promise<void>;
+    deleteRelationships(repositoryId: string, ids: string[]): Promise<{
+        deleted: string[];
+        notFound: string[];
+    }>;
     deleteRelationshipsByType(repositoryId: string, relationshipType: string): Promise<{
         deletedRelationships: number;
     }>;

package/dist/index.js

@@ -635,12 +635,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);
@@ -688,9 +695,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()`,
@@ -703,15 +738,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,
@@ -1448,6 +1475,45 @@ var CosmosDbProvider = class {
     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);
@@ -1473,6 +1539,42 @@ var CosmosDbProvider = class {
     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);
@@ -1686,6 +1788,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 ProviderError(`CosmosDB batch delete failed (${response.status}): ${text}`);
+  }
+}
 export {
   CosmosDbConnection,
   CosmosDbProvider