@mastra/pg 0.2.6-alpha.2 → 0.2.6-alpha.4

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.2.6-alpha.2 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.2.6-alpha.4 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 10254ms
+TSC ⚡️ Build success in 10085ms
 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 12251ms
+DTS ⚡️ Build success in 10753ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 34.40 KB
-ESM ⚡️ Build success in 1257ms
-CJS dist/index.cjs 34.80 KB
-CJS ⚡️ Build success in 1259ms
+ESM dist/index.js 36.43 KB
+ESM ⚡️ Build success in 1230ms
+CJS dist/index.cjs 36.85 KB
+CJS ⚡️ Build success in 1230ms

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @mastra/pg
 
+## 0.2.6-alpha.4
+
+### Patch Changes
+
+- e91bee7: Added helper method for both createindex and buildIndex
+
+## 0.2.6-alpha.3
+
+### Patch Changes
+
+- 7172059: Update PG Vector to use handle concurrent createIndex
+- Updated dependencies [b3b34f5]
+- Updated dependencies [a4686e8]
+  - @mastra/core@0.7.0-alpha.3
+
 ## 0.2.6-alpha.2
 
 ### Patch Changes

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

@@ -211,6 +211,7 @@ declare class PgVector extends MastraVector {
      */
     defineIndex(indexName: string, metric: "cosine" | "euclidean" | "dotproduct" | undefined, indexConfig: IndexConfig): Promise<void>;
     buildIndex(...args: ParamsToArgs<PgDefineIndexParams> | PgDefineIndexArgs): Promise<void>;
+    private setupIndex;
     listIndexes(): Promise<string[]>;
     describeIndex(indexName: string): Promise<PGIndexStats>;
     deleteIndex(indexName: string): Promise<void>;

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

@@ -211,6 +211,7 @@ declare class PgVector extends MastraVector {
      */
     defineIndex(indexName: string, metric: "cosine" | "euclidean" | "dotproduct" | undefined, indexConfig: IndexConfig): Promise<void>;
     buildIndex(...args: ParamsToArgs<PgDefineIndexParams> | PgDefineIndexArgs): Promise<void>;
+    private setupIndex;
     listIndexes(): Promise<string[]>;
     describeIndex(indexName: string): Promise<PGIndexStats>;
     deleteIndex(indexName: string): Promise<void>;

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var crypto$1 = require('crypto');
 var vector = require('@mastra/core/vector');
 var pg = require('pg');
 var filter = require('@mastra/core/vector/filter');
@@ -420,8 +421,28 @@ var PgVector = class extends vector.MastraVector {
       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(`
+      const hash = crypto$1.createHash("sha256").update(indexName).digest("hex");
+      const lockId = BigInt("0x" + hash.slice(0, 8)) % BigInt(2 ** 31);
+      const acquired = await client.query("SELECT pg_try_advisory_lock($1)", [lockId]);
+      if (!acquired.rows[0].pg_try_advisory_lock) {
+        const exists = await client.query(
+          `
+          SELECT 1 FROM pg_class c 
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE c.relname = $1 
+          AND n.nspname = 'public'
+        `,
+          [indexName]
+        );
+        if (exists.rows.length > 0) {
+          console.log(`Table ${indexName} already exists, skipping creation`);
+          return;
+        }
+        await client.query("SELECT pg_advisory_lock($1)", [lockId]);
+      }
+      try {
+        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,
@@ -429,8 +450,11 @@ var PgVector = class extends vector.MastraVector {
           metadata JSONB DEFAULT '{}'::jsonb
         );
       `);
+      } finally {
+        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
+      }
       if (buildIndex) {
-        await this.buildIndex({ indexName, metric, indexConfig });
+        await this.setupIndex({ indexName, metric, indexConfig }, client);
       }
     } catch (error) {
       console.error("Failed to create vector table:", error);
@@ -452,16 +476,46 @@ var PgVector = class extends vector.MastraVector {
     ]);
     const { indexName, metric = "cosine", indexConfig } = params;
     const client = await this.pool.connect();
+    try {
+      await this.setupIndex({ indexName, metric, indexConfig }, client);
+    } finally {
+      client.release();
+    }
+  }
+  async setupIndex({ indexName, metric, indexConfig }, client) {
+    const hash = crypto$1.createHash("sha256").update("build:" + indexName).digest("hex");
+    const lockId = BigInt("0x" + hash.slice(0, 8)) % BigInt(2 ** 31);
+    const acquired = await client.query("SELECT pg_try_advisory_lock($1)", [lockId]);
+    if (!acquired.rows[0].pg_try_advisory_lock) {
+      const exists = await client.query(
+        `
+            SELECT 1 FROM pg_class c 
+            JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relname = $1 
+            AND n.nspname = 'public'
+          `,
+        [`${indexName}_vector_idx`]
+      );
+      if (exists.rows.length > 0) {
+        console.log(`Index ${indexName}_vector_idx already exists, skipping creation`);
+        this.indexCache.delete(indexName);
+        return;
+      }
+      await client.query("SELECT pg_advisory_lock($1)", [lockId]);
+    }
     try {
       await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
-      if (indexConfig.type === "flat") return;
+      if (indexConfig.type === "flat") {
+        this.indexCache.delete(indexName);
+        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 
+          CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx 
           ON ${indexName} 
           USING hnsw (embedding ${metricOp})
           WITH (
@@ -478,7 +532,7 @@ var PgVector = class extends vector.MastraVector {
           lists = Math.max(100, Math.min(4e3, Math.floor(Math.sqrt(size) * 2)));
         }
         indexSQL = `
-          CREATE INDEX ${indexName}_vector_idx
+          CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx
           ON ${indexName}
           USING ivfflat (embedding ${metricOp})
           WITH (lists = ${lists});
@@ -487,7 +541,7 @@ var PgVector = class extends vector.MastraVector {
       await client.query(indexSQL);
       this.indexCache.delete(indexName);
     } finally {
-      client.release();
+      await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
     }
   }
   async listIndexes() {

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createHash } from 'crypto';
 import { MastraVector } from '@mastra/core/vector';
 import pg from 'pg';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
@@ -413,8 +414,28 @@ var PgVector = class extends MastraVector {
       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(`
+      const hash = createHash("sha256").update(indexName).digest("hex");
+      const lockId = BigInt("0x" + hash.slice(0, 8)) % BigInt(2 ** 31);
+      const acquired = await client.query("SELECT pg_try_advisory_lock($1)", [lockId]);
+      if (!acquired.rows[0].pg_try_advisory_lock) {
+        const exists = await client.query(
+          `
+          SELECT 1 FROM pg_class c 
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE c.relname = $1 
+          AND n.nspname = 'public'
+        `,
+          [indexName]
+        );
+        if (exists.rows.length > 0) {
+          console.log(`Table ${indexName} already exists, skipping creation`);
+          return;
+        }
+        await client.query("SELECT pg_advisory_lock($1)", [lockId]);
+      }
+      try {
+        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,
@@ -422,8 +443,11 @@ var PgVector = class extends MastraVector {
           metadata JSONB DEFAULT '{}'::jsonb
         );
       `);
+      } finally {
+        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
+      }
       if (buildIndex) {
-        await this.buildIndex({ indexName, metric, indexConfig });
+        await this.setupIndex({ indexName, metric, indexConfig }, client);
       }
     } catch (error) {
       console.error("Failed to create vector table:", error);
@@ -445,16 +469,46 @@ var PgVector = class extends MastraVector {
     ]);
     const { indexName, metric = "cosine", indexConfig } = params;
     const client = await this.pool.connect();
+    try {
+      await this.setupIndex({ indexName, metric, indexConfig }, client);
+    } finally {
+      client.release();
+    }
+  }
+  async setupIndex({ indexName, metric, indexConfig }, client) {
+    const hash = createHash("sha256").update("build:" + indexName).digest("hex");
+    const lockId = BigInt("0x" + hash.slice(0, 8)) % BigInt(2 ** 31);
+    const acquired = await client.query("SELECT pg_try_advisory_lock($1)", [lockId]);
+    if (!acquired.rows[0].pg_try_advisory_lock) {
+      const exists = await client.query(
+        `
+            SELECT 1 FROM pg_class c 
+            JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relname = $1 
+            AND n.nspname = 'public'
+          `,
+        [`${indexName}_vector_idx`]
+      );
+      if (exists.rows.length > 0) {
+        console.log(`Index ${indexName}_vector_idx already exists, skipping creation`);
+        this.indexCache.delete(indexName);
+        return;
+      }
+      await client.query("SELECT pg_advisory_lock($1)", [lockId]);
+    }
     try {
       await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
-      if (indexConfig.type === "flat") return;
+      if (indexConfig.type === "flat") {
+        this.indexCache.delete(indexName);
+        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 
+          CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx 
           ON ${indexName} 
           USING hnsw (embedding ${metricOp})
           WITH (
@@ -471,7 +525,7 @@ var PgVector = class extends MastraVector {
           lists = Math.max(100, Math.min(4e3, Math.floor(Math.sqrt(size) * 2)));
         }
         indexSQL = `
-          CREATE INDEX ${indexName}_vector_idx
+          CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx
           ON ${indexName}
           USING ivfflat (embedding ${metricOp})
           WITH (lists = ${lists});
@@ -480,7 +534,7 @@ var PgVector = class extends MastraVector {
       await client.query(indexSQL);
       this.indexCache.delete(indexName);
     } finally {
-      client.release();
+      await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
     }
   }
   async listIndexes() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.2.6-alpha.2",
+  "version": "0.2.6-alpha.4",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -21,7 +21,7 @@
   "dependencies": {
     "pg": "^8.13.3",
     "pg-promise": "^11.11.0",
-    "@mastra/core": "^0.7.0-alpha.2"
+    "@mastra/core": "^0.7.0-alpha.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",

package/src/vector/index.test.ts

@@ -1,7 +1,7 @@
+import type { QueryResult } from '@mastra/core';
 import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest';
 
 import { PgVector } from '.';
-import { type QueryResult } from '@mastra/core';
 
 describe('PgVector', () => {
   let vectorDB: PgVector;
@@ -1812,4 +1812,47 @@ describe('PgVector', () => {
       await expect(vectorDB.buildIndex(indexName, 'cosine', { type: 'flat' })).resolves.not.toThrow();
     });
   });
+
+  describe('Concurrent Operations', () => {
+    it('should handle concurrent index creation attempts', async () => {
+      const indexName = 'concurrent_test_index';
+      const dimension = 384;
+
+      // Create multiple promises trying to create the same index
+      const promises = Array(5)
+        .fill(null)
+        .map(() => vectorDB.createIndex({ indexName, dimension }));
+
+      // All should resolve without error - subsequent attempts should be no-ops
+      await expect(Promise.all(promises)).resolves.not.toThrow();
+
+      // Verify only one index was actually created
+      const stats = await vectorDB.describeIndex(indexName);
+      expect(stats.dimension).toBe(dimension);
+
+      await vectorDB.deleteIndex(indexName);
+    });
+
+    it('should handle concurrent buildIndex attempts', async () => {
+      const indexName = 'concurrent_build_test';
+      await vectorDB.createIndex({ indexName, dimension: 384 });
+
+      const promises = Array(5)
+        .fill(null)
+        .map(() =>
+          vectorDB.buildIndex({
+            indexName,
+            metric: 'cosine',
+            indexConfig: { type: 'ivfflat', ivf: { lists: 100 } },
+          }),
+        );
+
+      await expect(Promise.all(promises)).resolves.not.toThrow();
+
+      const stats = await vectorDB.describeIndex(indexName);
+      expect(stats.type).toBe('ivfflat');
+
+      await vectorDB.deleteIndex(indexName);
+    });
+  });
 });

package/src/vector/index.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'crypto';
 import { MastraVector } from '@mastra/core/vector';
 import type {
   IndexStats,
@@ -215,11 +216,39 @@ export class PgVector extends MastraVector {
         throw new Error('PostgreSQL vector extension is not available. Please install it first.');
       }
 
-      // Try to create extension
-      await client.query('CREATE EXTENSION IF NOT EXISTS vector');
+      // Get advisory lock using hash of index name
+      const hash = createHash('sha256').update(indexName).digest('hex');
+      const lockId = BigInt('0x' + hash.slice(0, 8)) % BigInt(2 ** 31); // Take first 8 chars and convert to number
+      const acquired = await client.query('SELECT pg_try_advisory_lock($1)', [lockId]);
+
+      if (!acquired.rows[0].pg_try_advisory_lock) {
+        // Check if table already exists
+        const exists = await client.query(
+          `
+          SELECT 1 FROM pg_class c 
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE c.relname = $1 
+          AND n.nspname = 'public'
+        `,
+          [indexName],
+        );
+
+        if (exists.rows.length > 0) {
+          // Table exists so return early
+          console.log(`Table ${indexName} already exists, skipping creation`);
+          return;
+        }
+
+        // Table doesn't exist, wait for lock
+        await client.query('SELECT pg_advisory_lock($1)', [lockId]);
+      }
+
+      try {
+        // Try to create extension
+        await client.query('CREATE EXTENSION IF NOT EXISTS vector');
 
-      // Create the table with explicit schema
-      await client.query(`
+        // Create the table with explicit schema
+        await client.query(`
         CREATE TABLE IF NOT EXISTS ${indexName} (
           id SERIAL PRIMARY KEY,
           vector_id TEXT UNIQUE NOT NULL,
@@ -227,9 +256,13 @@ export class PgVector extends MastraVector {
           metadata JSONB DEFAULT '{}'::jsonb
         );
       `);
+      } finally {
+        // Always release lock
+        await client.query('SELECT pg_advisory_unlock($1)', [lockId]);
+      }
 
       if (buildIndex) {
-        await this.buildIndex({ indexName, metric, indexConfig });
+        await this.setupIndex({ indexName, metric, indexConfig }, client);
       }
     } catch (error: any) {
       console.error('Failed to create vector table:', error);
@@ -259,10 +292,50 @@ export class PgVector extends MastraVector {
     const { indexName, metric = 'cosine', indexConfig } = params;
 
     const client = await this.pool.connect();
+    try {
+      await this.setupIndex({ indexName, metric, indexConfig }, client);
+    } finally {
+      client.release();
+    }
+  }
+
+  private async setupIndex({ indexName, metric, indexConfig }: PgDefineIndexParams, client: pg.PoolClient) {
+    // Use a different hash prefix for buildIndex locks to avoid conflicts with createIndex
+    const hash = createHash('sha256')
+      .update('build:' + indexName)
+      .digest('hex');
+    const lockId = BigInt('0x' + hash.slice(0, 8)) % BigInt(2 ** 31);
+    const acquired = await client.query('SELECT pg_try_advisory_lock($1)', [lockId]);
+
+    if (!acquired.rows[0].pg_try_advisory_lock) {
+      // Check if index already exists
+      const exists = await client.query(
+        `
+            SELECT 1 FROM pg_class c 
+            JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relname = $1 
+            AND n.nspname = 'public'
+          `,
+        [`${indexName}_vector_idx`],
+      );
+
+      if (exists.rows.length > 0) {
+        console.log(`Index ${indexName}_vector_idx already exists, skipping creation`);
+        this.indexCache.delete(indexName); // Still clear cache since we checked
+        return;
+      }
+
+      // Index doesn't exist, wait for lock
+      await client.query('SELECT pg_advisory_lock($1)', [lockId]);
+    }
+
     try {
       await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
 
-      if (indexConfig.type === 'flat') return;
+      if (indexConfig.type === 'flat') {
+        this.indexCache.delete(indexName);
+        return;
+      }
 
       const metricOp =
         metric === 'cosine' ? 'vector_cosine_ops' : metric === 'euclidean' ? 'vector_l2_ops' : 'vector_ip_ops';
@@ -273,7 +346,7 @@ export class PgVector extends MastraVector {
         const efConstruction = indexConfig.hnsw?.efConstruction ?? 32;
 
         indexSQL = `
-          CREATE INDEX ${indexName}_vector_idx 
+          CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx 
           ON ${indexName} 
           USING hnsw (embedding ${metricOp})
           WITH (
@@ -290,7 +363,7 @@ export class PgVector extends MastraVector {
           lists = Math.max(100, Math.min(4000, Math.floor(Math.sqrt(size) * 2)));
         }
         indexSQL = `
-          CREATE INDEX ${indexName}_vector_idx
+          CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx
           ON ${indexName}
           USING ivfflat (embedding ${metricOp})
           WITH (lists = ${lists});
@@ -300,7 +373,7 @@ export class PgVector extends MastraVector {
       await client.query(indexSQL);
       this.indexCache.delete(indexName);
     } finally {
-      client.release();
+      await client.query('SELECT pg_advisory_unlock($1)', [lockId]);
     }
   }