@workglow/postgres 0.2.34 → 0.2.36

package/dist/storage/node.js

@@ -639,6 +639,52 @@ class PostgresTabularStorage extends BaseSqlTabularStorage {
     this.events.emit("get", key, val);
     return val;
   }
+  async getBulk(keys) {
+    if (keys.length === 0)
+      return [];
+    const pkColCount = this.primaryKeyColumns().length;
+    const chunkSize = Math.max(1, Math.floor(30000 / pkColCount));
+    let rows;
+    if (keys.length <= chunkSize) {
+      rows = await this.mutex(() => this._getBulkInternal(keys));
+    } else {
+      rows = [];
+      for (let i = 0;i < keys.length; i += chunkSize) {
+        const chunk = keys.slice(i, i + chunkSize);
+        const chunkRows = await this.mutex(() => this._getBulkInternal(chunk));
+        rows.push(...chunkRows);
+      }
+    }
+    this.events.emit("getBulk", keys, rows);
+    return rows;
+  }
+  async _getBulkInternal(keys) {
+    const db = this.db;
+    const pkCols = this.primaryKeyColumns();
+    const params = [];
+    const tuples = [];
+    let p = 1;
+    for (const key of keys) {
+      const ordered = this.getPrimaryKeyAsOrderedArray(key);
+      params.push(...ordered);
+      const slots = [];
+      for (let i = 0;i < pkCols.length; i++) {
+        slots.push(`$${p++}`);
+      }
+      tuples.push(`(${slots.join(", ")})`);
+    }
+    const lhs = pkCols.length === 1 ? `"${pkCols[0]}"` : `(${pkCols.map((c) => `"${c}"`).join(", ")})`;
+    const rhs = pkCols.length === 1 ? params.map((_, i) => `$${i + 1}`).join(", ") : tuples.join(", ");
+    const sql = `SELECT * FROM "${this.table}" WHERE ${lhs} IN (${rhs})`;
+    const result = await db.query(sql, params);
+    for (const row of result.rows) {
+      const record = row;
+      for (const key in this.schema.properties) {
+        record[key] = this.sqlToJsValue(key, record[key]);
+      }
+    }
+    return result.rows;
+  }
   async delete(value) {
     return this.mutex(() => this._deleteInternal(value));
   }
@@ -711,10 +757,10 @@ class PostgresTabularStorage extends BaseSqlTabularStorage {
     const result = await db.query(`SELECT COUNT(*) FROM "${this.table}" WHERE ${whereClause}`, params);
     return parseInt(result.rows[0].count, 10);
   }
