@workglow/storage 0.0.77 → 0.0.79

package/README.md

@@ -327,9 +327,15 @@ const userCount = await userRepo.size();
 const engineeringUsers = await userRepo.search({ department: "Engineering" });
 const adultUsers = await userRepo.search({ age: 25 }); // Exact match
 
-// Delete by search criteria
-await userRepo.deleteSearch("department", "Sales", "=");
-await userRepo.deleteSearch("age", 65, ">="); // Delete users 65 and older
+// Delete by search criteria (supports multiple columns)
+await userRepo.deleteSearch({ department: "Sales" }); // Equality
+await userRepo.deleteSearch({ age: { value: 65, operator: ">=" } }); // Delete users 65 and older
+
+// Multiple criteria (AND logic)
+await userRepo.deleteSearch({
+  department: "Sales",
+  age: { value: 30, operator: "<" },
+}); // Delete young Sales employees
 ```
 
 #### Environment-Specific Tabular Storage
@@ -629,11 +635,7 @@ interface ITabularRepository<Schema, PrimaryKeyNames, Entity, PrimaryKey, Value>
 
   // Search operations
   search(criteria: Partial<Entity>): Promise<Entity[] | undefined>;
-  deleteSearch(
-    column: keyof Entity,
-    value: any,
-    operator: "=" | "<" | "<=" | ">" | ">="
-  ): Promise<void>;
+  deleteSearch(criteria: DeleteSearchCriteria<Entity>): Promise<void>;
 
   // Event handling
   on(event: "put" | "get" | "search" | "delete" | "clearall", callback: Function): void;
@@ -644,6 +646,37 @@ interface ITabularRepository<Schema, PrimaryKeyNames, Entity, PrimaryKey, Value>
 }
 ```
 
+#### DeleteSearchCriteria<Entity>
+
+The `deleteSearch` method accepts a criteria object that supports multiple columns with optional comparison operators:
+
+```typescript
+// Type definitions
+type SearchOperator = "=" | "<" | "<=" | ">" | ">=";
+
+interface SearchCondition<T> {
+  readonly value: T;
+  readonly operator: SearchOperator;
+}
+
+type DeleteSearchCriteria<Entity> = {
+  readonly [K in keyof Entity]?: Entity[K] | SearchCondition<Entity[K]>;
+};
+
+// Usage examples
+// Equality match (direct value)
+await repo.deleteSearch({ category: "electronics" });
+
+// With comparison operator
+await repo.deleteSearch({ createdAt: { value: date, operator: "<" } });
+
+// Multiple criteria (AND logic)
+await repo.deleteSearch({
+  category: "electronics",
+  value: { value: 100, operator: ">=" },
+});
+```
+
 ### IQueueStorage<Input, Output>
 
 Core interface for job queue storage:

package/dist/browser.js

@@ -7,6 +7,11 @@ import {
   makeFingerprint as makeFingerprint2
 } from "@workglow/util";
 
