@workglow/postgres 0.2.28

package/dist/storage/node.js

@@ -0,0 +1,842 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/storage/_postgres/node-bun.ts
+var _pg;
+async function loadPostgres() {
+  if (_pg) {
+    return;
+  }
+  try {
+    _pg = await import("pg");
+  } catch {
+    throw new Error('The "pg" package is required for @workglow/postgres/storage on Node.js or Bun. Install: bun add pg');
+  }
+}
+function getPostgres() {
+  if (!_pg) {
+    throw new Error("Postgres is not ready. Await Postgres.init() before using getPostgres() or Postgres.module.");
+  }
+  return _pg;
+}
+async function createPool(config) {
+  await loadPostgres();
+  return new _pg.Pool(config);
+}
+var Postgres = {
+  init: loadPostgres,
+  load: loadPostgres,
+  get module() {
+    return getPostgres();
+  },
+  createPool
+};
+// src/storage/PostgresKvStorage.ts
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
+
+// src/storage/PostgresTabularStorage.ts
+import { createServiceToken } from "@workglow/util";
+import {
+  BaseSqlTabularStorage,
+  isSearchCondition,
+  pickCoveringIndex
+} from "@workglow/storage";
+var POSTGRES_TABULAR_REPOSITORY = createServiceToken("storage.tabularRepository.postgres");
+
+class PostgresTabularStorage extends BaseSqlTabularStorage {
+  db;
+  constructor(db, table = "tabular_store", schema, primaryKeyNames, indexes = [], clientProvidedKeys = "if-missing") {
+    super(table, schema, primaryKeyNames, indexes, clientProvidedKeys);
+    this.db = db;
+  }
+  async setupDatabase() {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS "${this.table}" (
+        ${this.constructPrimaryKeyColumns('"')} ${this.constructValueColumns('"')},
+        PRIMARY KEY (${this.primaryKeyColumnList()}) 
+      )
+    `;
+    await this.db.query(sql);
+    await this.createVectorIndexes();
+    const pkColumns = this.primaryKeyColumns();
+    const createdIndexes = new Set;
+    for (const columns of this.indexes) {
+      if (columns.length <= pkColumns.length) {
+        const isPkPrefix = columns.every((col, idx) => col === pkColumns[idx]);
+        if (isPkPrefix)
+          continue;
+      }
+      const indexName = `${this.table}_${columns.join("_")}`;
+      const columnList = columns.map((col) => `"${String(col)}"`).join(", ");
+      const columnKey = columns.join(",");
+      if (createdIndexes.has(columnKey))
+        continue;
+      const isRedundant = Array.from(createdIndexes).some((existing) => {
+        const existingCols = existing.split(",");
+        return existingCols.length >= columns.length && columns.every((col, idx) => col === existingCols[idx]);
+      });
+      if (!isRedundant) {
+        await this.db.query(`CREATE INDEX IF NOT EXISTS "${indexName}" ON "${this.table}" (${columnList})`);
+        createdIndexes.add(columnKey);
+      }
+    }
+  }
+  isVectorFormat(format) {
+    if (!format)
+      return false;
+    return format.startsWith("TypedArray:") || format === "TypedArray";
+  }
+  getVectorDimensions(typeDef) {
+    return;
+  }
+  mapTypeToSQL(typeDef) {
+    const actualType = this.getNonNullType(typeDef);
+    if (typeof actualType === "boolean") {
+      return "TEXT /* boolean schema */";
+    }
+    if (actualType.contentEncoding === "blob")
+      return "BYTEA";
+    switch (actualType.type) {
+      case "string":
+        if (actualType.format === "date-time")
+          return "TIMESTAMP";
+        if (actualType.format === "date")
+          return "DATE";
+        if (actualType.format === "email")
+          return "VARCHAR(255)";
+        if (actualType.format === "uri")
+          return "VARCHAR(2048)";
+        if (actualType.format === "uuid")
+          return "UUID";
+        if (this.isVectorFormat(actualType.format)) {
+          const dimension = this.getVectorDimensions(actualType);
+          if (typeof dimension === "number") {
+            return `vector(${dimension})`;
+          }
+        }
+        if (typeof actualType.maxLength === "number") {
+          return `VARCHAR(${actualType.maxLength})`;
+        }
+        return "TEXT";
+      case "number":
+      case "integer":
+        if (actualType.multipleOf === 1 || actualType.type === "integer") {
+          if (typeof actualType.minimum === "number") {
+            if (actualType.minimum >= 0) {
+              if (typeof actualType.maximum === "number") {
+                if (actualType.maximum <= 32767)
+                  return "SMALLINT";
+                if (actualType.maximum <= 2147483647)
+                  return "INTEGER";
+              }
+              return "BIGINT";
+            }
+          }
+          return "INTEGER";
+        }
+        if (actualType.format === "float")
+          return "REAL";
+        if (actualType.format === "double")
+          return "DOUBLE PRECISION";
+        if (typeof actualType.multipleOf === "number") {
+          const decimalPlaces = String(actualType.multipleOf).split(".")[1]?.length || 0;
+          if (decimalPlaces > 0) {
+            return `NUMERIC(38, ${decimalPlaces})`;
+          }
+        }
+        return "NUMERIC";
+      case "boolean":
+        return "BOOLEAN";
+      case "array":
+        if (actualType.items && typeof actualType.items === "object" && !Array.isArray(actualType.items)) {
+          const itemType = this.mapTypeToSQL(actualType.items);
+          const supportedArrayElementTypes = [
+            "TEXT",
+            "VARCHAR",
+            "CHAR",
+            "INTEGER",
+            "SMALLINT",
+            "BIGINT",
+            "REAL",
+            "DOUBLE PRECISION",
+            "NUMERIC",
+            "BOOLEAN",
+            "UUID",
+            "DATE",
+            "TIMESTAMP"
+          ];
+          const isSupported = supportedArrayElementTypes.some((type) => itemType === type || itemType.startsWith(type + "(") && type !== "VARCHAR");
+          if (isSupported) {
+            return `${itemType}[]`;
+          } else {
+            return "JSONB /* complex array */";
+          }
+        }
+        return "JSONB /* generic array */";
+      case "object":
+        return "JSONB /* object */";
+      default:
+        return "TEXT /* unknown type */";
+    }
+  }
+  constructPrimaryKeyColumns($delimiter = "") {
+    const cols = Object.entries(this.primaryKeySchema.properties).map(([key, typeDef]) => {
+      if (this.isAutoGeneratedKey(key)) {
+        if (this.autoGeneratedKeyStrategy === "autoincrement") {
+          const sqlType2 = this.mapTypeToSQL(typeDef);
+          const isSmallInt = sqlType2.includes("SMALLINT");
+          const isBigInt = sqlType2.includes("BIGINT");
+          const serialType = isBigInt ? "BIGSERIAL" : isSmallInt ? "SMALLSERIAL" : "SERIAL";
+          return `${$delimiter}${key}${$delimiter} ${serialType}`;
+        } else if (this.autoGeneratedKeyStrategy === "uuid") {
+          return `${$delimiter}${key}${$delimiter} UUID DEFAULT gen_random_uuid()`;
+        }
+      }
+      const sqlType = this.mapTypeToSQL(typeDef);
+      let constraints = "NOT NULL";
+      if (this.shouldBeUnsigned(typeDef)) {
+        constraints += ` CHECK (${$delimiter}${key}${$delimiter} >= 0)`;
+      }
+      return `${$delimiter}${key}${$delimiter} ${sqlType} ${constraints}`;
+    }).join(", ");
+    return cols;
+  }
+  constructValueColumns($delimiter = "") {
+    const requiredSet = new Set(this.valueSchema.required ?? []);
+    const cols = Object.entries(this.valueSchema.properties).map(([key, typeDef]) => {
+      const sqlType = this.mapTypeToSQL(typeDef);
+      const isRequired = requiredSet.has(key);
+      const nullable = !isRequired || this.isNullable(typeDef);
+      let constraints = nullable ? "NULL" : "NOT NULL";
+      if (this.shouldBeUnsigned(typeDef)) {
+        constraints += ` CHECK (${$delimiter}${key}${$delimiter} >= 0)`;
+      }
+      return `${$delimiter}${key}${$delimiter} ${sqlType} ${constraints}`;
+    }).join(", ");
+    if (cols.length > 0) {
+      return `, ${cols}`;
+    } else {
+      return "";
+    }
+  }
+  jsToSqlValue(column, value) {
+    const typeDef = this.schema.properties[column];
+    if (typeDef) {
+      const actualType = this.getNonNullType(typeDef);
+      if (typeof actualType !== "boolean" && this.isVectorFormat(actualType.format)) {
+        if (value && ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+          const array = Array.from(value);
+          return `[${array.join(",")}]`;
+        }
+        if (typeof value === "string") {
+          return value;
+        }
+      }
+    }
+    return super.jsToSqlValue(column, value);
+  }
+  sqlToJsValue(column, value) {
+    const typeDef = this.schema.properties[column];
+    if (typeDef) {
+      if (value === null && this.isNullable(typeDef)) {
+        return null;
+      }
+      const actualType = this.getNonNullType(typeDef);
+      if (typeof actualType !== "boolean" && this.isVectorFormat(actualType.format)) {
+        if (typeof value === "string") {
+          try {
+            const array = JSON.parse(value);
+            return new Float32Array(array);
+          } catch (e) {
+            console.warn(`Failed to parse vector for column ${column}:`, e);
+          }
+        }
+        if (value && typeof value === "object") {
+          return value;
+        }
+      }
+      if (typeof actualType !== "boolean" && (actualType.type === "number" || actualType.type === "integer")) {
+        if (typeof value === "number")
+          return value;
+        if (typeof value === "string") {
+          const parsed = Number(value);
+          if (!isNaN(parsed))
+            return parsed;
+        }
+      }
+    }
+    return super.sqlToJsValue(column, value);
+  }
+  shouldBeUnsigned(typeDef) {
+    const actualType = this.getNonNullType(typeDef);
+    if (typeof actualType === "boolean") {
+      return false;
+    }
+    if ((actualType.type === "number" || actualType.type === "integer") && typeof actualType.minimum === "number" && actualType.minimum >= 0) {
+      return true;
+    }
+    return false;
+  }
+  getVectorColumns() {
+    const vectorColumns = [];
+    for (const [key, typeDef] of Object.entries(this.schema.properties)) {
+      const actualType = this.getNonNullType(typeDef);
+      if (typeof actualType !== "boolean" && this.isVectorFormat(actualType.format)) {
+        const dimension = this.getVectorDimensions(actualType);
+        if (typeof dimension === "number") {
+          vectorColumns.push({ column: key, dimension });
+        } else {
+          console.warn(`Invalid vector format for column ${key}: ${actualType.format}, skipping`);
+        }
+      }
+    }
+    return vectorColumns;
+  }
+  async createVectorIndexes() {
+    const vectorColumns = this.getVectorColumns();
+    if (vectorColumns.length === 0) {
+      return;
+    }
+    try {
+      await this.db.query("CREATE EXTENSION IF NOT EXISTS vector");
+    } catch (error) {
+      console.warn("pgvector extension not available, vector columns will use TEXT fallback:", error);
+      return;
+    }
+    for (const { column } of vectorColumns) {
+      const indexName = `${this.table}_${column}_hnsw_idx`;
+      try {
+        await this.db.query(`
+          CREATE INDEX IF NOT EXISTS "${indexName}"
+          ON "${this.table}"
+          USING hnsw ("${column}" vector_cosine_ops)
+        `);
+      } catch (error) {
+        console.warn(`Failed to create HNSW index on ${column}:`, error);
+      }
+    }
+  }
+  async put(entity) {
+    const db = this.db;
+    const columnsToInsert = [];
+    const paramsToInsert = [];
+    const pkColumns = this.primaryKeyColumns();
+    const entityRecord = entity;
+    for (const col of pkColumns) {
+      const colStr = String(col);
+      if (this.isAutoGeneratedKey(colStr)) {
+        const clientProvidedValue = entityRecord[colStr];
+        const hasClientValue = clientProvidedValue !== undefined && clientProvidedValue !== null;
+        let shouldUseClientValue = false;
+        if (this.clientProvidedKeys === "never") {
+          shouldUseClientValue = false;
+        } else if (this.clientProvidedKeys === "always") {
+          if (!hasClientValue) {
+            throw new Error(`Auto-generated key "${colStr}" is required when clientProvidedKeys is "always"`);
+          }
+          shouldUseClientValue = true;
+        } else {
+          shouldUseClientValue = hasClientValue;
+        }
+        if (shouldUseClientValue) {
+          columnsToInsert.push(colStr);
+          paramsToInsert.push(this.jsToSqlValue(colStr, clientProvidedValue));
+        }
+        continue;
+      }
+      columnsToInsert.push(colStr);
+      const value = entityRecord[colStr];
+      paramsToInsert.push(this.jsToSqlValue(colStr, value));
+    }
+    const valueColumns = this.valueColumns();
+    for (const col of valueColumns) {
+      const colStr = String(col);
+      columnsToInsert.push(colStr);
+      const value = entityRecord[colStr];
+      paramsToInsert.push(this.jsToSqlValue(colStr, value));
+    }
+    const columnList = columnsToInsert.map((c) => `"${c}"`).join(", ");
+    const placeholders = columnsToInsert.map((_, i) => `$${i + 1}`).join(", ");
+    const conflictClause = valueColumns.length > 0 ? `
+      ON CONFLICT (${this.primaryKeyColumnList('"')}) DO UPDATE
+      SET 
+      ${valueColumns.map((col) => {
+      const colIdx = columnsToInsert.indexOf(String(col));
+      return `"${col}" = $${colIdx + 1}`;
+    }).join(", ")}
+      ` : "";
+    const sql = `
+      INSERT INTO "${this.table}" (${columnList})
+      VALUES (${placeholders})
+      ${conflictClause}
+      RETURNING *
+    `;
+    const params = paramsToInsert;
+    const result = await db.query(sql, params);
+    const updatedEntity = result.rows[0];
+    const updatedRecord = updatedEntity;
+    for (const key in this.schema.properties) {
+      updatedRecord[key] = this.sqlToJsValue(key, updatedRecord[key]);
+    }
+    this.events.emit("put", updatedEntity);
+    return updatedEntity;
+  }
+  async putBulk(entities) {
+    if (entities.length === 0)
+      return [];
+    return await Promise.all(entities.map((entity) => this.put(entity)));
+  }
+  async get(key) {
+    const db = this.db;
+    const whereClauses = this.primaryKeyColumns().map((discriminatorKey, i) => `"${discriminatorKey}" = $${i + 1}`).join(" AND ");
+    const sql = `SELECT * FROM "${this.table}" WHERE ${whereClauses}`;
+    const params = this.getPrimaryKeyAsOrderedArray(key);
+    const result = await db.query(sql, params);
+    let val;
+    if (result.rows.length > 0) {
+      val = result.rows[0];
+      const valRecord = val;
+      for (const key2 in this.schema.properties) {
+        valRecord[key2] = this.sqlToJsValue(key2, valRecord[key2]);
+      }
+    } else {
+      val = undefined;
+    }
+    this.events.emit("get", key, val);
+    return val;
+  }
+  async delete(value) {
+    const db = this.db;
+    const { key } = this.separateKeyValueFromCombined(value);
+    const whereClauses = this.primaryKeyColumns().map((key2, i) => `${key2} = $${i + 1}`).join(" AND ");
+    const params = this.getPrimaryKeyAsOrderedArray(key);
+    await db.query(`DELETE FROM "${this.table}" WHERE ${whereClauses}`, params);
+    this.events.emit("delete", key);
+  }
+  async getAll(options) {
+    this.validateGetAllOptions(options);
+    const db = this.db;
+    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;
+        for (const key in this.schema.properties) {
+          record[key] = this.sqlToJsValue(key, record[key]);
+        }
+      }
+      return result.rows;
+    }
+    return;
+  }
+  async deleteAll() {
+    const db = this.db;
+    await db.query(`DELETE FROM "${this.table}"`);
+    this.events.emit("clearall");
+  }
+  async size() {
+    const db = this.db;
+    const result = await db.query(`SELECT COUNT(*) FROM "${this.table}"`);
+    return parseInt(result.rows[0].count, 10);
+  }
+  async count(criteria) {
+    if (!criteria || Object.keys(criteria).length === 0) {
+      return await this.size();
+    }
+    this.validateQueryParams(criteria);
+    const db = this.db;
+    const { whereClause, params } = this.buildDeleteSearchWhere(criteria);
+    const result = await db.query(`SELECT COUNT(*) FROM "${this.table}" WHERE ${whereClause}`, params);
+    return parseInt(result.rows[0].count, 10);
+  }
+  async getBulk(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]);
+    if (!result.rows || result.rows.length === 0) {
+      return;
+    }
+    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;
+  }
+  buildDeleteSearchWhere(criteria) {
+    const conditions = [];
+    const params = [];
+    let paramIndex = 1;
+    for (const column of Object.keys(criteria)) {
+      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;
+      }
+      conditions.push(`"${String(column)}" ${operator} $${paramIndex}`);
+      params.push(this.jsToSqlValue(column, value));
+      paramIndex++;
+    }
+    return {
+      whereClause: conditions.join(" AND "),
+      params
+    };
+  }
+  async deleteSearch(criteria) {
+    const criteriaKeys = Object.keys(criteria);
+    if (criteriaKeys.length === 0) {
+      return;
+    }
+    const db = this.db;
+    const { whereClause, params } = this.buildDeleteSearchWhere(criteria);
+    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;
+  }
+  async queryIndex(criteria, options) {
+    this.validateSelect(options);
+    this.validateQueryParams(criteria, options);
+    const registered = this.indexes.map((cols2, i) => {
+      const cs = Array.isArray(cols2) ? cols2 : [cols2];
+      return { name: `idx_${i}`, keyPath: cs };
+    });
+    pickCoveringIndex({
+      table: this.table,
+      indexes: registered,
+      criteriaColumns: Object.keys(criteria),
+      orderByColumns: (options.orderBy ?? []).map((o) => ({
+        column: String(o.column),
+        direction: o.direction
+      })),
+      selectColumns: options.select.map(String),
+      primaryKeyColumns: this.primaryKeyNames.map(String)
+    });
+    const cols = options.select.map((c) => `"${String(c)}"`).join(", ");
+    let sql = `SELECT ${cols} FROM "${this.table}"`;
+    const { whereClause, params } = this.buildDeleteSearchWhere(criteria);
+    sql += ` WHERE ${whereClause}`;
+    if (options.orderBy && options.orderBy.length > 0) {
+      sql += ` ORDER BY ` + options.orderBy.map((o) => `"${String(o.column)}" ${o.direction}`).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 db = this.db;
+    const result = await db.query(sql, params);
+    for (const row of result.rows) {
+      const record = row;
+      for (const k of Object.keys(record)) {
+        record[k] = this.sqlToJsValue(k, record[k]);
+      }
+    }
+    return result.rows;
+  }
+  subscribeToChanges(callback, options) {
+    throw new Error("subscribeToChanges is not supported for PostgresTabularStorage");
+  }
+  destroy() {
+    super.destroy();
+  }
+}
+
+// src/storage/PostgresKvStorage.ts
+import {
+  DefaultKeyValueKey,
+  DefaultKeyValueSchema,
+  KvViaTabularStorage
+} from "@workglow/storage";
+var POSTGRES_KV_REPOSITORY = createServiceToken2("storage.kvRepository.postgres");
+
+class PostgresKvStorage extends KvViaTabularStorage {
+  db;
+  dbName;
+  tabularRepository;
+  constructor(db, dbName, keySchema = { type: "string" }, valueSchema = {}) {
+    super(keySchema, valueSchema);
+    this.db = db;
+    this.dbName = dbName;
+    this.tabularRepository = new PostgresTabularStorage(db, dbName, DefaultKeyValueSchema, DefaultKeyValueKey);
+  }
+}
+// src/storage/PostgresVectorStorage.ts
+import { cosineSimilarity } from "@workglow/util/schema";
+import { StorageValidationError, getMetadataProperty, getVectorProperty } from "@workglow/storage";
+var SAFE_IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+
+class PostgresVectorStorage extends PostgresTabularStorage {
+  vectorDimensions;
+  vectorCtor;
+  vectorPropertyName;
+  metadataPropertyName;
+  constructor(db, table, schema, primaryKeyNames, indexes = [], dimensions, vectorCtor = Float32Array) {
+    super(db, table, schema, primaryKeyNames, indexes);
+    this.vectorDimensions = dimensions;
+    this.vectorCtor = vectorCtor;
+    const vectorProp = getVectorProperty(schema);
+    if (!vectorProp) {
+      throw new Error("Schema must have a property with type array and format TypedArray");
+    }
+    this.vectorPropertyName = vectorProp;
+    this.metadataPropertyName = getMetadataProperty(schema);
+  }
+  getVectorDimensions() {
+    return this.vectorDimensions;
+  }
+  async similaritySearch(query, options = {}) {
+    const { topK = 10, filter, scoreThreshold = 0 } = options;
+    try {
+      const queryVector = `[${Array.from(query).join(",")}]`;
+      const vectorCol = String(this.vectorPropertyName);
+      const metadataCol = this.metadataPropertyName ? String(this.metadataPropertyName) : null;
+      let sql = `
+        SELECT 
+          *,
+          1 - (${vectorCol} <=> $1::vector) as score
+        FROM "${this.table}"
+      `;
+      const params = [queryVector];
+      let paramIndex = 2;
+      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++;
+        }
+        sql += ` WHERE ${conditions.join(" AND ")}`;
+      }
+      if (scoreThreshold > 0) {
+        sql += filter ? " AND" : " WHERE";
+        sql += ` (1 - (${vectorCol} <=> $1::vector)) >= $${paramIndex}`;
+        params.push(scoreThreshold);
+        paramIndex++;
+      }
+      sql += ` ORDER BY ${vectorCol} <=> $1::vector 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]?.[vectorCol] || "[]";
+        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 query failed, falling back to in-memory search:", error);
+      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 vectorCol = String(this.vectorPropertyName);
+      const metadataCol = this.metadataPropertyName ? String(this.metadataPropertyName) : null;
+      let sql = `
+        SELECT 
+          *,
+          (
+            $2 * (1 - (${vectorCol} <=> $1::vector)) +
+            $3 * ts_rank(to_tsvector('english', ${metadataCol || "''"}::text), plainto_tsquery('english', $4))
+          ) as score
+        FROM "${this.table}"
+      `;
+      const params = [queryVector, vectorWeight, 1 - vectorWeight, tsQueryText];
+      let paramIndex = 5;
+      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++;
+        }
+        sql += ` WHERE ${conditions.join(" AND ")}`;
+      }
+      if (scoreThreshold > 0) {
+        sql += filter ? " AND" : " WHERE";
+        sql += ` (
+          $2 * (1 - (${vectorCol} <=> $1::vector)) +
+          $3 * ts_rank(to_tsvector('english', ${metadataCol || "''"}::text), plainto_tsquery('english', $4))
+        ) >= $${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]?.[vectorCol] || "[]";
+        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);
+    }
+  }
+  async searchFallback(query, options) {
+    const { topK = 10, filter, scoreThreshold = 0 } = options;
+    const allRows = await this.getAll() || [];
+    const results = [];
+    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 score = cosineSimilarity(query, vector);
+      if (score >= scoreThreshold) {
+        results.push({ ...row, score });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    const topResults = results.slice(0, topK);
+    return topResults;
+  }
+  async hybridSearchFallback(query, options) {
+    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 ");
+  }
+  getPrimaryKeyValues(row) {
+    return this.primaryKeyNames.map((key) => row[key]);
+  }
+  matchesFilter(metadata, filter) {
+    for (const [key, value] of Object.entries(filter)) {
+      if (metadata[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+export {
+  loadPostgres,
+  getPostgres,
+  createPool,
+  PostgresVectorStorage,
+  PostgresTabularStorage,
+  PostgresKvStorage,
+  Postgres,
+  POSTGRES_TABULAR_REPOSITORY,
+  POSTGRES_KV_REPOSITORY
+};
+
+//# debugId=EAED4AF57300AAC364756E2164756E21