-  async getBulk(offset, limit) {
-    return this.mutex(() => this._getBulkInternal(offset, limit));
+  async getOffsetPage(offset, limit) {
+    return this.mutex(() => this._getOffsetPageInternal(offset, limit));
   }
-  async _getBulkInternal(offset, limit) {
+  async _getOffsetPageInternal(offset, limit) {
     const db = this.db;
     const orderByClause = this.primaryKeyColumns().map((col) => `"${String(col)}"`).join(", ");
     const result = await db.query(`SELECT * FROM "${this.table}" ORDER BY ${orderByClause} LIMIT $1 OFFSET $2`, [limit, offset]);
@@ -1063,74 +1109,6 @@ class PostgresVectorStorage extends PostgresTabularStorage {
       return this.searchFallback(query, options);
     }
   }
-  async hybridSearch(query, options) {
-    const { topK = 10, filter, scoreThreshold = 0, textQuery, vectorWeight = 0.7 } = options;
-    if (!textQuery || textQuery.trim().length === 0) {
-      return this.similaritySearch(query, { topK, filter, scoreThreshold });
-    }
-    try {
-      const queryVector = `[${Array.from(query).join(",")}]`;
-      const tsQueryText = textQuery;
-      const vectorColRaw = String(this.vectorPropertyName);
-      const vectorCol = PostgresDialect2.quoteId(vectorColRaw);
-      const metadataColRaw = this.metadataPropertyName ? String(this.metadataPropertyName) : null;
-      const metadataCol = metadataColRaw ? PostgresDialect2.quoteId(metadataColRaw) : null;
-      const vectorScoreExpr = this.buildScoreExpr(vectorCol, "$1");
-      const combinedScoreExpr = `(
-            $2 * ${vectorScoreExpr} +
-            $3 * ts_rank(to_tsvector('english', ${metadataCol || "''"}::text), plainto_tsquery('english', $4))
-          )`;
-      let sql = `
-        SELECT
-          *,
-          ${combinedScoreExpr} as score
-        FROM "${this.table}"
-      `;
-      const params = [queryVector, vectorWeight, 1 - vectorWeight, tsQueryText];
-      let paramIndex = 5;
-      let hasWhere = false;
-      if (filter && Object.keys(filter).length > 0 && metadataCol) {
-        const conditions = [];
-        for (const [key, value] of Object.entries(filter)) {
-          if (!SAFE_IDENTIFIER_RE.test(key)) {
-            throw new StorageValidationError(`Invalid metadata filter key: "${key}". Keys must match /^[a-zA-Z_][a-zA-Z0-9_]*$/.`);
-          }
-          conditions.push(`${metadataCol}->>'${key}' = $${paramIndex}`);
-          params.push(String(value));
-          paramIndex++;
-        }
-        if (conditions.length > 0) {
-          sql += ` WHERE ${conditions.join(" AND ")}`;
-          hasWhere = true;
-        }
-      }
-      sql += hasWhere ? " AND" : " WHERE";
-      sql += ` ${combinedScoreExpr} >= $${paramIndex}`;
-      params.push(scoreThreshold);
-      paramIndex++;
-      sql += ` ORDER BY score DESC LIMIT $${paramIndex}`;
-      params.push(topK);
-      const result = await this.db.query(sql, params);
-      const results = [];
-      for (const row of result.rows) {
-        const vectorResult = await this.db.query(`SELECT ${vectorCol}::text FROM "${this.table}" WHERE ${this.getPrimaryKeyWhereClause()}`, this.getPrimaryKeyValues(row));
-        const vectorStr = vectorResult.rows[0]?.[vectorColRaw] || "[]";
-        const vectorArray = JSON.parse(vectorStr);
-        results.push({
-          ...row,
-          [this.vectorPropertyName]: new this.vectorCtor(vectorArray),
-          score: parseFloat(row.score)
-        });
-      }
-      return results;
-    } catch (error) {
-      if (error instanceof StorageValidationError) {
-        throw error;
-      }
-      console.error("pgvector hybrid query failed, falling back to in-memory search:", error);
-      return this.hybridSearchFallback(query, options);
-    }
-  }
   assertFallbackSupportsDistance() {
     if (this.distance !== "cosine") {
       throw new Error(`PostgresVectorStorage: pgvector is unavailable and the in-memory ` + `fallback only supports cosine distance (configured: "${this.distance}"). ` + `Install pgvector or switch the storage to cosine distance.`);
@@ -1156,40 +1134,6 @@ class PostgresVectorStorage extends PostgresTabularStorage {
     const topResults = results.slice(0, topK);
     return topResults;
   }
-  async hybridSearchFallback(query, options) {
-    this.assertFallbackSupportsDistance();
-    const { topK = 10, filter, scoreThreshold = 0, textQuery, vectorWeight = 0.7 } = options;
-    const allRows = await this.getAll() || [];
-    const results = [];
-    const queryLower = textQuery.toLowerCase();
-    const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 0);
-    for (const row of allRows) {
-      const vector = row[this.vectorPropertyName];
-      const metadata = this.metadataPropertyName ? row[this.metadataPropertyName] : {};
-      if (filter && !this.matchesFilter(metadata, filter)) {
-        continue;
-      }
-      const vectorScore = cosineSimilarity(query, vector);
-      const metadataText = Object.values(metadata ?? {}).join(" ").toLowerCase();
-      let textScore = 0;
-      if (queryWords.length > 0) {
-        let matches = 0;
-        for (const word of queryWords) {
-          if (metadataText.includes(word)) {
-            matches++;
-          }
-        }
-        textScore = matches / queryWords.length;
-      }
-      const combinedScore = vectorWeight * vectorScore + (1 - vectorWeight) * textScore;
-      if (combinedScore >= scoreThreshold) {
-        results.push({ ...row, score: combinedScore });
-      }
-    }
-    results.sort((a, b) => b.score - a.score);
-    const topResults = results.slice(0, topK);
-    return topResults;
-  }
   getPrimaryKeyWhereClause() {
     const conditions = this.primaryKeyNames.map((key, idx) => `${String(key)} = $${idx + 1}`);
     return conditions.join(" AND ");
@@ -1211,6 +1155,7 @@ import {
   MIGRATIONS_TABLE as MIGRATIONS_TABLE2,
   sortMigrations
 } from "@workglow/storage";
+var runLocks = new WeakMap;
 
 class PostgresMigrationRunner {
   db;
@@ -1243,6 +1188,15 @@ class PostgresMigrationRunner {
     } };
   }
   async run(migrations, options = {}) {
+    const key = this.db;
+    const prev = runLocks.get(key) ?? Promise.resolve();
+    const result = prev.then(() => this.runInternal(migrations, options));
+    runLocks.set(key, result.catch(() => {
+      return;
+    }));
+    return result;
+  }
+  async runInternal(migrations, options) {
     await this.ensureBookkeepingTable();
     const sorted = sortMigrations(migrations);
     const applied = [];
@@ -1328,4 +1282,4 @@ export {
   POSTGRES_KV_REPOSITORY
 };
 
-//# debugId=1C3E72F1BE3B8A0064756E2164756E21
+//# debugId=31CB72E3014C272564756E2164756E21