+// src/tabular/ITabularRepository.ts
+function isSearchCondition(value) {
+  return typeof value === "object" && value !== null && "value" in value && "operator" in value && typeof value.operator === "string";
+}
+
 // src/tabular/TabularRepository.ts
 import {
   createServiceToken,
@@ -258,24 +263,50 @@ class InMemoryTabularRepository extends TabularRepository {
   async size() {
     return this.values.size;
   }
-  async deleteSearch(column, value, operator = "=") {
-    const entries = this.values.entries();
+  async deleteSearch(criteria) {
+    const criteriaKeys = Object.keys(criteria);
+    if (criteriaKeys.length === 0) {
+      return;
+    }
+    const entries = Array.from(this.values.entries());
     const entriesToDelete = entries.filter(([_, entity]) => {
-      const columnValue = entity[column];
-      switch (operator) {
-        case "=":
-          return columnValue === value;
-        case "<":
-          return columnValue !== null && columnValue !== undefined && columnValue < value;
-        case "<=":
-          return columnValue !== null && columnValue !== undefined && columnValue <= value;
-        case ">":
-          return columnValue !== null && columnValue !== undefined && columnValue > value;
-        case ">=":
-          return columnValue !== null && columnValue !== undefined && columnValue >= value;
-        default:
-          return false;
+      for (const column of criteriaKeys) {
+        const criterion = criteria[column];
+        const columnValue = entity[column];
+        if (isSearchCondition(criterion)) {
+          const { value, operator } = criterion;
+          const v = value;
+          const cv = columnValue;
+          switch (operator) {
+            case "=":
+              if (cv !== v)
+                return false;
+              break;
+            case "<":
+              if (cv === null || cv === undefined || !(cv < v))
+                return false;
+              break;
+            case "<=":
+              if (cv === null || cv === undefined || !(cv <= v))
+                return false;
+              break;
+            case ">":
+              if (cv === null || cv === undefined || !(cv > v))
+                return false;
+              break;
+            case ">=":
+              if (cv === null || cv === undefined || !(cv >= v))
+                return false;
+              break;
+            default:
+              return false;
+          }
+        } else {
+          if (columnValue !== criterion)
+            return false;
+        }
       }
+      return true;
     });
     for (const [id, entity] of entriesToDelete) {
       this.values.delete(id);
@@ -417,10 +448,10 @@ class CachedTabularRepository extends TabularRepository {
     await this.initializeCache();
     return await this.durable.size();
   }
-  async deleteSearch(column, value, operator = "=") {
+  async deleteSearch(criteria) {
     await this.initializeCache();
-    await this.durable.deleteSearch(column, value, operator);
-    await this.cache.deleteSearch(column, value, operator);
+    await this.durable.deleteSearch(criteria);
+    await this.cache.deleteSearch(criteria);
   }
   async invalidateCache() {
     await this.cache.deleteAll();
@@ -1731,32 +1762,76 @@ class IndexedDbTabularRepository extends TabularRepository {
       request.onsuccess = () => resolve(request.result);
     });
   }
-  async deleteSearch(column, value, operator = "=") {
+  matchesCriteria(record, criteria) {
+    for (const column of Object.keys(criteria)) {
+      const criterion = criteria[column];
+      const recordValue = record[column];
+      let operator = "=";
+      let value;
+      if (isSearchCondition(criterion)) {
+        operator = criterion.operator;
+        value = criterion.value;
+      } else {
+        value = criterion;
+      }
+      if (operator !== "=" && (recordValue === null || recordValue === undefined)) {
+        return false;
+      }
+      switch (operator) {
+        case "=":
+          if (recordValue !== value)
+            return false;
+          break;
+        case "<":
+          if (!(recordValue < value))
+            return false;
+          break;
+        case "<=":
+          if (!(recordValue <= value))
+            return false;
+          break;
+        case ">":
+          if (!(recordValue > value))
+            return false;
+          break;
+        case ">=":
+          if (!(recordValue >= value))
+            return false;
+          break;
+        default:
+          return false;
+      }
+    }
+    return true;
+  }
+  async deleteSearch(criteria) {
+    const criteriaKeys = Object.keys(criteria);
+    if (criteriaKeys.length === 0) {
+      return;
+    }
     const db = await this.getDb();
     return new Promise(async (resolve, reject) => {
       try {
-        if (operator === "=") {
-          const searchKey = { [column]: value };
-          const recordsToDelete = await this.search(searchKey);
-          if (!recordsToDelete || recordsToDelete.length === 0) {
-            this.events.emit("delete", column);
-            this.hybridManager?.notifyLocalChange();
-            resolve();
+        const transaction = db.transaction(this.table, "readwrite");
+        const store = transaction.objectStore(this.table);
+        transaction.oncomplete = () => {
+          this.events.emit("delete", criteriaKeys[0]);
+          this.hybridManager?.notifyLocalChange();
+          resolve();
+        };
+        transaction.onerror = () => {
+          reject(transaction.error);
+        };
+        const getAllRequest = store.getAll();
+        getAllRequest.onsuccess = () => {
+          const allRecords = getAllRequest.result;
+          const recordsToDelete = allRecords.filter((record) => this.matchesCriteria(record, criteria));
+          if (recordsToDelete.length === 0) {
             return;
           }
-          const transaction = db.transaction(this.table, "readwrite");
-          const store = transaction.objectStore(this.table);
-          transaction.oncomplete = () => {
-            this.events.emit("delete", column);
-            this.hybridManager?.notifyLocalChange();
-            resolve();
-          };
-          transaction.onerror = () => {
-            reject(transaction.error);
-          };
           for (const record of recordsToDelete) {
-            const primaryKey = this.primaryKeyColumns().reduce((key, column2) => {
-              key[column2] = record[column2];
+            const primaryKey = this.primaryKeyColumns().reduce((key, col) => {
+              key[col] = record[col];
               return key;
             }, {});
             const request = store.delete(this.getIndexedKey(primaryKey));
@@ -1764,56 +1839,10 @@ class IndexedDbTabularRepository extends TabularRepository {
               console.error("Error deleting record:", request.error);
             };
           }
-        } else {
-          const transaction = db.transaction(this.table, "readwrite");
-          const store = transaction.objectStore(this.table);
-          transaction.oncomplete = () => {
-            this.events.emit("delete", column);
-            this.hybridManager?.notifyLocalChange();
-            resolve();
-          };
-          transaction.onerror = () => {
-            reject(transaction.error);
-          };
-          const getAllRequest = store.getAll();
-          getAllRequest.onsuccess = () => {
-            const allRecords = getAllRequest.result;
-            const recordsToDelete = allRecords.filter((record) => {
-              const recordValue = record[column];
-              if (recordValue === null || recordValue === undefined || value === null || value === undefined) {
-                return false;
-              }
-              switch (operator) {
-                case "<":
-                  return recordValue < value;
-                case "<=":
-                  return recordValue <= value;
-                case ">":
-                  return recordValue > value;
-                case ">=":
-                  return recordValue >= value;
-                default:
-                  return false;
-              }
-            });
-            if (recordsToDelete.length === 0) {
-              return;
-            }
-            for (const record of recordsToDelete) {
-              const primaryKey = this.primaryKeyColumns().reduce((key, column2) => {
-                key[column2] = record[column2];
-                return key;
-              }, {});
-              const request = store.delete(this.getIndexedKey(primaryKey));
-              request.onerror = () => {
-                console.error("Error deleting record:", request.error);
-              };
-            }
-          };
-          getAllRequest.onerror = () => {
-            reject(getAllRequest.error);
-          };
-        }
+        };
+        getAllRequest.onerror = () => {
+          reject(getAllRequest.error);
+        };
       } catch (error) {
         reject(error);
       }
@@ -1941,7 +1970,7 @@ class SharedInMemoryTabularRepository extends TabularRepository {
         await this.inMemoryRepo.deleteAll();
         break;
       case "DELETE_SEARCH":
-        await this.inMemoryRepo.deleteSearch(message.column, message.value, message.operator);
+        await this.inMemoryRepo.deleteSearch(message.criteria);
         break;
     }
   }
@@ -2002,13 +2031,11 @@ class SharedInMemoryTabularRepository extends TabularRepository {
   async size() {
     return await this.inMemoryRepo.size();
   }
-  async deleteSearch(column, value, operator = "=") {
-    await this.inMemoryRepo.deleteSearch(column, value, operator);
+  async deleteSearch(criteria) {
+    await this.inMemoryRepo.deleteSearch(criteria);
     this.broadcast({
       type: "DELETE_SEARCH",
-      column: String(column),
-      value,
-      operator
+      criteria
     });
   }
   subscribeToChanges(callback, options) {
@@ -2541,35 +2568,47 @@ class SupabaseTabularRepository extends BaseSqlTabularRepository {
       throw error;
     return count ?? 0;
   }
-  generateWhereClause(column, operator = "=") {
-    if (!(column in this.schema.properties)) {
-      throw new Error(`Schema must have a ${String(column)} field to use deleteSearch`);
+  async deleteSearch(criteria) {
+    const criteriaKeys = Object.keys(criteria);
+    if (criteriaKeys.length === 0) {
+      return;
     }
-    return `${String(column)} ${operator} $1`;
-  }
-  async deleteSearch(column, value, operator = "=") {
     let query = this.client.from(this.table).delete();
-    switch (operator) {
-      case "=":
-        query = query.eq(String(column), value);
-        break;
-      case "<":
-        query = query.lt(String(column), value);
-        break;
-      case "<=":
-        query = query.lte(String(column), value);
-        break;
-      case ">":
-        query = query.gt(String(column), value);
-        break;
-      case ">=":
-        query = query.gte(String(column), value);
-        break;
+    for (const column of criteriaKeys) {
+      if (!(column in this.schema.properties)) {
+        throw new Error(`Schema must have a ${String(column)} field to use deleteSearch`);
+      }
+      const criterion = criteria[column];
+      let operator = "=";
+      let value;
+      if (isSearchCondition(criterion)) {
+        operator = criterion.operator;
+        value = criterion.value;
+      } else {
+        value = criterion;
+      }
+      switch (operator) {
+        case "=":
+          query = query.eq(String(column), value);
+          break;
+        case "<":
+          query = query.lt(String(column), value);
+          break;
+        case "<=":
+          query = query.lte(String(column), value);
+          break;
+        case ">":
+          query = query.gt(String(column), value);
+          break;
+        case ">=":
+          query = query.gte(String(column), value);
+          break;
+      }
     }
     const { error } = await query;
     if (error)
       throw error;
-    this.events.emit("delete", column);
+    this.events.emit("delete", criteriaKeys[0]);
   }
   convertRealtimeRow(row) {
     const entity = { ...row };
@@ -4078,6 +4117,7 @@ class SupabaseRateLimiterStorage {
   }
 }
 export {
+  isSearchCondition,
   ensureIndexedDbTable,
   dropIndexedDbTable,
   TabularRepository,
@@ -4122,4 +4162,4 @@ export {
   CACHED_TABULAR_REPOSITORY
 };
 
-//# debugId=8E3873F6AB0E1B4764756E2164756E21
+//# debugId=DD99166332ED2CB564756E2164756E21