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

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.3 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 10734ms
 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 11829ms
 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
+CJS dist/index.cjs 36.78 KB
+CJS ⚡️ Build success in 1386ms
+ESM dist/index.js 36.37 KB
+ESM ⚡️ Build success in 1387ms

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @mastra/pg
 
+## 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/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,6 +450,9 @@ 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 });
       }
@@ -453,15 +477,39 @@ var PgVector = class extends vector.MastraVector {
     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 
+      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") {
+          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 IF NOT EXISTS ${indexName}_vector_idx 
           ON ${indexName} 
           USING hnsw (embedding ${metricOp})
           WITH (
@@ -469,23 +517,26 @@ var PgVector = class extends vector.MastraVector {
             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
+          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 IF NOT EXISTS ${indexName}_vector_idx
           ON ${indexName}
           USING ivfflat (embedding ${metricOp})
           WITH (lists = ${lists});
         `;
+        }
+        await client.query(indexSQL);
+        this.indexCache.delete(indexName);
+      } finally {
+        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
       }
-      await client.query(indexSQL);
-      this.indexCache.delete(indexName);
     } finally {
       client.release();
     }

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,6 +443,9 @@ 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 });
       }
@@ -446,15 +470,39 @@ var PgVector = class extends MastraVector {
     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 
+      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") {
+          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 IF NOT EXISTS ${indexName}_vector_idx 
           ON ${indexName} 
           USING hnsw (embedding ${metricOp})
           WITH (
@@ -462,23 +510,26 @@ var PgVector = class extends MastraVector {
             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
+          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 IF NOT EXISTS ${indexName}_vector_idx
           ON ${indexName}
           USING ivfflat (embedding ${metricOp})
           WITH (lists = ${lists});
         `;
+        }
+        await client.query(indexSQL);
+        this.indexCache.delete(indexName);
+      } finally {
+        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
       }
-      await client.query(indexSQL);
-      this.indexCache.delete(indexName);
     } finally {
       client.release();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.2.6-alpha.2",
+  "version": "0.2.6-alpha.3",
   "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]);
+      }
 
-      // Create the table with explicit schema
-      await client.query(`
+      try {
+        // Try to create extension
+        await client.query('CREATE EXTENSION IF NOT EXISTS vector');
+
+        // 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,6 +256,10 @@ 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 });
@@ -260,20 +293,53 @@ export class PgVector extends MastraVector {
 
     const client = await this.pool.connect();
     try {
-      await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
+      // 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]);
+      }
 
-      if (indexConfig.type === 'flat') return;
+      try {
+        await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
+
+        if (indexConfig.type === 'flat') {
+          this.indexCache.delete(indexName);
+          return;
+        }
 
-      const metricOp =
-        metric === 'cosine' ? 'vector_cosine_ops' : metric === 'euclidean' ? 'vector_l2_ops' : 'vector_ip_ops';
+        const metricOp =
+          metric === 'cosine' ? 'vector_cosine_ops' : metric === 'euclidean' ? 'vector_l2_ops' : 'vector_ip_ops';
 
-      let indexSQL: string;
-      if (indexConfig.type === 'hnsw') {
-        const m = indexConfig.hnsw?.m ?? 8;
-        const efConstruction = indexConfig.hnsw?.efConstruction ?? 32;
+        let indexSQL: string;
+        if (indexConfig.type === 'hnsw') {
+          const m = indexConfig.hnsw?.m ?? 8;
+          const efConstruction = indexConfig.hnsw?.efConstruction ?? 32;
 
-        indexSQL = `
-          CREATE INDEX ${indexName}_vector_idx 
+          indexSQL = `
+          CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx 
           ON ${indexName} 
           USING hnsw (embedding ${metricOp})
           WITH (
@@ -281,24 +347,27 @@ export class PgVector extends MastraVector {
             ef_construction = ${efConstruction}
           )
         `;
-      } else {
-        let lists: number;
-        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(4000, Math.floor(Math.sqrt(size) * 2)));
-        }
-        indexSQL = `
-          CREATE INDEX ${indexName}_vector_idx
+          let lists: number;
+          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(4000, Math.floor(Math.sqrt(size) * 2)));
+          }
+          indexSQL = `
+          CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx
           ON ${indexName}
           USING ivfflat (embedding ${metricOp})
           WITH (lists = ${lists});
         `;
-      }
+        }
 
-      await client.query(indexSQL);
-      this.indexCache.delete(indexName);
+        await client.query(indexSQL);
+        this.indexCache.delete(indexName);
+      } finally {
+        await client.query('SELECT pg_advisory_unlock($1)', [lockId]);
+      }
     } finally {
       client.release();
     }