@workglow/storage 0.0.104 → 0.0.105

package/dist/node.js

@@ -4,6 +4,58 @@ import {
   EventEmitter,
   makeFingerprint
 } from "@workglow/util";
+
+// src/tabular/ITabularStorage.ts
+function isSearchCondition(value) {
+  return typeof value === "object" && value !== null && "value" in value && "operator" in value && typeof value.operator === "string";
+}
+
+// src/tabular/StorageError.ts
+import { BaseError } from "@workglow/util";
+
+class StorageError extends BaseError {
+  static type = "StorageError";
+  constructor(message) {
+    super(message);
+  }
+}
+
+class StorageValidationError extends StorageError {
+  static type = "StorageValidationError";
+  constructor(message) {
+    super(message);
+  }
+}
+
+class StorageEmptyCriteriaError extends StorageValidationError {
+  static type = "StorageEmptyCriteriaError";
+  constructor() {
+    super("Query criteria must not be empty. Use getAll() to retrieve all records.");
+  }
+}
+
+class StorageInvalidLimitError extends StorageValidationError {
+  static type = "StorageInvalidLimitError";
+  constructor(limit) {
+    super(`Query limit must be greater than 0, got ${limit}`);
+  }
+}
+
+class StorageInvalidColumnError extends StorageValidationError {
+  static type = "StorageInvalidColumnError";
+  constructor(column) {
+    super(`Column "${column}" does not exist in the schema`);
+  }
+}
+
+class StorageUnsupportedError extends StorageError {
+  static type = "StorageUnsupportedError";
+  constructor(operation, backend) {
+    super(`${operation} is not supported for ${backend}`);
+  }
+}
+
+// src/tabular/BaseTabularStorage.ts
 var TABULAR_REPOSITORY = createServiceToken("storage.tabularRepository");
 
 class BaseTabularStorage {
@@ -162,6 +214,62 @@ class BaseTabularStorage {
   subscribeToChanges(_callback, _options) {
     throw new Error(`subscribeToChanges is not implemented for ${this.constructor.name}. ` + `All concrete repository implementations should override this method.`);
   }
+  validateQueryParams(criteria, options) {
+    const criteriaKeys = Object.keys(criteria);
+    if (criteriaKeys.length === 0) {
+      throw new StorageEmptyCriteriaError;
+    }
+    if (options?.limit !== undefined && options.limit <= 0) {
+      throw new StorageInvalidLimitError(options.limit);
+    }
+    if (options?.offset !== undefined && options.offset < 0) {
+      throw new StorageValidationError(`Query offset must be non-negative, got ${options.offset}`);
+    }
+    for (const column of criteriaKeys) {
+      if (!(column in this.schema.properties)) {
+        throw new StorageInvalidColumnError(String(column));
+      }
+      const criterion = criteria[column];
+      if (isSearchCondition(criterion)) {
+        const validOperators = ["=", "<", "<=", ">", ">="];
+        if (!validOperators.includes(criterion.operator)) {
+          throw new StorageValidationError(`Invalid operator "${criterion.operator}". Must be one of: ${validOperators.join(", ")}`);
+        }
+      }
+    }
+    if (options?.orderBy) {
+      const validDirections = ["ASC", "DESC"];
+      for (const { column, direction } of options.orderBy) {
+        if (!(column in this.schema.properties)) {
+          throw new StorageInvalidColumnError(String(column));
+        }
+        if (!validDirections.includes(direction)) {
+          throw new StorageValidationError(`Invalid sort direction "${direction}". Must be "ASC" or "DESC"`);
+        }
+      }
+    }
+  }
+  validateGetAllOptions(options) {
+    if (!options)
+      return;
+    if (options.limit !== undefined && options.limit <= 0) {
+      throw new StorageInvalidLimitError(options.limit);
+    }
+    if (options.offset !== undefined && options.offset < 0) {
+      throw new StorageValidationError(`Query offset must be non-negative, got ${options.offset}`);
+    }
+    if (options.orderBy) {
+      const validDirections = ["ASC", "DESC"];
+      for (const { column, direction } of options.orderBy) {
+        if (!(column in this.schema.properties)) {
+          throw new StorageInvalidColumnError(String(column));
+        }
+        if (!validDirections.includes(direction)) {
+          throw new StorageValidationError(`Invalid sort direction "${direction}". Must be "ASC" or "DESC"`);
+        }
+      }
+    }
+  }
   primaryKeyColumns() {
     const columns = [];
     for (const key of Object.keys(this.primaryKeySchema.properties)) {
@@ -279,7 +387,8 @@ class BaseTabularStorage {
 }
 // src/tabular/CachedTabularStorage.ts
 import {
-  createServiceToken as createServiceToken3
+  createServiceToken as createServiceToken3,
+  getLogger
 } from "@workglow/util";
 
 // src/tabular/InMemoryTabularStorage.ts
@@ -288,13 +397,6 @@ import {
   makeFingerprint as makeFingerprint2,
   uuid4
 } from "@workglow/util";
-
-// src/tabular/ITabularStorage.ts
-function isSearchCondition(value) {
-  return typeof value === "object" && value !== null && "value" in value && "operator" in value && typeof value.operator === "string";
-}
-
-// src/tabular/InMemoryTabularStorage.ts
 var MEMORY_TABULAR_REPOSITORY = createServiceToken2("storage.tabularRepository.inMemory");
 
 class InMemoryTabularStorage extends BaseTabularStorage {
@@ -348,24 +450,6 @@ class InMemoryTabularStorage extends BaseTabularStorage {
     this.events.emit("get", key, out);
     return out;
   }
-  async search(key) {
-    const searchKeys = Object.keys(key);
-    if (searchKeys.length === 0) {
-      return;
-    }
-    const bestIndex = this.findBestMatchingIndex(searchKeys);
-    if (!bestIndex) {
-      throw new Error(`No suitable index found for the search criteria, searching for ['${searchKeys.join("', '")}'] with pk ['${this.primaryKeyNames.join("', '")}'] and indexes ['${this.indexes.join("', '")}']`);
-    }
-    const results = Array.from(this.values.values()).filter((item) => Object.entries(key).every(([k, v]) => item[k] === v));
-    if (results.length > 0) {
-      this.events.emit("search", key, results);
-      return results;
-    } else {
-      this.events.emit("search", key, undefined);
-      return;
-    }
-  }
   async delete(value) {
     const { key } = this.separateKeyValueFromCombined(value);
     const id = await makeFingerprint2(key);
@@ -376,8 +460,34 @@ class InMemoryTabularStorage extends BaseTabularStorage {
     this.values.clear();
     this.events.emit("clearall");
   }
-  async getAll() {
-    const all = Array.from(this.values.values());
+  async getAll(options) {
+    this.validateGetAllOptions(options);
+    let all = Array.from(this.values.values());
+    if (options?.orderBy && options.orderBy.length > 0) {
+      all.sort((a, b) => {
+        for (const { column, direction } of options.orderBy) {
+          const aVal = a[column];
+          const bVal = b[column];
+          if (aVal == null && bVal == null)
+            continue;
+          if (aVal == null)
+            return direction === "ASC" ? -1 : 1;
+          if (bVal == null)
+            return direction === "ASC" ? 1 : -1;
+          if (aVal < bVal)
+            return direction === "ASC" ? -1 : 1;
+          if (aVal > bVal)
+            return direction === "ASC" ? 1 : -1;
+        }
+        return 0;
+      });
+    }
+    if (options?.offset !== undefined) {
+      all = all.slice(options.offset);
+    }
+    if (options?.limit !== undefined) {
+      all = all.slice(0, options.limit);
+    }
     return all.length > 0 ? all : undefined;
   }
   async size() {
@@ -450,6 +560,77 @@ class InMemoryTabularStorage extends BaseTabularStorage {
       this.events.emit("delete", key);
     }
   }
+  async query(criteria, options) {
+    this.validateQueryParams(criteria, options);
+    const criteriaKeys = Object.keys(criteria);
+    let results = Array.from(this.values.values()).filter((entity) => {
+      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;
+    });
+    if (options?.orderBy && options.orderBy.length > 0) {
+      results.sort((a, b) => {
+        for (const { column, direction } of options.orderBy) {
+          const aVal = a[column];
+          const bVal = b[column];
+          if (aVal == null && bVal == null)
+            continue;
+          if (aVal == null)
+            return direction === "ASC" ? -1 : 1;
+          if (bVal == null)
+            return direction === "ASC" ? 1 : -1;
+          if (aVal < bVal)
+            return direction === "ASC" ? -1 : 1;
+          if (aVal > bVal)
+            return direction === "ASC" ? 1 : -1;
+        }
+        return 0;
+      });
+    }
+    if (options?.offset !== undefined) {
+      results = results.slice(options.offset);
+    }
+    if (options?.limit !== undefined) {
+      results = results.slice(0, options.limit);
+    }
+    const result = results.length > 0 ? results : undefined;
+    this.events.emit("query", criteria, result);
+    return result;
+  }
   subscribeToChanges(callback, options) {
     const handlePut = (entity) => {
       callback({ type: "UPDATE", new: entity });
@@ -501,8 +682,8 @@ class CachedTabularStorage extends BaseTabularStorage {
     this.cache.on("get", (key, entity) => {
       this.events.emit("get", key, entity);
     });
-    this.cache.on("search", (key, entities) => {
-      this.events.emit("search", key, entities);
+    this.cache.on("query", (key, entities) => {
+      this.events.emit("query", key, entities);
     });
     this.cache.on("delete", (key) => {
       this.events.emit("delete", key);
@@ -521,7 +702,7 @@ class CachedTabularStorage extends BaseTabularStorage {
       }
       this.cacheInitialized = true;
     } catch (error) {
-      console.warn("Failed to initialize cache from durable repository:", error);
+      getLogger().warn("Failed to initialize cache from durable repository:", { error });
       this.cacheInitialized = true;
     }
   }
@@ -548,17 +729,6 @@ class CachedTabularStorage extends BaseTabularStorage {
     }
     return result;
   }
-  async search(key) {
-    await this.initializeCache();
-    let results = await this.cache.search(key);
-    if (results === undefined) {
-      results = await this.durable.search(key);
-      if (results && results.length > 0) {
-        await this.cache.putBulk(results);
-      }
-    }
-    return results;
-  }
   async delete(value) {
     await this.initializeCache();
     await this.durable.delete(value);
@@ -569,7 +739,7 @@ class CachedTabularStorage extends BaseTabularStorage {
     await this.durable.deleteAll();
     await this.cache.deleteAll();
   }
-  async getAll() {
+  async getAll(options) {
     await this.initializeCache();
     let results = await this.cache.getAll();
     if (!results || results.length === 0) {
@@ -578,6 +748,9 @@ class CachedTabularStorage extends BaseTabularStorage {
         await this.cache.putBulk(results);
       }
     }
+    if (options && results && results.length > 0) {
+      return await this.cache.getAll(options);
+    }
     return results;
   }
   async size() {
@@ -588,6 +761,10 @@ class CachedTabularStorage extends BaseTabularStorage {
     await this.initializeCache();
     return await this.durable.getBulk(offset, limit);
   }
+  async query(criteria, options) {
+    await this.initializeCache();
+    return await this.cache.query(criteria, options);
+  }
   async deleteSearch(criteria) {
     await this.initializeCache();
     await this.durable.deleteSearch(criteria);
@@ -708,7 +885,8 @@ class HuggingFaceTabularStorage extends BaseTabularStorage {
     this.events.emit("get", key, undefined);
     return;
   }
-  async getAll() {
+  async getAll(options) {
+    this.validateGetAllOptions(options);
     const allEntities = [];
     let offset = 0;
     const pageSize = 100;
@@ -723,7 +901,36 @@ class HuggingFaceTabularStorage extends BaseTabularStorage {
         break;
       }
     }
-    return allEntities.length > 0 ? allEntities : undefined;
+    if (allEntities.length === 0)
+      return;
+    let results = allEntities;
+    if (options?.orderBy && options.orderBy.length > 0) {
+      results = [...results];
+      results.sort((a, b) => {
+        for (const { column, direction } of options.orderBy) {
+          const aVal = a[column];
+          const bVal = b[column];
+          if (aVal == null && bVal == null)
+            continue;
+          if (aVal == null)
+            return direction === "ASC" ? -1 : 1;
+          if (bVal == null)
+            return direction === "ASC" ? 1 : -1;
+          if (aVal < bVal)
+            return direction === "ASC" ? -1 : 1;
+          if (aVal > bVal)
+            return direction === "ASC" ? 1 : -1;
+        }
+        return 0;
+      });
+    }
+    if (options?.offset !== undefined) {
+      results = results.slice(options.offset);
+    }
+    if (options?.limit !== undefined) {
+      results = results.slice(0, options.limit);
+    }
+    return results.length > 0 ? results : undefined;
   }
   async getBulk(offset, limit) {
     const data = await this.fetchApi("/rows", {
@@ -739,18 +946,40 @@ class HuggingFaceTabularStorage extends BaseTabularStorage {
     }
     return entities;
   }
-  async search(key) {
-    const searchKeys = Object.keys(key);
-    if (searchKeys.length === 0) {
-      return;
-    }
-    const bestIndex = this.findBestMatchingIndex(searchKeys);
-    if (!bestIndex) {
-      throw new Error(`No suitable index found for the search criteria, searching for ['${searchKeys.join("', '")}'] with pk ['${this.primaryKeyNames.join("', '")}'] and indexes ['${this.indexes.map((idx) => idx.join(",")).join("', '")}'`);
-    }
+  async size() {
+    const data = await this.fetchApi("/size", {});
+    return data.size.num_rows;
+  }
+  async put(_value) {
+    throw new Error("HuggingFaceTabularStorage is readonly");
+  }
+  async putBulk(_values) {
+    throw new Error("HuggingFaceTabularStorage is readonly");
+  }
+  async delete(_value) {
+    throw new Error("HuggingFaceTabularStorage is readonly");
+  }
+  async deleteAll() {
+    throw new Error("HuggingFaceTabularStorage is readonly");
+  }
+  async query(criteria, options) {
+    this.validateQueryParams(criteria, options);
     const whereConditions = [];
-    for (const [k, v] of Object.entries(key)) {
-      if (v !== undefined && v !== null) {
+    for (const [k, v] of Object.entries(criteria)) {
+      if (v === undefined || v === null)
+        continue;
+      if (isSearchCondition(v)) {
+        if (v.operator !== "=") {
+          throw new StorageUnsupportedError(`Operator "${v.operator}" in query`, "HuggingFaceTabularStorage");
+        }
+        const val = v.value;
+        if (typeof val === "string") {
+          const escaped = val.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+          whereConditions.push(`${k}='${escaped}'`);
+        } else {
+          whereConditions.push(`${k}=${val}`);
+        }
+      } else {
         if (typeof v === "string") {
           const escaped = v.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
           whereConditions.push(`${k}='${escaped}'`);
@@ -760,50 +989,60 @@ class HuggingFaceTabularStorage extends BaseTabularStorage {
       }
     }
     if (whereConditions.length === 0) {
-      throw new Error("Search criteria must include at least one non-null and non-undefined value to build a valid WHERE clause.");
+      return;
     }
     const where = whereConditions.join(" AND ");
     const allEntities = [];
-    let offset = 0;
-    const limit = 100;
+    let fetchOffset = 0;
+    const fetchLimit = 100;
     while (true) {
       const data = await this.fetchApi("/filter", {
         where,
-        offset: offset.toString(),
-        limit: limit.toString()
+        offset: fetchOffset.toString(),
+        limit: fetchLimit.toString()
       });
       for (const row of data.rows) {
         allEntities.push(this.rowToEntity(row));
       }
-      offset += data.rows.length;
-      if (offset >= data.num_rows_total || data.rows.length < limit) {
+      fetchOffset += data.rows.length;
+      if (fetchOffset >= data.num_rows_total || data.rows.length < fetchLimit) {
         break;
       }
     }
-    if (allEntities.length > 0) {
-      this.events.emit("search", key, allEntities);
-      return allEntities;
+    let results = allEntities;
+    if (options?.orderBy && options.orderBy.length > 0) {
+      results.sort((a, b) => {
+        for (const { column, direction } of options.orderBy) {
+          const aVal = a[column];
+          const bVal = b[column];
+          if (aVal == null && bVal == null)
+            continue;
+          if (aVal == null)
+            return direction === "ASC" ? -1 : 1;
+          if (bVal == null)
+            return direction === "ASC" ? 1 : -1;
+          if (aVal < bVal)
+            return direction === "ASC" ? -1 : 1;
+          if (aVal > bVal)
+            return direction === "ASC" ? 1 : -1;
+        }
+        return 0;
+      });
+    }
+    if (options?.offset !== undefined) {
+      results = results.slice(options.offset);
+    }
+    if (options?.limit !== undefined) {
+      results = results.slice(0, options.limit);
+    }
+    if (results.length > 0) {
+      this.events.emit("query", criteria, results);
+      return results;
     } else {
-      this.events.emit("search", key, undefined);
+      this.events.emit("query", criteria, undefined);
       return;
     }
   }
-  async size() {
-    const data = await this.fetchApi("/size", {});
-    return data.size.num_rows;
-  }
-  async put(_value) {
-    throw new Error("HuggingFaceTabularStorage is readonly");
-  }
-  async putBulk(_values) {
-    throw new Error("HuggingFaceTabularStorage is readonly");
-  }
-  async delete(_value) {
-    throw new Error("HuggingFaceTabularStorage is readonly");
-  }
-  async deleteAll() {
-    throw new Error("HuggingFaceTabularStorage is readonly");
-  }
   async deleteSearch(_criteria) {
     throw new Error("HuggingFaceTabularStorage is readonly");
   }
@@ -1034,7 +1273,7 @@ class InMemoryKvStorage extends KvViaTabularStorage {
 import {
   createServiceToken as createServiceToken9,
   EventEmitter as EventEmitter3,
-  getLogger,
+  getLogger as getLogger2,
   makeFingerprint as makeFingerprint4,
   sleep,
   uuid4 as uuid42
@@ -1133,7 +1372,7 @@ class InMemoryQueueStorage {
     const job = this.jobQueue.find((j) => j.id === id && this.matchesPrefixes(j));
     if (!job) {
       const jobWithAnyPrefix = this.jobQueue.find((j) => j.id === id);
-      getLogger().warn("Job not found for progress update", {
+      getLogger2().warn("Job not found for progress update", {
         id,
         reason: jobWithAnyPrefix ? "prefix_mismatch" : "missing",
         existingStatus: jobWithAnyPrefix?.status,
@@ -1143,7 +1382,7 @@ class InMemoryQueueStorage {
       return;
     }
     if (job.status === JobStatus.COMPLETED || job.status === JobStatus.FAILED) {
-      getLogger().warn("Job already completed or failed for progress update", {
+      getLogger2().warn("Job already completed or failed for progress update", {
         id,
         status: job.status,
         completedAt: job.completed_at,
@@ -1929,15 +2168,15 @@ class FsFolderTabularStorage extends BaseTabularStorage {
     const page = allEntities.slice(offset, offset + limit);
     return page.length > 0 ? page : undefined;
   }
-  async search(key) {
-    throw new Error("Search not supported for FsFolderTabularStorage");
-  }
   async getFilePath(value) {
     const { key } = this.separateKeyValueFromCombined(value);
     const filename = await this.getKeyAsIdString(key);
     const fullPath = path.join(this.folderPath, `${filename}.json`);
     return fullPath;
   }
+  async query(_criteria, _options) {
+    throw new StorageUnsupportedError("query", "FsFolderTabularStorage");
+  }
   async deleteSearch(_criteria) {
     throw new Error("deleteSearch is not supported for FsFolderTabularStorage");
   }
@@ -2525,39 +2764,6 @@ class PostgresTabularStorage extends BaseSqlTabularStorage {
     this.events.emit("get", key, val);
     return val;
   }
-  async search(key) {
-    const db = this.db;
-    const searchKeys = Object.keys(key);
-    if (searchKeys.length === 0) {
-      return;
-    }
-    const bestIndex = this.findBestMatchingIndex(searchKeys);
-    if (!bestIndex) {
-      throw new Error(`No suitable index found for the search criteria, searching for ['${searchKeys.join("', '")}'] with pk ['${this.primaryKeyNames.join("', '")}'] and indexes ['${this.indexes.join("', '")}']`);
-    }
-    const validColumns = [...this.primaryKeyColumns(), ...this.valueColumns()];
-    const invalidColumns = searchKeys.filter((key2) => !validColumns.includes(key2));
-    if (invalidColumns.length > 0) {
-      throw new Error(`Invalid columns in search criteria: ${invalidColumns.join(", ")}`);
-    }
-    const whereClauses = Object.keys(key).map((key2, i) => `"${key2}" = $${i + 1}`).join(" AND ");
-    const whereClauseValues = Object.entries(key).map(([k, v]) => this.jsToSqlValue(k, v));
-    const sql = `SELECT * FROM "${this.table}" WHERE ${whereClauses}`;
-    const result = await db.query(sql, whereClauseValues);
-    if (result.rows.length > 0) {
-      for (const row of result.rows) {
-        const record = row;
-        for (const k in this.schema.properties) {
-          record[k] = this.sqlToJsValue(k, record[k]);
-        }
-      }
-      this.events.emit("search", key, result.rows);
-      return result.rows;
-    } else {
-      this.events.emit("search", key, undefined);
-      return;
-    }
-  }
   async delete(value) {
     const db = this.db;
     const { key } = this.separateKeyValueFromCombined(value);
@@ -2566,10 +2772,24 @@ class PostgresTabularStorage extends BaseSqlTabularStorage {
     await db.query(`DELETE FROM "${this.table}" WHERE ${whereClauses}`, params);
     this.events.emit("delete", key);
   }
-  async getAll() {
+  async getAll(options) {
+    this.validateGetAllOptions(options);
     const db = this.db;
-    const sql = `SELECT * FROM "${this.table}"`;
-    const result = await db.query(sql);
+    let sql = `SELECT * FROM "${this.table}"`;
+    const params = [];
+    if (options?.orderBy && options.orderBy.length > 0) {
+      const orderClauses = options.orderBy.map((o) => `"${String(o.column)}" ${o.direction}`);
+      sql += ` ORDER BY ${orderClauses.join(", ")}`;
+    }
+    if (options?.limit !== undefined) {
+      sql += ` LIMIT $${params.length + 1}`;
+      params.push(options.limit);
+    }
+    if (options?.offset !== undefined) {
+      sql += ` OFFSET $${params.length + 1}`;
+      params.push(options.offset);
+    }
+    const result = params.length > 0 ? await db.query(sql, params) : await db.query(sql);
     if (result.rows.length > 0) {
       for (const row of result.rows) {
         const record = row;
@@ -2642,6 +2862,38 @@ class PostgresTabularStorage extends BaseSqlTabularStorage {
     await db.query(`DELETE FROM "${this.table}" WHERE ${whereClause}`, params);
     this.events.emit("delete", criteriaKeys[0]);
   }
+  async query(criteria, options) {
+    this.validateQueryParams(criteria, options);
+    const db = this.db;
+    let sql = `SELECT * FROM "${this.table}"`;
+    const { whereClause, params } = this.buildDeleteSearchWhere(criteria);
+    sql += ` WHERE ${whereClause}`;
+    if (options?.orderBy && options.orderBy.length > 0) {
+      const orderClauses = options.orderBy.map((o) => `"${String(o.column)}" ${o.direction}`);
+      sql += ` ORDER BY ${orderClauses.join(", ")}`;
+    }
+    if (options?.limit !== undefined) {
+      sql += ` LIMIT $${params.length + 1}`;
+      params.push(options.limit);
+    }
+    if (options?.offset !== undefined) {
+      sql += ` OFFSET $${params.length + 1}`;
+      params.push(options.offset);
+    }
+    const result = await db.query(sql, params);
+    if (result.rows.length > 0) {
+      for (const row of result.rows) {
+        const record = row;
+        for (const k in this.schema.properties) {
+          record[k] = this.sqlToJsValue(k, record[k]);
+        }
+      }
+      this.events.emit("query", criteria, result.rows);
+      return result.rows;
+    }
+    this.events.emit("query", criteria, undefined);
+    return;
+  }
   subscribeToChanges(callback, options) {
     throw new Error("subscribeToChanges is not supported for PostgresTabularStorage");
   }
@@ -2974,40 +3226,6 @@ class SqliteTabularStorage extends BaseSqlTabularStorage {
       return;
     }
   }
-  async search(key) {
-    const db = this.db;
-    const searchKeys = Object.keys(key);
-    if (searchKeys.length === 0) {
-      return;
-    }
-    const bestIndex = super.findBestMatchingIndex(searchKeys);
-    if (!bestIndex) {
-      throw new Error(`No suitable index found for the search criteria, searching for ['${searchKeys.join("', '")}'] with pk ['${this.primaryKeyNames.join("', '")}'] and indexes ['${this.indexes.join("', '")}']`);
-    }
-    const validColumns = [...this.primaryKeyColumns(), ...this.valueColumns()];
-    const invalidColumns = searchKeys.filter((key2) => !validColumns.includes(key2));
-    if (invalidColumns.length > 0) {
-      throw new Error(`Invalid columns in search criteria: ${invalidColumns.join(", ")}`);
-    }
-    const whereClauses = Object.keys(key).map((key2, i) => `"${key2}" = ?`).join(" AND ");
-    const whereClauseValues = Object.entries(key).map(([k, v]) => this.jsToSqlValue(k, v));
-    const sql = `SELECT * FROM \`${this.table}\` WHERE ${whereClauses}`;
-    const stmt = db.prepare(sql);
-    const result = stmt.all(...whereClauseValues);
-    if (result.length > 0) {
-      for (const row of result) {
-        const record = row;
-        for (const k in this.schema.properties) {
-          record[k] = this.sqlToJsValue(k, record[k]);
-        }
-      }
-      this.events.emit("search", key, result);
-      return result;
-    } else {
-      this.events.emit("search", key, undefined);
-      return;
-    }
-  }
   async delete(key) {
     const db = this.db;
     const whereClauses = this.primaryKeyColumns().map((key2) => `${key2} = ?`).join(" AND ");
@@ -3016,11 +3234,28 @@ class SqliteTabularStorage extends BaseSqlTabularStorage {
     stmt.run(...params);
     this.events.emit("delete", key);
   }
-  async getAll() {
+  async getAll(options) {
+    this.validateGetAllOptions(options);
     const db = this.db;
-    const sql = `SELECT * FROM \`${this.table}\``;
+    let sql = `SELECT * FROM \`${this.table}\``;
+    const params = [];
+    if (options?.orderBy && options.orderBy.length > 0) {
+      const orderClauses = options.orderBy.map((o) => `\`${String(o.column)}\` ${o.direction}`);
+      sql += ` ORDER BY ${orderClauses.join(", ")}`;
+    }
+    if (options?.limit !== undefined) {
+      sql += ` LIMIT ?`;
+      params.push(options.limit);
+    }
+    if (options?.offset !== undefined) {
+      if (options.limit === undefined) {
+        sql += ` LIMIT -1`;
+      }
+      sql += ` OFFSET ?`;
+      params.push(options.offset);
+    }
     const stmt = db.prepare(sql);
-    const value = stmt.all();
+    const value = params.length > 0 ? stmt.all(...params) : stmt.all();
     if (!value.length)
       return;
     for (const row of value) {
@@ -3096,6 +3331,42 @@ class SqliteTabularStorage extends BaseSqlTabularStorage {
     stmt.run(...params);
     this.events.emit("delete", criteriaKeys[0]);
   }
+  async query(criteria, options) {
+    this.validateQueryParams(criteria, options);
+    const db = this.db;
+    let sql = `SELECT * FROM \`${this.table}\``;
+    const { whereClause, params } = this.buildDeleteSearchWhere(criteria);
+    sql += ` WHERE ${whereClause}`;
+    if (options?.orderBy && options.orderBy.length > 0) {
+      const orderClauses = options.orderBy.map((o) => `\`${String(o.column)}\` ${o.direction}`);
+      sql += ` ORDER BY ${orderClauses.join(", ")}`;
+    }
+    if (options?.limit !== undefined) {
+      sql += ` LIMIT ?`;
+      params.push(options.limit);
+    }
+    if (options?.offset !== undefined) {
+      if (options.limit === undefined) {
+        sql += ` LIMIT -1`;
+      }
+      sql += ` OFFSET ?`;
+      params.push(options.offset);
+    }
+    const stmt = db.prepare(sql);
+    const result = stmt.all(...params);
+    if (result.length > 0) {
+      for (const row of result) {
+        const record = row;
+        for (const k in this.schema.properties) {
+          record[k] = this.sqlToJsValue(k, record[k]);
+        }
+      }
+      this.events.emit("query", criteria, result);
+      return result;
+    }
+    this.events.emit("query", criteria, undefined);
+    return;
+  }
   subscribeToChanges(callback, options) {
     throw new Error("subscribeToChanges is not supported for SqliteTabularStorage");
   }
@@ -3379,41 +3650,6 @@ class SupabaseTabularStorage extends BaseSqlTabularStorage {
     this.events.emit("get", key, val);
     return val;
   }
-  async search(searchCriteria) {
-    const searchKeys = Object.keys(searchCriteria);
-    if (searchKeys.length === 0) {
-      return;
-    }
-    const bestIndex = this.findBestMatchingIndex(searchKeys);
-    if (!bestIndex) {
-      throw new Error(`No suitable index found for the search criteria, searching for ['${searchKeys.join("', '")}'] with pk ['${this.primaryKeyNames.join("', '")}'] and indexes ['${this.indexes.join("', '")}']`);
-    }
-    const validColumns = [...this.primaryKeyColumns(), ...this.valueColumns()];
-    const invalidColumns = searchKeys.filter((key) => !validColumns.includes(key));
-    if (invalidColumns.length > 0) {
-      throw new Error(`Invalid columns in search criteria: ${invalidColumns.join(", ")}`);
-    }
-    let query = this.client.from(this.table).select("*");
-    for (const [key, value] of Object.entries(searchCriteria)) {
-      query = query.eq(key, value);
-    }
-    const { data, error } = await query;
-    if (error)
-      throw error;
-    if (data && data.length > 0) {
-      for (const row of data) {
-        const record = row;
-        for (const key in this.schema.properties) {
-          record[key] = this.sqlToJsValue(key, record[key]);
-        }
-      }
-      this.events.emit("search", searchCriteria, data);
-      return data;
-    } else {
-      this.events.emit("search", searchCriteria, undefined);
-      return;
-    }
-  }
   async delete(value) {
     const { key } = this.separateKeyValueFromCombined(value);
     let query = this.client.from(this.table).delete();
@@ -3426,8 +3662,23 @@ class SupabaseTabularStorage extends BaseSqlTabularStorage {
       throw error;
     this.events.emit("delete", key);
   }
-  async getAll() {
-    const { data, error } = await this.client.from(this.table).select("*");
+  async getAll(options) {
+    this.validateGetAllOptions(options);
+    let query = this.client.from(this.table).select("*");
+    if (options?.orderBy) {
+      for (const { column, direction } of options.orderBy) {
+        query = query.order(String(column), { ascending: direction === "ASC" });
+      }
+    }
+    if (options?.offset !== undefined || options?.limit !== undefined) {
+      const start = options?.offset ?? 0;
+      if (options?.limit !== undefined) {
+        query = query.range(start, start + options.limit - 1);
+      } else if (options?.offset !== undefined) {
+        query = query.range(start, start + 999999);
+      }
+    }
+    const { data, error } = await query;
     if (error)
       throw error;
     if (data && data.length) {
@@ -3515,6 +3766,69 @@ class SupabaseTabularStorage extends BaseSqlTabularStorage {
       throw error;
     this.events.emit("delete", criteriaKeys[0]);
   }
+  async query(criteria, options) {
+    this.validateQueryParams(criteria, options);
+    const criteriaKeys = Object.keys(criteria);
+    let query = this.client.from(this.table).select("*");
+    for (const column of criteriaKeys) {
+      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;
+      }
+    }
+    if (options?.orderBy) {
+      for (const { column, direction } of options.orderBy) {
+        query = query.order(String(column), { ascending: direction === "ASC" });
+      }
+    }
+    if (options?.offset !== undefined || options?.limit !== undefined) {
+      const start = options?.offset ?? 0;
+      if (options?.limit !== undefined) {
+        query = query.range(start, start + options.limit - 1);
+      } else if (options?.offset !== undefined) {
+        query = query.range(start, start + 999999);
+      }
+    } else if (options?.limit !== undefined) {
+      query = query.limit(options.limit);
+    }
+    const { data, error } = await query;
+    if (error)
+      throw error;
+    if (data && data.length > 0) {
+      for (const row of data) {
+        const record = row;
+        for (const key in this.schema.properties) {
+          record[key] = this.sqlToJsValue(key, record[key]);
+        }
+      }
+      this.events.emit("query", criteria, data);
+      return data;
+    }
+    this.events.emit("query", criteria, undefined);
+    return;
+  }
   convertRealtimeRow(row) {
     const entity = { ...row };
     const record = entity;
@@ -6079,7 +6393,8 @@ class IndexedDbTabularStorage extends BaseTabularStorage {
       };
     });
   }
-  async getAll() {
+  async getAll(options) {
+    this.validateGetAllOptions(options);
     const db = await this.getDb();
     const transaction = db.transaction(this.table, "readonly");
     const store = transaction.objectStore(this.table);
@@ -6087,96 +6402,38 @@ class IndexedDbTabularStorage extends BaseTabularStorage {
     return new Promise((resolve, reject) => {
       request.onerror = () => reject(request.error);
       request.onsuccess = () => {
-        const values = request.result;
-        resolve(values.length > 0 ? values : undefined);
-      };
-    });
-  }
-  async search(key) {
-    const db = await this.getDb();
-    const searchKeys = Object.keys(key);
-    if (searchKeys.length === 0) {
-      return;
-    }
-    const bestIndex = this.findBestMatchingIndex(searchKeys);
-    if (!bestIndex) {
-      throw new Error("No suitable index found for the search criteria");
-    }
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.table, "readonly");
-      const store = transaction.objectStore(this.table);
-      const indexName = bestIndex.join("_");
-      const primaryKeyName = this.primaryKeyColumns().join("_");
-      const isPrimaryKey = indexName === primaryKeyName;
-      const indexValues = [];
-      for (const col of bestIndex) {
-        const val = key[col];
-        if (val === undefined)
-          break;
-        if (typeof val !== "string" && typeof val !== "number") {
-          throw new Error(`Invalid value type for indexed column ${String(col)}`);
+        let values = request.result;
+        if (values.length === 0) {
+          resolve(undefined);
+          return;
         }
-        indexValues.push(val);
-      }
-      if (indexValues.length > 0) {
-        const index = isPrimaryKey ? store : store.index(indexName);
-        const isPartialMatch = indexValues.length < bestIndex.length;
-        if (isPartialMatch) {
-          const allColumnsRequired = bestIndex.every((col) => {
-            const colName = String(col);
-            return this.schema.required?.includes(colName);
+        if (options?.orderBy && options.orderBy.length > 0) {
+          values.sort((a, b) => {
+            for (const { column, direction } of options.orderBy) {
+              const aVal = a[column];
+              const bVal = b[column];
+              if (aVal == null && bVal == null)
+                continue;
+              if (aVal == null)
+                return direction === "ASC" ? -1 : 1;
+              if (bVal == null)
+                return direction === "ASC" ? 1 : -1;
+              if (aVal < bVal)
+                return direction === "ASC" ? -1 : 1;
+              if (aVal > bVal)
+                return direction === "ASC" ? 1 : -1;
+            }
+            return 0;
           });
-          if (allColumnsRequired) {
-            const results = [];
-            const keyRange = IDBKeyRange.lowerBound(indexValues);
-            const cursorRequest = index.openCursor(keyRange);
-            cursorRequest.onsuccess = () => {
-              const cursor = cursorRequest.result;
-              if (cursor) {
-                const item = cursor.value;
-                const cursorKey = Array.isArray(cursor.key) ? cursor.key : [cursor.key];
-                const prefixMatches = indexValues.every((val, idx) => cursorKey[idx] === val);
-                if (!prefixMatches) {
-                  resolve(results.length > 0 ? results : undefined);
-                  return;
-                }
-                const matches = Object.entries(key).every(([k, v]) => item[k] === v);
-                if (matches) {
-                  results.push(item);
-                }
-                cursor.continue();
-              } else {
-                resolve(results.length > 0 ? results : undefined);
-              }
-            };
-            cursorRequest.onerror = () => {
-              reject(cursorRequest.error);
-            };
-          } else {
-            const getAllRequest = store.getAll();
-            getAllRequest.onsuccess = () => {
-              const allRecords = getAllRequest.result;
-              const results = allRecords.filter((item) => Object.entries(key).every(([k, v]) => item[k] === v));
-              resolve(results.length > 0 ? results : undefined);
-            };
-            getAllRequest.onerror = () => {
-              reject(getAllRequest.error);
-            };
-          }
-        } else {
-          const request = index.getAll(indexValues.length === 1 ? indexValues[0] : indexValues);
-          request.onsuccess = () => {
-            const results = request.result.filter((item) => Object.entries(key).every(([k, v]) => item[k] === v));
-            resolve(results.length > 0 ? results : undefined);
-          };
-          request.onerror = () => {
-            console.error("Search error:", request.error);
-            reject(request.error);
-          };
         }
-      } else {
-        throw new Error(`No valid values provided for indexed columns: ${bestIndex.join(", ")}`);
-      }
+        if (options?.offset !== undefined) {
+          values = values.slice(options.offset);
+        }
+        if (options?.limit !== undefined) {
+          values = values.slice(0, options.limit);
+        }
+        resolve(values.length > 0 ? values : undefined);
+      };
     });
   }
   async delete(key) {
@@ -6342,6 +6599,50 @@ class IndexedDbTabularStorage extends BaseTabularStorage {
       }
     });
   }
+  async query(criteria, options) {
+    this.validateQueryParams(criteria, options);
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readonly");
+      const store = transaction.objectStore(this.table);
+      const getAllRequest = store.getAll();
+      getAllRequest.onsuccess = () => {
+        const allRecords = getAllRequest.result;
+        let results = allRecords.filter((record) => this.matchesCriteria(record, criteria));
+        if (options?.orderBy && options.orderBy.length > 0) {
+          results.sort((a, b) => {
+            for (const { column, direction } of options.orderBy) {
+              const aVal = a[column];
+              const bVal = b[column];
+              if (aVal == null && bVal == null)
+                continue;
+              if (aVal == null)
+                return direction === "ASC" ? -1 : 1;
+              if (bVal == null)
+                return direction === "ASC" ? 1 : -1;
+              if (aVal < bVal)
+                return direction === "ASC" ? -1 : 1;
+              if (aVal > bVal)
+                return direction === "ASC" ? 1 : -1;
+            }
+            return 0;
+          });
+        }
+        if (options?.offset !== undefined) {
+          results = results.slice(options.offset);
+        }
+        if (options?.limit !== undefined) {
+          results = results.slice(0, options.limit);
+        }
+        const result = results.length > 0 ? results : undefined;
+        this.events.emit("query", criteria, result);
+        resolve(result);
+      };
+      getAllRequest.onerror = () => {
+        reject(getAllRequest.error);
+      };
+    });
+  }
   getHybridManager() {
     if (!this.hybridManager) {
       const channelName = `indexeddb-tabular-${this.table}`;
@@ -7296,6 +7597,12 @@ export {
   SupabaseRateLimiterStorage,
   SupabaseQueueStorage,
   SupabaseKvStorage,
+  StorageValidationError,
+  StorageUnsupportedError,
+  StorageInvalidLimitError,
+  StorageInvalidColumnError,
+  StorageError,
+  StorageEmptyCriteriaError,
   SqliteVectorStorage,
   SqliteTabularStorage,
   SqliteRateLimiterStorage,
@@ -7361,4 +7668,4 @@ export {
   BaseTabularStorage
 };
 
-//# debugId=2D59BEA4EF2DA70564756E2164756E21
+//# debugId=10EEBA1FB4F879DB64756E2164756E21