@mastra/pg 0.1.6-alpha.1 → 0.1.6-alpha.3

package/dist/index.cjs

@@ -0,0 +1,1050 @@
+'use strict';
+
+var vector = require('@mastra/core/vector');
+var pg = require('pg');
+var filter = require('@mastra/core/vector/filter');
+var storage = require('@mastra/core/storage');
+var pgPromise = require('pg-promise');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pg__default = /*#__PURE__*/_interopDefault(pg);
+var pgPromise__default = /*#__PURE__*/_interopDefault(pgPromise);
+
+// src/vector/index.ts
+var PGFilterTranslator = class extends filter.BaseFilterTranslator {
+  getSupportedOperators() {
+    return {
+      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+      custom: ["$contains", "$size"]
+    };
+  }
+  translate(filter) {
+    if (this.isEmpty(filter)) {
+      return filter;
+    }
+    this.validateFilter(filter);
+    return this.translateNode(filter);
+  }
+  translateNode(node, currentPath = "") {
+    const withPath = (result2) => currentPath ? { [currentPath]: result2 } : result2;
+    if (this.isPrimitive(node)) {
+      return withPath({ $eq: this.normalizeComparisonValue(node) });
+    }
+    if (Array.isArray(node)) {
+      return withPath({ $in: this.normalizeArrayValues(node) });
+    }
+    if (node instanceof RegExp) {
+      return withPath(this.translateRegexPattern(node.source, node.flags));
+    }
+    const entries = Object.entries(node);
+    const result = {};
+    if ("$options" in node && !("$regex" in node)) {
+      throw new Error("$options is not valid without $regex");
+    }
+    if ("$regex" in node) {
+      const options = node.$options || "";
+      return withPath(this.translateRegexPattern(node.$regex, options));
+    }
+    for (const [key, value] of entries) {
+      if (key === "$options") continue;
+      const newPath = currentPath ? `${currentPath}.${key}` : key;
+      if (this.isLogicalOperator(key)) {
+        result[key] = Array.isArray(value) ? value.map((filter) => this.translateNode(filter)) : this.translateNode(value);
+      } else if (this.isOperator(key)) {
+        if (this.isArrayOperator(key) && !Array.isArray(value) && key !== "$elemMatch") {
+          result[key] = [value];
+        } else if (this.isBasicOperator(key) && Array.isArray(value)) {
+          result[key] = JSON.stringify(value);
+        } else {
+          result[key] = value;
+        }
+      } else if (typeof value === "object" && value !== null) {
+        const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
+        if (hasOperators) {
+          result[newPath] = this.translateNode(value);
+        } else {
+          Object.assign(result, this.translateNode(value, newPath));
+        }
+      } else {
+        result[newPath] = this.translateNode(value);
+      }
+    }
+    return result;
+  }
+  translateRegexPattern(pattern, options = "") {
+    if (!options) return { $regex: pattern };
+    const flags = options.split("").filter((f) => "imsux".includes(f)).join("");
+    return { $regex: flags ? `(?${flags})${pattern}` : pattern };
+  }
+};
+
+// src/vector/sql-builder.ts
+var createBasicOperator = (symbol) => {
+  return (key, paramIndex) => ({
+    sql: `CASE 
+      WHEN $${paramIndex}::text IS NULL THEN metadata#>>'{${handleKey(key)}}' IS ${symbol === "=" ? "" : "NOT"} NULL
+      ELSE metadata#>>'{${handleKey(key)}}' ${symbol} $${paramIndex}::text
+    END`,
+    needsValue: true
+  });
+};
+var createNumericOperator = (symbol) => {
+  return (key, paramIndex) => ({
+    sql: `(metadata#>>'{${handleKey(key)}}')::numeric ${symbol} $${paramIndex}`,
+    needsValue: true
+  });
+};
+function buildElemMatchConditions(value, paramIndex) {
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("$elemMatch requires an object with conditions");
+  }
+  const conditions = [];
+  const values = [];
+  Object.entries(value).forEach(([field, val]) => {
+    const nextParamIndex = paramIndex + values.length;
+    let paramOperator;
+    let paramKey;
+    let paramValue;
+    if (field.startsWith("$")) {
+      paramOperator = field;
+      paramKey = "";
+      paramValue = val;
+    } else if (typeof val === "object" && !Array.isArray(val)) {
+      const [op, opValue] = Object.entries(val || {})[0] || [];
+      paramOperator = op;
+      paramKey = field;
+      paramValue = opValue;
+    } else {
+      paramOperator = "$eq";
+      paramKey = field;
+      paramValue = val;
+    }
+    const operatorFn = FILTER_OPERATORS[paramOperator];
+    if (!operatorFn) {
+      throw new Error(`Invalid operator: ${paramOperator}`);
+    }
+    const result = operatorFn(paramKey, nextParamIndex, paramValue);
+    const sql = result.sql.replaceAll("metadata#>>", "elem#>>");
+    conditions.push(sql);
+    if (result.needsValue) {
+      values.push(paramValue);
+    }
+  });
+  return {
+    sql: conditions.join(" AND "),
+    values
+  };
+}
+var FILTER_OPERATORS = {
+  $eq: createBasicOperator("="),
+  $ne: createBasicOperator("!="),
+  $gt: createNumericOperator(">"),
+  $gte: createNumericOperator(">="),
+  $lt: createNumericOperator("<"),
+  $lte: createNumericOperator("<="),
+  // Array Operators
+  $in: (key, paramIndex) => ({
+    sql: `metadata#>>'{${handleKey(key)}}' = ANY($${paramIndex}::text[])`,
+    needsValue: true
+  }),
+  $nin: (key, paramIndex) => ({
+    sql: `metadata#>>'{${handleKey(key)}}' != ALL($${paramIndex}::text[])`,
+    needsValue: true
+  }),
+  $all: (key, paramIndex) => ({
+    sql: `CASE WHEN array_length($${paramIndex}::text[], 1) IS NULL THEN false 
+          ELSE (metadata#>'{${handleKey(key)}}')::jsonb ?& $${paramIndex}::text[] END`,
+    needsValue: true
+  }),
+  $elemMatch: (key, paramIndex, value) => {
+    const { sql, values } = buildElemMatchConditions(value, paramIndex);
+    return {
+      sql: `(
+        CASE
+          WHEN jsonb_typeof(metadata->'${handleKey(key)}') = 'array' THEN
+            EXISTS (
+              SELECT 1 
+              FROM jsonb_array_elements(metadata->'${handleKey(key)}') as elem
+              WHERE ${sql}
+            )
+          ELSE FALSE
+        END
+      )`,
+      needsValue: true,
+      transformValue: () => values
+    };
+  },
+  // Element Operators
+  $exists: (key) => ({
+    sql: `metadata ? '${key}'`,
+    needsValue: false
+  }),
+  // Logical Operators
+  $and: (key) => ({ sql: `(${key})`, needsValue: false }),
+  $or: (key) => ({ sql: `(${key})`, needsValue: false }),
+  $not: (key) => ({ sql: `NOT (${key})`, needsValue: false }),
+  $nor: (key) => ({ sql: `NOT (${key})`, needsValue: false }),
+  // Regex Operators
+  $regex: (key, paramIndex) => ({
+    sql: `metadata#>>'{${handleKey(key)}}' ~ $${paramIndex}`,
+    needsValue: true
+  }),
+  $contains: (key, paramIndex) => ({
+    sql: `metadata @> $${paramIndex}::jsonb`,
+    needsValue: true,
+    transformValue: (value) => {
+      const parts = key.split(".");
+      return JSON.stringify(parts.reduceRight((value2, key2) => ({ [key2]: value2 }), value));
+    }
+  }),
+  $size: (key, paramIndex) => ({
+    sql: `(
+      CASE
+        WHEN jsonb_typeof(metadata#>'{${handleKey(key)}}') = 'array' THEN 
+          jsonb_array_length(metadata#>'{${handleKey(key)}}') = $${paramIndex}
+        ELSE FALSE
+      END
+    )`,
+    needsValue: true
+  })
+};
+var handleKey = (key) => {
+  return key.replace(/\./g, ",");
+};
+function buildFilterQuery(filter, minScore) {
+  const values = [minScore];
+  function buildCondition(key, value, parentPath) {
+    if (["$and", "$or", "$not", "$nor"].includes(key)) {
+      return handleLogicalOperator(key, value);
+    }
+    if (!value || typeof value !== "object") {
+      values.push(value);
+      return `metadata#>>'{${handleKey(key)}}' = $${values.length}`;
+    }
+    const [[operator, operatorValue] = []] = Object.entries(value);
+    if (operator === "$not") {
+      const entries = Object.entries(operatorValue);
+      const conditions2 = entries.map(([nestedOp, nestedValue]) => {
+        if (!FILTER_OPERATORS[nestedOp]) {
+          throw new Error(`Invalid operator in $not condition: ${nestedOp}`);
+        }
+        const operatorFn2 = FILTER_OPERATORS[nestedOp];
+        const operatorResult2 = operatorFn2(key, values.length + 1);
+        if (operatorResult2.needsValue) {
+          values.push(nestedValue);
+        }
+        return operatorResult2.sql;
+      }).join(" AND ");
+      return `NOT (${conditions2})`;
+    }
+    const operatorFn = FILTER_OPERATORS[operator];
+    const operatorResult = operatorFn(key, values.length + 1, operatorValue);
+    if (operatorResult.needsValue) {
+      const transformedValue = operatorResult.transformValue ? operatorResult.transformValue(operatorValue) : operatorValue;
+      if (Array.isArray(transformedValue) && operator === "$elemMatch") {
+        values.push(...transformedValue);
+      } else {
+        values.push(transformedValue);
+      }
+    }
+    return operatorResult.sql;
+  }
+  function handleLogicalOperator(key, value, parentPath) {
+    if (key === "$not") {
+      const entries = Object.entries(value);
+      const conditions3 = entries.map(([fieldKey, fieldValue]) => buildCondition(fieldKey, fieldValue)).join(" AND ");
+      return `NOT (${conditions3})`;
+    }
+    if (!value || value.length === 0) {
+      switch (key) {
+        case "$and":
+        case "$nor":
+          return "true";
+        // Empty $and/$nor match everything
+        case "$or":
+          return "false";
+        // Empty $or matches nothing
+        default:
+          return "true";
+      }
+    }
+    const joinOperator = key === "$or" || key === "$nor" ? "OR" : "AND";
+    const conditions2 = value.map((f) => {
+      const entries = Object.entries(f || {});
+      if (entries.length === 0) return "";
+      const [firstKey, firstValue] = entries[0] || [];
+      if (["$and", "$or", "$not", "$nor"].includes(firstKey)) {
+        return buildCondition(firstKey, firstValue);
+      }
+      return entries.map(([k, v]) => buildCondition(k, v)).join(` ${joinOperator} `);
+    });
+    const joined = conditions2.join(` ${joinOperator} `);
+    const operatorFn = FILTER_OPERATORS[key];
+    return operatorFn(joined, 0, value).sql;
+  }
+  if (!filter) {
+    return { sql: "", values };
+  }
+  const conditions = Object.entries(filter).map(([key, value]) => buildCondition(key, value)).filter(Boolean).join(" AND ");
+  return { sql: conditions ? `WHERE ${conditions}` : "", values };
+}
+
+// src/vector/index.ts
+var PgVector = class extends vector.MastraVector {
+  pool;
+  indexCache = /* @__PURE__ */ new Map();
+  constructor(connectionString) {
+    super();
+    const basePool = new pg__default.default.Pool({
+      connectionString,
+      max: 20,
+      // Maximum number of clients in the pool
+      idleTimeoutMillis: 3e4,
+      // Close idle connections after 30 seconds
+      connectionTimeoutMillis: 2e3
+      // Fail fast if can't connect
+    });
+    const telemetry = this.__getTelemetry();
+    this.pool = telemetry?.traceClass(basePool, {
+      spanNamePrefix: "pg-vector",
+      attributes: {
+        "vector.type": "postgres"
+      }
+    }) ?? basePool;
+  }
+  transformFilter(filter) {
+    const translator = new PGFilterTranslator();
+    return translator.translate(filter);
+  }
+  async getIndexInfo(indexName) {
+    if (!this.indexCache.has(indexName)) {
+      this.indexCache.set(indexName, await this.describeIndex(indexName));
+    }
+    return this.indexCache.get(indexName);
+  }
+  async query(...args) {
+    const params = this.normalizeArgs("query", args, ["minScore", "ef", "probes"]);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false, minScore = 0, ef, probes } = params;
+    const client = await this.pool.connect();
+    try {
+      const vectorStr = `[${queryVector.join(",")}]`;
+      const translatedFilter = this.transformFilter(filter);
+      const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter, minScore);
+      const indexInfo = await this.getIndexInfo(indexName);
+      if (indexInfo.type === "hnsw") {
+        const calculatedEf = ef ?? Math.max(topK, (indexInfo?.config?.m ?? 16) * topK);
+        const searchEf = Math.min(1e3, Math.max(1, calculatedEf));
+        await client.query(`SET LOCAL hnsw.ef_search = ${searchEf}`);
+      }
+      if (indexInfo.type === "ivfflat" && probes) {
+        await client.query(`SET LOCAL ivfflat.probes = ${probes}`);
+      }
+      const query = `
+        WITH vector_scores AS (
+          SELECT
+            vector_id as id,
+            1 - (embedding <=> '${vectorStr}'::vector) as score,
+            metadata
+            ${includeVector ? ", embedding" : ""}
+          FROM ${indexName}
+          ${filterQuery}
+        )
+        SELECT *
+        FROM vector_scores
+        WHERE score > $1
+        ORDER BY score DESC
+        LIMIT ${topK}`;
+      const result = await client.query(query, filterValues);
+      return result.rows.map(({ id, score, metadata, embedding }) => ({
+        id,
+        score,
+        metadata,
+        ...includeVector && embedding && { vector: JSON.parse(embedding) }
+      }));
+    } finally {
+      client.release();
+    }
+  }
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args);
+    const { indexName, vectors, metadata, ids } = params;
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const vectorIds = ids || vectors.map(() => crypto.randomUUID());
+      for (let i = 0; i < vectors.length; i++) {
+        const query = `
+          INSERT INTO ${indexName} (vector_id, embedding, metadata)
+          VALUES ($1, $2::vector, $3::jsonb)
+          ON CONFLICT (vector_id)
+          DO UPDATE SET
+            embedding = $2::vector,
+            metadata = $3::jsonb
+          RETURNING embedding::text
+        `;
+        await client.query(query, [vectorIds[i], `[${vectors[i]?.join(",")}]`, JSON.stringify(metadata?.[i] || {})]);
+      }
+      await client.query("COMMIT");
+      return vectorIds;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args, ["indexConfig", "buildIndex"]);
+    const { indexName, dimension, metric = "cosine", indexConfig = {}, buildIndex = true } = params;
+    const client = await this.pool.connect();
+    try {
+      if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
+        throw new Error("Invalid index name format");
+      }
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+      const extensionCheck = await client.query(`
+        SELECT EXISTS (
+          SELECT 1 FROM pg_available_extensions WHERE name = 'vector'
+        );
+      `);
+      if (!extensionCheck.rows[0].exists) {
+        throw new Error("PostgreSQL vector extension is not available. Please install it first.");
+      }
+      await client.query("CREATE EXTENSION IF NOT EXISTS vector");
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS ${indexName} (
+          id SERIAL PRIMARY KEY,
+          vector_id TEXT UNIQUE NOT NULL,
+          embedding vector(${dimension}),
+          metadata JSONB DEFAULT '{}'::jsonb
+        );
+      `);
+      if (buildIndex) {
+        await this.buildIndex({ indexName, metric, indexConfig });
+      }
+    } catch (error) {
+      console.error("Failed to create vector table:", error);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * @deprecated This function is deprecated. Use buildIndex instead
+   */
+  async defineIndex(indexName, metric = "cosine", indexConfig) {
+    return this.buildIndex({ indexName, metric, indexConfig });
+  }
+  async buildIndex(...args) {
+    const params = this.normalizeArgs("buildIndex", args, ["metric", "indexConfig"]);
+    const { indexName, metric = "cosine", indexConfig } = params;
+    const client = await this.pool.connect();
+    try {
+      await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
+      if (indexConfig.type === "flat") return;
+      const metricOp = metric === "cosine" ? "vector_cosine_ops" : metric === "euclidean" ? "vector_l2_ops" : "vector_ip_ops";
+      let indexSQL;
+      if (indexConfig.type === "hnsw") {
+        const m = indexConfig.hnsw?.m ?? 8;
+        const efConstruction = indexConfig.hnsw?.efConstruction ?? 32;
+        indexSQL = `
+          CREATE INDEX ${indexName}_vector_idx 
+          ON ${indexName} 
+          USING hnsw (embedding ${metricOp})
+          WITH (
+            m = ${m},
+            ef_construction = ${efConstruction}
+          )
+        `;
+      } else {
+        let lists;
+        if (indexConfig.ivf?.lists) {
+          lists = indexConfig.ivf.lists;
+        } else {
+          const size = (await client.query(`SELECT COUNT(*) FROM ${indexName}`)).rows[0].count;
+          lists = Math.max(100, Math.min(4e3, Math.floor(Math.sqrt(size) * 2)));
+        }
+        indexSQL = `
+          CREATE INDEX ${indexName}_vector_idx
+          ON ${indexName}
+          USING ivfflat (embedding ${metricOp})
+          WITH (lists = ${lists});
+        `;
+      }
+      await client.query(indexSQL);
+      this.indexCache.delete(indexName);
+    } finally {
+      client.release();
+    }
+  }
+  async listIndexes() {
+    const client = await this.pool.connect();
+    try {
+      const vectorTablesQuery = `
+            SELECT DISTINCT table_name
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+            AND udt_name = 'vector';
+        `;
+      const vectorTables = await client.query(vectorTablesQuery);
+      return vectorTables.rows.map((row) => row.table_name);
+    } finally {
+      client.release();
+    }
+  }
+  async describeIndex(indexName) {
+    const client = await this.pool.connect();
+    try {
+      const dimensionQuery = `
+                SELECT atttypmod as dimension
+                FROM pg_attribute
+                WHERE attrelid = $1::regclass
+                AND attname = 'embedding';
+            `;
+      const countQuery = `
+                SELECT COUNT(*) as count
+                FROM ${indexName};
+            `;
+      const indexQuery = `
+            SELECT
+                am.amname as index_method,
+                pg_get_indexdef(i.indexrelid) as index_def,
+                opclass.opcname as operator_class
+            FROM pg_index i
+            JOIN pg_class c ON i.indexrelid = c.oid
+            JOIN pg_am am ON c.relam = am.oid
+            JOIN pg_opclass opclass ON i.indclass[0] = opclass.oid
+            WHERE c.relname = '${indexName}_vector_idx';
+            `;
+      const [dimResult, countResult, indexResult] = await Promise.all([
+        client.query(dimensionQuery, [indexName]),
+        client.query(countQuery),
+        client.query(indexQuery)
+      ]);
+      const { index_method, index_def, operator_class } = indexResult.rows[0] || {
+        index_method: "flat",
+        index_def: "",
+        operator_class: "cosine"
+      };
+      const metric = operator_class.includes("l2") ? "euclidean" : operator_class.includes("ip") ? "dotproduct" : "cosine";
+      const config = {};
+      if (index_method === "hnsw") {
+        const m = index_def.match(/m\s*=\s*'?(\d+)'?/)?.[1];
+        const efConstruction = index_def.match(/ef_construction\s*=\s*'?(\d+)'?/)?.[1];
+        if (m) config.m = parseInt(m);
+        if (efConstruction) config.efConstruction = parseInt(efConstruction);
+      } else if (index_method === "ivfflat") {
+        const lists = index_def.match(/lists\s*=\s*'?(\d+)'?/)?.[1];
+        if (lists) config.lists = parseInt(lists);
+      }
+      return {
+        dimension: dimResult.rows[0].dimension,
+        count: parseInt(countResult.rows[0].count),
+        metric,
+        type: index_method,
+        config
+      };
+    } catch (e) {
+      await client.query("ROLLBACK");
+      throw new Error(`Failed to describe vector table: ${e.message}`);
+    } finally {
+      client.release();
+    }
+  }
+  async deleteIndex(indexName) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(`DROP TABLE IF EXISTS ${indexName} CASCADE`);
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw new Error(`Failed to delete vector table: ${error.message}`);
+    } finally {
+      client.release();
+    }
+  }
+  async truncateIndex(indexName) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(`TRUNCATE ${indexName}`);
+    } catch (e) {
+      await client.query("ROLLBACK");
+      throw new Error(`Failed to truncate vector table: ${e.message}`);
+    } finally {
+      client.release();
+    }
+  }
+  async disconnect() {
+    await this.pool.end();
+  }
+};
+var PostgresStore = class extends storage.MastraStorage {
+  db;
+  pgp;
+  constructor(config) {
+    super({ name: "PostgresStore" });
+    this.pgp = pgPromise__default.default();
+    this.db = this.pgp(
+      `connectionString` in config ? { connectionString: config.connectionString } : {
+        host: config.host,
+        port: config.port,
+        database: config.database,
+        user: config.user,
+        password: config.password
+      }
+    );
+  }
+  getEvalsByAgentName(_agentName, _type) {
+    throw new Error("Method not implemented.");
+  }
+  async batchInsert({ tableName, records }) {
+    try {
+      await this.db.query("BEGIN");
+      for (const record of records) {
+        await this.insert({ tableName, record });
+      }
+      await this.db.query("COMMIT");
+    } catch (error) {
+      console.error(`Error inserting into ${tableName}:`, error);
+      await this.db.query("ROLLBACK");
+      throw error;
+    }
+  }
+  async getTraces({
+    name,
+    scope,
+    page,
+    perPage,
+    attributes
+  }) {
+    let idx = 1;
+    const limit = perPage;
+    const offset = page * perPage;
+    const args = [];
+    const conditions = [];
+    if (name) {
+      conditions.push(`name LIKE CONCAT($${idx++}, '%')`);
+    }
+    if (scope) {
+      conditions.push(`scope = $${idx++}`);
+    }
+    if (attributes) {
+      Object.keys(attributes).forEach((key) => {
+        conditions.push(`attributes->>'${key}' = $${idx++}`);
+      });
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    if (name) {
+      args.push(name);
+    }
+    if (scope) {
+      args.push(scope);
+    }
+    if (attributes) {
+      for (const [_key, value] of Object.entries(attributes)) {
+        args.push(value);
+      }
+    }
+    console.log(
+      "QUERY",
+      `SELECT * FROM ${storage.MastraStorage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
+      args
+    );
+    const result = await this.db.manyOrNone(
+      `SELECT * FROM ${storage.MastraStorage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
+      args
+    );
+    if (!result) {
+      return [];
+    }
+    return result.map((row) => ({
+      id: row.id,
+      parentSpanId: row.parentSpanId,
+      traceId: row.traceId,
+      name: row.name,
+      scope: row.scope,
+      kind: row.kind,
+      status: row.status,
+      events: row.events,
+      links: row.links,
+      attributes: row.attributes,
+      startTime: row.startTime,
+      endTime: row.endTime,
+      other: row.other,
+      createdAt: row.createdAt
+    }));
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    try {
+      const columns = Object.entries(schema).map(([name, def]) => {
+        const constraints = [];
+        if (def.primaryKey) constraints.push("PRIMARY KEY");
+        if (!def.nullable) constraints.push("NOT NULL");
+        return `"${name}" ${def.type.toUpperCase()} ${constraints.join(" ")}`;
+      }).join(",\n");
+      const sql = `
+        CREATE TABLE IF NOT EXISTS ${tableName} (
+          ${columns}
+        );
+        ${tableName === storage.MastraStorage.TABLE_WORKFLOW_SNAPSHOT ? `
+        DO $$ BEGIN
+          IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint WHERE conname = 'mastra_workflow_snapshot_workflow_name_run_id_key'
+          ) THEN
+            ALTER TABLE ${tableName}
+            ADD CONSTRAINT mastra_workflow_snapshot_workflow_name_run_id_key
+            UNIQUE (workflow_name, run_id);
+          END IF;
+        END $$;
+        ` : ""}
+      `;
+      await this.db.none(sql);
+    } catch (error) {
+      console.error(`Error creating table ${tableName}:`, error);
+      throw error;
+    }
+  }
+  async clearTable({ tableName }) {
+    try {
+      await this.db.none(`TRUNCATE TABLE ${tableName} CASCADE`);
+    } catch (error) {
+      console.error(`Error clearing table ${tableName}:`, error);
+      throw error;
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      const columns = Object.keys(record);
+      const values = Object.values(record);
+      const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+      await this.db.none(
+        `INSERT INTO ${tableName} (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
+        values
+      );
+    } catch (error) {
+      console.error(`Error inserting into ${tableName}:`, error);
+      throw error;
+    }
+  }
+  async load({ tableName, keys }) {
+    try {
+      const keyEntries = Object.entries(keys);
+      const conditions = keyEntries.map(([key], index) => `"${key}" = $${index + 1}`).join(" AND ");
+      const values = keyEntries.map(([_, value]) => value);
+      const result = await this.db.oneOrNone(`SELECT * FROM ${tableName} WHERE ${conditions}`, values);
+      if (!result) {
+        return null;
+      }
+      if (tableName === storage.MastraStorage.TABLE_WORKFLOW_SNAPSHOT) {
+        const snapshot = result;
+        if (typeof snapshot.snapshot === "string") {
+          snapshot.snapshot = JSON.parse(snapshot.snapshot);
+        }
+        return snapshot;
+      }
+      return result;
+    } catch (error) {
+      console.error(`Error loading from ${tableName}:`, error);
+      throw error;
+    }
+  }
+  async getThreadById({ threadId }) {
+    try {
+      const thread = await this.db.oneOrNone(
+        `SELECT 
+          id,
+          "resourceId",
+          title,
+          metadata,
+          "createdAt",
+          "updatedAt"
+        FROM "${storage.MastraStorage.TABLE_THREADS}"
+        WHERE id = $1`,
+        [threadId]
+      );
+      if (!thread) {
+        return null;
+      }
+      return {
+        ...thread,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt
+      };
+    } catch (error) {
+      console.error(`Error getting thread ${threadId}:`, error);
+      throw error;
+    }
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    try {
+      const threads = await this.db.manyOrNone(
+        `SELECT 
+          id,
+          "resourceId",
+          title,
+          metadata,
+          "createdAt",
+          "updatedAt"
+        FROM "${storage.MastraStorage.TABLE_THREADS}"
+        WHERE "resourceId" = $1`,
+        [resourceId]
+      );
+      return threads.map((thread) => ({
+        ...thread,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt
+      }));
+    } catch (error) {
+      console.error(`Error getting threads for resource ${resourceId}:`, error);
+      throw error;
+    }
+  }
+  async saveThread({ thread }) {
+    try {
+      await this.db.none(
+        `INSERT INTO "${storage.MastraStorage.TABLE_THREADS}" (
+          id,
+          "resourceId",
+          title,
+          metadata,
+          "createdAt",
+          "updatedAt"
+        ) VALUES ($1, $2, $3, $4, $5, $6)
+        ON CONFLICT (id) DO UPDATE SET
+          "resourceId" = EXCLUDED."resourceId",
+          title = EXCLUDED.title,
+          metadata = EXCLUDED.metadata,
+          "createdAt" = EXCLUDED."createdAt",
+          "updatedAt" = EXCLUDED."updatedAt"`,
+        [
+          thread.id,
+          thread.resourceId,
+          thread.title,
+          thread.metadata ? JSON.stringify(thread.metadata) : null,
+          thread.createdAt,
+          thread.updatedAt
+        ]
+      );
+      return thread;
+    } catch (error) {
+      console.error("Error saving thread:", error);
+      throw error;
+    }
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    try {
+      const existingThread = await this.getThreadById({ threadId: id });
+      if (!existingThread) {
+        throw new Error(`Thread ${id} not found`);
+      }
+      const mergedMetadata = {
+        ...existingThread.metadata,
+        ...metadata
+      };
+      const thread = await this.db.one(
+        `UPDATE "${storage.MastraStorage.TABLE_THREADS}"
+        SET title = $1,
+            metadata = $2,
+            "updatedAt" = $3
+        WHERE id = $4
+        RETURNING *`,
+        [title, mergedMetadata, (/* @__PURE__ */ new Date()).toISOString(), id]
+      );
+      return {
+        ...thread,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt
+      };
+    } catch (error) {
+      console.error("Error updating thread:", error);
+      throw error;
+    }
+  }
+  async deleteThread({ threadId }) {
+    try {
+      await this.db.tx(async (t) => {
+        await t.none(`DELETE FROM "${storage.MastraStorage.TABLE_MESSAGES}" WHERE thread_id = $1`, [threadId]);
+        await t.none(`DELETE FROM "${storage.MastraStorage.TABLE_THREADS}" WHERE id = $1`, [threadId]);
+      });
+    } catch (error) {
+      console.error("Error deleting thread:", error);
+      throw error;
+    }
+  }
+  async getMessages({ threadId, selectBy }) {
+    try {
+      const messages = [];
+      const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
+      const include = selectBy?.include || [];
+      if (include.length) {
+        const includeResult = await this.db.manyOrNone(
+          `
+          WITH ordered_messages AS (
+            SELECT 
+              *,
+              ROW_NUMBER() OVER (ORDER BY "createdAt" DESC) as row_num
+            FROM "${storage.MastraStorage.TABLE_MESSAGES}"
+            WHERE thread_id = $1
+          )
+          SELECT
+            m.id, 
+            m.content, 
+            m.role, 
+            m.type,
+            m."createdAt", 
+            m.thread_id AS "threadId"
+          FROM ordered_messages m
+          WHERE m.id = ANY($2)
+          OR EXISTS (
+            SELECT 1 FROM ordered_messages target
+            WHERE target.id = ANY($2)
+            AND (
+              -- Get previous messages based on the max withPreviousMessages
+              (m.row_num <= target.row_num + $3 AND m.row_num > target.row_num)
+              OR
+              -- Get next messages based on the max withNextMessages
+              (m.row_num >= target.row_num - $4 AND m.row_num < target.row_num)
+            )
+          )
+          ORDER BY m."createdAt" DESC
+          `,
+          [
+            threadId,
+            include.map((i) => i.id),
+            Math.max(...include.map((i) => i.withPreviousMessages || 0)),
+            Math.max(...include.map((i) => i.withNextMessages || 0))
+          ]
+        );
+        messages.push(...includeResult);
+      }
+      const result = await this.db.manyOrNone(
+        `
+        SELECT 
+            id, 
+            content, 
+            role, 
+            type,
+            "createdAt", 
+            thread_id AS "threadId"
+        FROM "${storage.MastraStorage.TABLE_MESSAGES}"
+        WHERE thread_id = $1
+        AND id != ALL($2)
+        ORDER BY "createdAt" DESC
+        LIMIT $3
+        `,
+        [threadId, messages.map((m) => m.id), limit]
+      );
+      messages.push(...result);
+      messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      messages.forEach((message) => {
+        if (typeof message.content === "string") {
+          try {
+            message.content = JSON.parse(message.content);
+          } catch {
+          }
+        }
+      });
+      return messages;
+    } catch (error) {
+      console.error("Error getting messages:", error);
+      throw error;
+    }
+  }
+  async saveMessages({ messages }) {
+    if (messages.length === 0) return messages;
+    try {
+      const threadId = messages[0]?.threadId;
+      if (!threadId) {
+        throw new Error("Thread ID is required");
+      }
+      const thread = await this.getThreadById({ threadId });
+      if (!thread) {
+        throw new Error(`Thread ${threadId} not found`);
+      }
+      await this.db.tx(async (t) => {
+        for (const message of messages) {
+          await t.none(
+            `INSERT INTO "${storage.MastraStorage.TABLE_MESSAGES}" (id, thread_id, content, "createdAt", role, type) 
+             VALUES ($1, $2, $3, $4, $5, $6)`,
+            [
+              message.id,
+              threadId,
+              typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+              message.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+              message.role,
+              message.type
+            ]
+          );
+        }
+      });
+      return messages;
+    } catch (error) {
+      console.error("Error saving messages:", error);
+      throw error;
+    }
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await this.db.none(
+        `INSERT INTO "${storage.MastraStorage.TABLE_WORKFLOW_SNAPSHOT}" (
+          workflow_name,
+          run_id,
+          snapshot,
+          "createdAt",
+          "updatedAt"
+        ) VALUES ($1, $2, $3, $4, $5)
+        ON CONFLICT (workflow_name, run_id) DO UPDATE
+        SET snapshot = EXCLUDED.snapshot,
+            "updatedAt" = EXCLUDED."updatedAt"`,
+        [workflowName, runId, JSON.stringify(snapshot), now, now]
+      );
+    } catch (error) {
+      console.error("Error persisting workflow snapshot:", error);
+      throw error;
+    }
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    try {
+      const result = await this.load({
+        tableName: storage.MastraStorage.TABLE_WORKFLOW_SNAPSHOT,
+        keys: {
+          workflow_name: workflowName,
+          run_id: runId
+        }
+      });
+      if (!result) {
+        return null;
+      }
+      return result.snapshot;
+    } catch (error) {
+      console.error("Error loading workflow snapshot:", error);
+      throw error;
+    }
+  }
+  async close() {
+    this.pgp.end();
+  }
+};
+
+exports.PgVector = PgVector;
+exports.PostgresStore = PostgresStore;