@mastra/pg 0.2.10-alpha.4 → 0.2.10-alpha.5

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.2.10-alpha.4 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.2.10-alpha.5 build /home/runner/work/mastra/mastra/stores/pg
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.4.0
 TSC Build start
-TSC ⚡️ Build success in 12130ms
+TSC ⚡️ Build success in 10784ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/pg/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/pg/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 11695ms
+DTS ⚡️ Build success in 10970ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 41.83 KB
-CJS ⚡️ Build success in 1205ms
-ESM dist/index.js 41.41 KB
-ESM ⚡️ Build success in 1205ms
+CJS dist/index.cjs 46.10 KB
+CJS ⚡️ Build success in 1339ms
+ESM dist/index.js 45.68 KB
+ESM ⚡️ Build success in 1339ms

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @mastra/pg
 
+## 0.2.10-alpha.5
+
+### Patch Changes
+
+- 5e846ee: feat(@mastra/pg): schema support
+
 ## 0.2.10-alpha.4
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -203,10 +203,18 @@ declare class PgVector extends MastraVector {
     private describeIndexCache;
     private createdIndexes;
     private mutexesByName;
+    private schema?;
+    private setupSchemaPromise;
     private installVectorExtensionPromise;
     private vectorExtensionInstalled;
+    private schemaSetupComplete;
     constructor(connectionString: string);
+    constructor(config: {
+        connectionString: string;
+        schemaName?: string;
+    });
     private getMutexByName;
+    private getTableName;
     transformFilter(filter?: VectorFilter): VectorFilter;
     getIndexInfo(indexName: string): Promise<PGIndexStats>;
     query(...args: ParamsToArgs<PgQueryVectorParams> | PgQueryVectorArgs): Promise<QueryResult[]>;
@@ -214,6 +222,7 @@ declare class PgVector extends MastraVector {
     private hasher;
     private getIndexCacheKey;
     private cachedIndexExists;
+    private setupSchema;
     createIndex(...args: ParamsToArgs<PgCreateIndexParams> | PgCreateIndexArgs): Promise<void>;
     /**
      * @deprecated This function is deprecated. Use buildIndex instead
@@ -237,6 +246,8 @@ export { PgVector }
 export { PgVector as PgVector_alias_1 }
 
 declare type PostgresConfig = {
+    schema?: string;
+} & ({
     host: string;
     port: number;
     database: string;
@@ -245,14 +256,18 @@ declare type PostgresConfig = {
     ssl?: boolean | ISSLConfig;
 } | {
     connectionString: string;
-};
+});
 export { PostgresConfig }
 export { PostgresConfig as PostgresConfig_alias_1 }
 
 declare class PostgresStore extends MastraStorage {
     private db;
     private pgp;
+    private schema?;
+    private setupSchemaPromise;
+    private schemaSetupComplete;
     constructor(config: PostgresConfig);
+    private getTableName;
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
     private transformEvalRow;
     batchInsert({ tableName, records }: {
@@ -267,6 +282,7 @@ declare class PostgresStore extends MastraStorage {
         attributes?: Record<string, string>;
         filters?: Record<string, any>;
     }): Promise<any[]>;
+    private setupSchema;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;

package/dist/_tsup-dts-rollup.d.ts

@@ -203,10 +203,18 @@ declare class PgVector extends MastraVector {
     private describeIndexCache;
     private createdIndexes;
     private mutexesByName;
+    private schema?;
+    private setupSchemaPromise;
     private installVectorExtensionPromise;
     private vectorExtensionInstalled;
+    private schemaSetupComplete;
     constructor(connectionString: string);
+    constructor(config: {
+        connectionString: string;
+        schemaName?: string;
+    });
     private getMutexByName;
+    private getTableName;
     transformFilter(filter?: VectorFilter): VectorFilter;
     getIndexInfo(indexName: string): Promise<PGIndexStats>;
     query(...args: ParamsToArgs<PgQueryVectorParams> | PgQueryVectorArgs): Promise<QueryResult[]>;
@@ -214,6 +222,7 @@ declare class PgVector extends MastraVector {
     private hasher;
     private getIndexCacheKey;
     private cachedIndexExists;
+    private setupSchema;
     createIndex(...args: ParamsToArgs<PgCreateIndexParams> | PgCreateIndexArgs): Promise<void>;
     /**
      * @deprecated This function is deprecated. Use buildIndex instead
@@ -237,6 +246,8 @@ export { PgVector }
 export { PgVector as PgVector_alias_1 }
 
 declare type PostgresConfig = {
+    schema?: string;
+} & ({
     host: string;
     port: number;
     database: string;
@@ -245,14 +256,18 @@ declare type PostgresConfig = {
     ssl?: boolean | ISSLConfig;
 } | {
     connectionString: string;
-};
+});
 export { PostgresConfig }
 export { PostgresConfig as PostgresConfig_alias_1 }
 
 declare class PostgresStore extends MastraStorage {
     private db;
     private pgp;
+    private schema?;
+    private setupSchemaPromise;
+    private schemaSetupComplete;
     constructor(config: PostgresConfig);
+    private getTableName;
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
     private transformEvalRow;
     batchInsert({ tableName, records }: {
@@ -267,6 +282,7 @@ declare class PostgresStore extends MastraStorage {
         attributes?: Record<string, string>;
         filters?: Record<string, any>;
     }): Promise<any[]>;
+    private setupSchema;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;

package/dist/index.cjs

@@ -299,10 +299,15 @@ var PgVector = class extends vector.MastraVector {
   describeIndexCache = /* @__PURE__ */ new Map();
   createdIndexes = /* @__PURE__ */ new Map();
   mutexesByName = /* @__PURE__ */ new Map();
+  schema;
+  setupSchemaPromise = null;
   installVectorExtensionPromise = null;
   vectorExtensionInstalled = void 0;
-  constructor(connectionString) {
+  schemaSetupComplete = void 0;
+  constructor(config) {
     super();
+    const connectionString = typeof config === "string" ? config : config.connectionString;
+    this.schema = typeof config === "string" ? void 0 : config.schemaName;
     const basePool = new pg__default.default.Pool({
       connectionString,
       max: 20,
@@ -337,6 +342,9 @@ var PgVector = class extends vector.MastraVector {
     if (!this.mutexesByName.has(indexName)) this.mutexesByName.set(indexName, new asyncMutex.Mutex());
     return this.mutexesByName.get(indexName);
   }
+  getTableName(indexName) {
+    return this.schema ? `${this.schema}.${indexName}` : indexName;
+  }
   transformFilter(filter) {
     const translator = new PGFilterTranslator();
     return translator.translate(filter);
@@ -368,6 +376,7 @@ var PgVector = class extends vector.MastraVector {
       if (indexInfo.type === "ivfflat" && probes) {
         await client.query(`SET LOCAL ivfflat.probes = ${probes}`);
       }
+      const tableName = this.getTableName(indexName);
       const query = `
         WITH vector_scores AS (
           SELECT
@@ -375,7 +384,7 @@ var PgVector = class extends vector.MastraVector {
             1 - (embedding <=> '${vectorStr}'::vector) as score,
             metadata
             ${includeVector ? ", embedding" : ""}
-          FROM ${indexName}
+          FROM ${tableName}
           ${filterQuery}
         )
         SELECT *
@@ -397,13 +406,14 @@ var PgVector = class extends vector.MastraVector {
   async upsert(...args) {
     const params = this.normalizeArgs("upsert", args);
     const { indexName, vectors, metadata, ids } = params;
+    const tableName = this.getTableName(indexName);
     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)
+          INSERT INTO ${tableName} (vector_id, embedding, metadata)
           VALUES ($1, $2::vector, $3::jsonb)
           ON CONFLICT (vector_id)
           DO UPDATE SET
@@ -440,12 +450,54 @@ var PgVector = class extends vector.MastraVector {
     const existingIndexCacheKey = this.createdIndexes.get(indexName);
     return existingIndexCacheKey && existingIndexCacheKey === newKey;
   }
+  async setupSchema(client) {
+    if (!this.schema || this.schemaSetupComplete) {
+      return;
+    }
+    if (!this.setupSchemaPromise) {
+      this.setupSchemaPromise = (async () => {
+        try {
+          const schemaCheck = await client.query(
+            `
+            SELECT EXISTS (
+              SELECT 1 FROM information_schema.schemata 
+              WHERE schema_name = $1
+            )
+          `,
+            [this.schema]
+          );
+          const schemaExists = schemaCheck.rows[0].exists;
+          if (!schemaExists) {
+            try {
+              await client.query(`CREATE SCHEMA IF NOT EXISTS ${this.schema}`);
+              this.logger.info(`Schema "${this.schema}" created successfully`);
+            } catch (error) {
+              this.logger.error(`Failed to create schema "${this.schema}"`, { error });
+              throw new Error(
+                `Unable to create schema "${this.schema}". This requires CREATE privilege on the database. Either create the schema manually or grant CREATE privilege to the user.`
+              );
+            }
+          }
+          this.schemaSetupComplete = true;
+          this.logger.debug(`Schema "${this.schema}" is ready for use`);
+        } catch (error) {
+          this.schemaSetupComplete = void 0;
+          this.setupSchemaPromise = null;
+          throw error;
+        } finally {
+          this.setupSchemaPromise = null;
+        }
+      })();
+    }
+    await this.setupSchemaPromise;
+  }
   async createIndex(...args) {
     const params = this.normalizeArgs("createIndex", args, [
       "indexConfig",
       "buildIndex"
     ]);
     const { indexName, dimension, metric = "cosine", indexConfig = {}, buildIndex = true } = params;
+    const tableName = this.getTableName(indexName);
     if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
       throw new Error("Invalid index name format");
     }
@@ -463,22 +515,22 @@ var PgVector = class extends vector.MastraVector {
       }
       const client = await this.pool.connect();
       try {
+        await this.setupSchema(client);
         await this.installVectorExtension(client);
         await client.query(`
-          CREATE TABLE IF NOT EXISTS ${indexName} (
+          CREATE TABLE IF NOT EXISTS ${tableName} (
             id SERIAL PRIMARY KEY,
             vector_id TEXT UNIQUE NOT NULL,
             embedding vector(${dimension}),
             metadata JSONB DEFAULT '{}'::jsonb
           );
-      `);
+        `);
         this.createdIndexes.set(indexName, indexCacheKey);
         if (buildIndex) {
           await this.setupIndex({ indexName, metric, indexConfig }, client);
         }
       } catch (error) {
         this.createdIndexes.delete(indexName);
-        console.error("Failed to create vector table:", error);
         throw error;
       } finally {
         client.release();
@@ -507,8 +559,9 @@ var PgVector = class extends vector.MastraVector {
   async setupIndex({ indexName, metric, indexConfig }, client) {
     const mutex = this.getMutexByName(`build-${indexName}`);
     await mutex.runExclusive(async () => {
+      const tableName = this.getTableName(indexName);
       if (this.createdIndexes.has(indexName)) {
-        await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
+        await client.query(`DROP INDEX IF EXISTS ${tableName}_vector_idx`);
       }
       if (indexConfig.type === "flat") {
         this.describeIndexCache.delete(indexName);
@@ -521,7 +574,7 @@ var PgVector = class extends vector.MastraVector {
         const efConstruction = indexConfig.hnsw?.efConstruction ?? 32;
         indexSQL = `
           CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx 
-          ON ${indexName} 
+          ON ${tableName} 
           USING hnsw (embedding ${metricOp})
           WITH (
             m = ${m},
@@ -533,12 +586,12 @@ var PgVector = class extends vector.MastraVector {
         if (indexConfig.ivf?.lists) {
           lists = indexConfig.ivf.lists;
         } else {
-          const size = (await client.query(`SELECT COUNT(*) FROM ${indexName}`)).rows[0].count;
+          const size = (await client.query(`SELECT COUNT(*) FROM ${tableName}`)).rows[0].count;
           lists = Math.max(100, Math.min(4e3, Math.floor(Math.sqrt(size) * 2)));
         }
         indexSQL = `
           CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx
-          ON ${indexName}
+          ON ${tableName}
           USING ivfflat (embedding ${metricOp})
           WITH (lists = ${lists});
         `;
@@ -590,10 +643,10 @@ var PgVector = class extends vector.MastraVector {
       const vectorTablesQuery = `
             SELECT DISTINCT table_name
             FROM information_schema.columns
-            WHERE table_schema = 'public'
+            WHERE table_schema = $1
             AND udt_name = 'vector';
         `;
-      const vectorTables = await client.query(vectorTablesQuery);
+      const vectorTables = await client.query(vectorTablesQuery, [this.schema || "public"]);
       return vectorTables.rows.map((row) => row.table_name);
     } finally {
       client.release();
@@ -602,14 +655,16 @@ var PgVector = class extends vector.MastraVector {
   async describeIndex(indexName) {
     const client = await this.pool.connect();
     try {
+      const tableName = this.getTableName(indexName);
       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 countQuery = `
+                SELECT COUNT(*) as count
+                FROM ${tableName};
             `;
       const indexQuery = `
             SELECT
@@ -620,10 +675,10 @@ var PgVector = class extends vector.MastraVector {
             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';
+            WHERE c.relname = '${tableName}_vector_idx';
             `;
       const [dimResult, countResult, indexResult] = await Promise.all([
-        client.query(dimensionQuery, [indexName]),
+        client.query(dimensionQuery, [tableName]),
         client.query(countQuery),
         client.query(indexQuery)
       ]);
@@ -660,7 +715,8 @@ var PgVector = class extends vector.MastraVector {
   async deleteIndex(indexName) {
     const client = await this.pool.connect();
     try {
-      await client.query(`DROP TABLE IF EXISTS ${indexName} CASCADE`);
+      const tableName = this.getTableName(indexName);
+      await client.query(`DROP TABLE IF EXISTS ${tableName} CASCADE`);
       this.createdIndexes.delete(indexName);
     } catch (error) {
       await client.query("ROLLBACK");
@@ -672,7 +728,8 @@ var PgVector = class extends vector.MastraVector {
   async truncateIndex(indexName) {
     const client = await this.pool.connect();
     try {
-      await client.query(`TRUNCATE ${indexName}`);
+      const tableName = this.getTableName(indexName);
+      await client.query(`TRUNCATE ${tableName}`);
     } catch (e) {
       await client.query("ROLLBACK");
       throw new Error(`Failed to truncate vector table: ${e.message}`);
@@ -704,8 +761,9 @@ var PgVector = class extends vector.MastraVector {
       if (updateParts.length === 0) {
         return;
       }
+      const tableName = this.getTableName(indexName);
       const query = `
-        UPDATE ${indexName}
+        UPDATE ${tableName}
         SET ${updateParts.join(", ")}
         WHERE vector_id = $1
       `;
@@ -717,8 +775,9 @@ var PgVector = class extends vector.MastraVector {
   async deleteIndexById(indexName, id) {
     const client = await this.pool.connect();
     try {
+      const tableName = this.getTableName(indexName);
       const query = `
-        DELETE FROM ${indexName}
+        DELETE FROM ${tableName}
         WHERE vector_id = $1
       `;
       await client.query(query, [id]);
@@ -730,9 +789,13 @@ var PgVector = class extends vector.MastraVector {
 var PostgresStore = class extends storage.MastraStorage {
   db;
   pgp;
+  schema;
+  setupSchemaPromise = null;
+  schemaSetupComplete = void 0;
   constructor(config) {
     super({ name: "PostgresStore" });
     this.pgp = pgPromise__default.default();
+    this.schema = config.schema;
     this.db = this.pgp(
       `connectionString` in config ? { connectionString: config.connectionString } : {
         host: config.host,
@@ -744,9 +807,12 @@ var PostgresStore = class extends storage.MastraStorage {
       }
     );
   }
+  getTableName(indexName) {
+    return this.schema ? `${this.schema}."${indexName}"` : `"${indexName}"`;
+  }
   async getEvalsByAgentName(agentName, type) {
     try {
-      const baseQuery = `SELECT * FROM ${storage.TABLE_EVALS} WHERE agent_name = $1`;
+      const baseQuery = `SELECT * FROM ${this.getTableName(storage.TABLE_EVALS)} WHERE agent_name = $1`;
       const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
       const query = `${baseQuery}${typeCondition} ORDER BY created_at DESC`;
       const rows = await this.db.manyOrNone(query, [agentName]);
@@ -840,7 +906,10 @@ var PostgresStore = class extends storage.MastraStorage {
         args.push(value);
       }
     }
-    const result = await this.db.manyOrNone(`SELECT * FROM ${storage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`, args);
+    const result = await this.db.manyOrNone(
+      `SELECT * FROM ${this.getTableName(storage.TABLE_TRACES)} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
+      args
+    );
     if (!result) {
       return [];
     }
@@ -861,6 +930,46 @@ var PostgresStore = class extends storage.MastraStorage {
       createdAt: row.createdAt
     }));
   }
+  async setupSchema() {
+    if (!this.schema || this.schemaSetupComplete) {
+      return;
+    }
+    if (!this.setupSchemaPromise) {
+      this.setupSchemaPromise = (async () => {
+        try {
+          const schemaExists = await this.db.oneOrNone(
+            `
+            SELECT EXISTS (
+              SELECT 1 FROM information_schema.schemata 
+              WHERE schema_name = $1
+            )
+          `,
+            [this.schema]
+          );
+          if (!schemaExists?.exists) {
+            try {
+              await this.db.none(`CREATE SCHEMA IF NOT EXISTS ${this.schema}`);
+              this.logger.info(`Schema "${this.schema}" created successfully`);
+            } catch (error) {
+              this.logger.error(`Failed to create schema "${this.schema}"`, { error });
+              throw new Error(
+                `Unable to create schema "${this.schema}". This requires CREATE privilege on the database. Either create the schema manually or grant CREATE privilege to the user.`
+              );
+            }
+          }
+          this.schemaSetupComplete = true;
+          this.logger.debug(`Schema "${this.schema}" is ready for use`);
+        } catch (error) {
+          this.schemaSetupComplete = void 0;
+          this.setupSchemaPromise = null;
+          throw error;
+        } finally {
+          this.setupSchemaPromise = null;
+        }
+      })();
+    }
+    await this.setupSchemaPromise;
+  }
   async createTable({
     tableName,
     schema
@@ -872,8 +981,11 @@ var PostgresStore = class extends storage.MastraStorage {
         if (!def.nullable) constraints.push("NOT NULL");
         return `"${name}" ${def.type.toUpperCase()} ${constraints.join(" ")}`;
       }).join(",\n");
+      if (this.schema) {
+        await this.setupSchema();
+      }
       const sql = `
-        CREATE TABLE IF NOT EXISTS ${tableName} (
+        CREATE TABLE IF NOT EXISTS ${this.getTableName(tableName)} (
           ${columns}
         );
         ${tableName === storage.TABLE_WORKFLOW_SNAPSHOT ? `
@@ -881,7 +993,7 @@ var PostgresStore = class extends storage.MastraStorage {
           IF NOT EXISTS (
             SELECT 1 FROM pg_constraint WHERE conname = 'mastra_workflow_snapshot_workflow_name_run_id_key'
           ) THEN
-            ALTER TABLE ${tableName}
+            ALTER TABLE ${this.getTableName(tableName)}
             ADD CONSTRAINT mastra_workflow_snapshot_workflow_name_run_id_key
             UNIQUE (workflow_name, run_id);
           END IF;
@@ -896,7 +1008,7 @@ var PostgresStore = class extends storage.MastraStorage {
   }
   async clearTable({ tableName }) {
     try {
-      await this.db.none(`TRUNCATE TABLE ${tableName} CASCADE`);
+      await this.db.none(`TRUNCATE TABLE ${this.getTableName(tableName)} CASCADE`);
     } catch (error) {
       console.error(`Error clearing table ${tableName}:`, error);
       throw error;
@@ -908,7 +1020,7 @@ var PostgresStore = class extends storage.MastraStorage {
       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})`,
+        `INSERT INTO ${this.getTableName(tableName)} (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
         values
       );
     } catch (error) {
@@ -921,7 +1033,10 @@ var PostgresStore = class extends storage.MastraStorage {
       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);
+      const result = await this.db.oneOrNone(
+        `SELECT * FROM ${this.getTableName(tableName)} WHERE ${conditions}`,
+        values
+      );
       if (!result) {
         return null;
       }
@@ -948,7 +1063,7 @@ var PostgresStore = class extends storage.MastraStorage {
           metadata,
           "createdAt",
           "updatedAt"
-        FROM "${storage.TABLE_THREADS}"
+        FROM ${this.getTableName(storage.TABLE_THREADS)}
         WHERE id = $1`,
         [threadId]
       );
@@ -976,7 +1091,7 @@ var PostgresStore = class extends storage.MastraStorage {
           metadata,
           "createdAt",
           "updatedAt"
-        FROM "${storage.TABLE_THREADS}"
+        FROM ${this.getTableName(storage.TABLE_THREADS)}
         WHERE "resourceId" = $1`,
         [resourceId]
       );
@@ -994,7 +1109,7 @@ var PostgresStore = class extends storage.MastraStorage {
   async saveThread({ thread }) {
     try {
       await this.db.none(
-        `INSERT INTO "${storage.TABLE_THREADS}" (
+        `INSERT INTO ${this.getTableName(storage.TABLE_THREADS)} (
           id,
           "resourceId",
           title,
@@ -1038,7 +1153,7 @@ var PostgresStore = class extends storage.MastraStorage {
         ...metadata
       };
       const thread = await this.db.one(
-        `UPDATE "${storage.TABLE_THREADS}"
+        `UPDATE ${this.getTableName(storage.TABLE_THREADS)}
         SET title = $1,
             metadata = $2,
             "updatedAt" = $3
@@ -1060,8 +1175,8 @@ var PostgresStore = class extends storage.MastraStorage {
   async deleteThread({ threadId }) {
     try {
       await this.db.tx(async (t) => {
-        await t.none(`DELETE FROM "${storage.TABLE_MESSAGES}" WHERE thread_id = $1`, [threadId]);
-        await t.none(`DELETE FROM "${storage.TABLE_THREADS}" WHERE id = $1`, [threadId]);
+        await t.none(`DELETE FROM ${this.getTableName(storage.TABLE_MESSAGES)} WHERE thread_id = $1`, [threadId]);
+        await t.none(`DELETE FROM ${this.getTableName(storage.TABLE_THREADS)} WHERE id = $1`, [threadId]);
       });
     } catch (error) {
       console.error("Error deleting thread:", error);
@@ -1080,7 +1195,7 @@ var PostgresStore = class extends storage.MastraStorage {
             SELECT 
               *,
               ROW_NUMBER() OVER (ORDER BY "createdAt" DESC) as row_num
-            FROM "${storage.TABLE_MESSAGES}"
+            FROM ${this.getTableName(storage.TABLE_MESSAGES)}
             WHERE thread_id = $1
           )
           SELECT
@@ -1123,7 +1238,7 @@ var PostgresStore = class extends storage.MastraStorage {
             type,
             "createdAt", 
             thread_id AS "threadId"
-        FROM "${storage.TABLE_MESSAGES}"
+        FROM ${this.getTableName(storage.TABLE_MESSAGES)}
         WHERE thread_id = $1
         AND id != ALL($2)
         ORDER BY "createdAt" DESC
@@ -1161,7 +1276,7 @@ var PostgresStore = class extends storage.MastraStorage {
       await this.db.tx(async (t) => {
         for (const message of messages) {
           await t.none(
-            `INSERT INTO "${storage.TABLE_MESSAGES}" (id, thread_id, content, "createdAt", role, type) 
+            `INSERT INTO ${this.getTableName(storage.TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type) 
              VALUES ($1, $2, $3, $4, $5, $6)`,
             [
               message.id,
@@ -1188,7 +1303,7 @@ var PostgresStore = class extends storage.MastraStorage {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       await this.db.none(
-        `INSERT INTO "${storage.TABLE_WORKFLOW_SNAPSHOT}" (
+        `INSERT INTO ${this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT)} (
           workflow_name,
           run_id,
           snapshot,
@@ -1255,13 +1370,13 @@ var PostgresStore = class extends storage.MastraStorage {
     let total = 0;
     if (limit !== void 0 && offset !== void 0) {
       const countResult = await this.db.one(
-        `SELECT COUNT(*) as count FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause}`,
+        `SELECT COUNT(*) as count FROM ${this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT)} ${whereClause}`,
         values
       );
       total = Number(countResult.count);
     }
     const query = `
-      SELECT * FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} 
+      SELECT * FROM ${this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT)} 
       ${whereClause} 
       ORDER BY "createdAt" DESC
       ${limit !== void 0 && offset !== void 0 ? ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}` : ""}