@mastra/pg 0.2.11-alpha.2 → 0.3.0-alpha.4

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.2.11-alpha.2 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.3.0-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 11183ms
+TSC ⚡️ Build success in 10612ms
 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 12473ms
+DTS ⚡️ Build success in 11768ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 46.10 KB
-CJS ⚡️ Build success in 1276ms
-ESM dist/index.js 45.68 KB
-ESM ⚡️ Build success in 1276ms
+ESM dist/index.js 46.99 KB
+ESM ⚡️ Build success in 1698ms
+CJS dist/index.cjs 47.42 KB
+CJS ⚡️ Build success in 1697ms

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @mastra/pg
 
+## 0.3.0-alpha.4
+
+### Patch Changes
+
+- 373458f: updated schema for storage config to align with pgvector and added validation for pg connections
+- Updated dependencies [7e92011]
+  - @mastra/core@0.9.0-alpha.4
+
+## 0.3.0-alpha.3
+
+### Minor Changes
+
+- fe3ae4d: Remove \_\_ functions in storage and move to storage proxy to make sure init is called
+
+### Patch Changes
+
+- Updated dependencies [fe3ae4d]
+  - @mastra/core@0.9.0-alpha.3
+
 ## 0.2.11-alpha.2
 
 ### Patch Changes

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

@@ -246,6 +246,10 @@ export { PgVector }
 export { PgVector as PgVector_alias_1 }
 
 declare type PostgresConfig = {
+    schemaName?: string;
+    /**
+     * @deprecated Use `schemaName` instead. Support for `schema` will be removed in a future release.
+     */
     schema?: string;
 } & ({
     host: string;

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

@@ -246,6 +246,10 @@ export { PgVector }
 export { PgVector as PgVector_alias_1 }
 
 declare type PostgresConfig = {
+    schemaName?: string;
+    /**
+     * @deprecated Use `schemaName` instead. Support for `schema` will be removed in a future release.
+     */
     schema?: string;
 } & ({
     host: string;

package/dist/index.cjs

@@ -305,8 +305,13 @@ var PgVector = class extends vector.MastraVector {
   vectorExtensionInstalled = void 0;
   schemaSetupComplete = void 0;
   constructor(config) {
-    super();
     const connectionString = typeof config === "string" ? config : config.connectionString;
+    if (!connectionString || typeof connectionString !== "string" || connectionString.trim() === "") {
+      throw new Error(
+        "PgVector: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults."
+      );
+    }
+    super();
     this.schema = typeof config === "string" ? void 0 : config.schemaName;
     const basePool = new pg__default.default.Pool({
       connectionString,
@@ -793,9 +798,30 @@ var PostgresStore = class extends storage.MastraStorage {
   setupSchemaPromise = null;
   schemaSetupComplete = void 0;
   constructor(config) {
+    if ("connectionString" in config) {
+      if (!config.connectionString || typeof config.connectionString !== "string" || config.connectionString.trim() === "") {
+        throw new Error(
+          "PostgresStore: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults."
+        );
+      }
+    } else {
+      const required = ["host", "database", "user", "password"];
+      for (const key of required) {
+        if (!(key in config) || typeof config[key] !== "string" || config[key].trim() === "") {
+          throw new Error(
+            `PostgresStore: ${key} must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults.`
+          );
+        }
+      }
+    }
     super({ name: "PostgresStore" });
     this.pgp = pgPromise__default.default();
-    this.schema = config.schema;
+    if ("schema" in config && config.schema) {
+      console.warn(
+        '[DEPRECATION NOTICE] The "schema" option in PostgresStore is deprecated. Please use "schemaName" instead. Support for "schema" will be removed in a future release.'
+      );
+    }
+    this.schema = config.schemaName ?? config.schema;
     this.db = this.pgp(
       `connectionString` in config ? { connectionString: config.connectionString } : {
         host: config.host,

package/dist/index.js

@@ -297,8 +297,13 @@ var PgVector = class extends MastraVector {
   vectorExtensionInstalled = void 0;
   schemaSetupComplete = void 0;
   constructor(config) {
-    super();
     const connectionString = typeof config === "string" ? config : config.connectionString;
+    if (!connectionString || typeof connectionString !== "string" || connectionString.trim() === "") {
+      throw new Error(
+        "PgVector: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults."
+      );
+    }
+    super();
     this.schema = typeof config === "string" ? void 0 : config.schemaName;
     const basePool = new pg.Pool({
       connectionString,
@@ -785,9 +790,30 @@ var PostgresStore = class extends MastraStorage {
   setupSchemaPromise = null;
   schemaSetupComplete = void 0;
   constructor(config) {
+    if ("connectionString" in config) {
+      if (!config.connectionString || typeof config.connectionString !== "string" || config.connectionString.trim() === "") {
+        throw new Error(
+          "PostgresStore: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults."
+        );
+      }
+    } else {
+      const required = ["host", "database", "user", "password"];
+      for (const key of required) {
+        if (!(key in config) || typeof config[key] !== "string" || config[key].trim() === "") {
+          throw new Error(
+            `PostgresStore: ${key} must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults.`
+          );
+        }
+      }
+    }
     super({ name: "PostgresStore" });
     this.pgp = pgPromise();
-    this.schema = config.schema;
+    if ("schema" in config && config.schema) {
+      console.warn(
+        '[DEPRECATION NOTICE] The "schema" option in PostgresStore is deprecated. Please use "schemaName" instead. Support for "schema" will be removed in a future release.'
+      );
+    }
+    this.schema = config.schemaName ?? config.schema;
     this.db = this.pgp(
       `connectionString` in config ? { connectionString: config.connectionString } : {
         host: config.host,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.2.11-alpha.2",
+  "version": "0.3.0-alpha.4",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
     "pg": "^8.13.3",
     "pg-promise": "^11.11.0",
     "xxhash-wasm": "^1.1.0",
-    "@mastra/core": "^0.8.4-alpha.2"
+    "@mastra/core": "^0.9.0-alpha.4"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",

package/src/storage/index.test.ts

@@ -104,21 +104,65 @@ describe('PostgresStore', () => {
     }
   });
 
+  // --- Validation tests ---
+  describe('Validation', () => {
+    const validConfig = TEST_CONFIG;
+    it('throws if connectionString is empty', () => {
+      expect(() => new PostgresStore({ connectionString: '' })).toThrow(
+        /connectionString must be provided and cannot be empty/,
+      );
+    });
+    it('throws if host is missing or empty', () => {
+      expect(() => new PostgresStore({ ...validConfig, host: '' })).toThrow(
+        /host must be provided and cannot be empty/,
+      );
+      const { host, ...rest } = validConfig;
+      expect(() => new PostgresStore(rest as any)).toThrow(/host must be provided and cannot be empty/);
+    });
+    it('throws if user is missing or empty', () => {
+      expect(() => new PostgresStore({ ...validConfig, user: '' })).toThrow(
+        /user must be provided and cannot be empty/,
+      );
+      const { user, ...rest } = validConfig;
+      expect(() => new PostgresStore(rest as any)).toThrow(/user must be provided and cannot be empty/);
+    });
+    it('throws if database is missing or empty', () => {
+      expect(() => new PostgresStore({ ...validConfig, database: '' })).toThrow(
+        /database must be provided and cannot be empty/,
+      );
+      const { database, ...rest } = validConfig;
+      expect(() => new PostgresStore(rest as any)).toThrow(/database must be provided and cannot be empty/);
+    });
+    it('throws if password is missing or empty', () => {
+      expect(() => new PostgresStore({ ...validConfig, password: '' })).toThrow(
+        /password must be provided and cannot be empty/,
+      );
+      const { password, ...rest } = validConfig;
+      expect(() => new PostgresStore(rest as any)).toThrow(/password must be provided and cannot be empty/);
+    });
+    it('does not throw on valid config (host-based)', () => {
+      expect(() => new PostgresStore(validConfig)).not.toThrow();
+    });
+    it('does not throw on non-empty connection string', () => {
+      expect(() => new PostgresStore({ connectionString })).not.toThrow();
+    });
+  });
+
   describe('Thread Operations', () => {
     it('should create and retrieve a thread', async () => {
       const thread = createSampleThread();
 
       // Save thread
-      const savedThread = await store.__saveThread({ thread });
+      const savedThread = await store.saveThread({ thread });
       expect(savedThread).toEqual(thread);
 
       // Retrieve thread
-      const retrievedThread = await store.__getThreadById({ threadId: thread.id });
+      const retrievedThread = await store.getThreadById({ threadId: thread.id });
       expect(retrievedThread?.title).toEqual(thread.title);
     });
 
     it('should return null for non-existent thread', async () => {
-      const result = await store.__getThreadById({ threadId: 'non-existent' });
+      const result = await store.getThreadById({ threadId: 'non-existent' });
       expect(result).toBeNull();
     });
 
@@ -126,20 +170,20 @@ describe('PostgresStore', () => {
       const thread1 = createSampleThread();
       const thread2 = { ...createSampleThread(), resourceId: thread1.resourceId };
 
-      await store.__saveThread({ thread: thread1 });
-      await store.__saveThread({ thread: thread2 });
+      await store.saveThread({ thread: thread1 });
+      await store.saveThread({ thread: thread2 });
 
-      const threads = await store.__getThreadsByResourceId({ resourceId: thread1.resourceId });
+      const threads = await store.getThreadsByResourceId({ resourceId: thread1.resourceId });
       expect(threads).toHaveLength(2);
       expect(threads.map(t => t.id)).toEqual(expect.arrayContaining([thread1.id, thread2.id]));
     });
 
     it('should update thread title and metadata', async () => {
       const thread = createSampleThread();
-      await store.__saveThread({ thread });
+      await store.saveThread({ thread });
 
       const newMetadata = { newKey: 'newValue' };
-      const updatedThread = await store.__updateThread({
+      const updatedThread = await store.updateThread({
         id: thread.id,
         title: 'Updated Title',
         metadata: newMetadata,
@@ -152,25 +196,25 @@ describe('PostgresStore', () => {
       });
 
       // Verify persistence
-      const retrievedThread = await store.__getThreadById({ threadId: thread.id });
+      const retrievedThread = await store.getThreadById({ threadId: thread.id });
       expect(retrievedThread).toEqual(updatedThread);
     });
 
     it('should delete thread and its messages', async () => {
       const thread = createSampleThread();
-      await store.__saveThread({ thread });
+      await store.saveThread({ thread });
 
       // Add some messages
       const messages = [createSampleMessage(thread.id), createSampleMessage(thread.id)];
-      await store.__saveMessages({ messages });
+      await store.saveMessages({ messages });
 
-      await store.__deleteThread({ threadId: thread.id });
+      await store.deleteThread({ threadId: thread.id });
 
-      const retrievedThread = await store.__getThreadById({ threadId: thread.id });
+      const retrievedThread = await store.getThreadById({ threadId: thread.id });
       expect(retrievedThread).toBeNull();
 
       // Verify messages were also deleted
-      const retrievedMessages = await store.__getMessages({ threadId: thread.id });
+      const retrievedMessages = await store.getMessages({ threadId: thread.id });
       expect(retrievedMessages).toHaveLength(0);
     });
   });
@@ -178,28 +222,28 @@ describe('PostgresStore', () => {
   describe('Message Operations', () => {
     it('should save and retrieve messages', async () => {
       const thread = createSampleThread();
-      await store.__saveThread({ thread });
+      await store.saveThread({ thread });
 
       const messages = [createSampleMessage(thread.id), createSampleMessage(thread.id)];
 
       // Save messages
-      const savedMessages = await store.__saveMessages({ messages });
+      const savedMessages = await store.saveMessages({ messages });
       expect(savedMessages).toEqual(messages);
 
       // Retrieve messages
-      const retrievedMessages = await store.__getMessages({ threadId: thread.id });
+      const retrievedMessages = await store.getMessages({ threadId: thread.id });
       expect(retrievedMessages).toHaveLength(2);
       expect(retrievedMessages).toEqual(expect.arrayContaining(messages));
     });
 
     it('should handle empty message array', async () => {
-      const result = await store.__saveMessages({ messages: [] });
+      const result = await store.saveMessages({ messages: [] });
       expect(result).toEqual([]);
     });
 
     it('should maintain message order', async () => {
       const thread = createSampleThread();
-      await store.__saveThread({ thread });
+      await store.saveThread({ thread });
 
       const messages = [
         { ...createSampleMessage(thread.id), content: [{ type: 'text', text: 'First' }] as MessageType['content'] },
@@ -207,9 +251,9 @@ describe('PostgresStore', () => {
         { ...createSampleMessage(thread.id), content: [{ type: 'text', text: 'Third' }] as MessageType['content'] },
       ];
 
-      await store.__saveMessages({ messages });
+      await store.saveMessages({ messages });
 
-      const retrievedMessages = await store.__getMessages({ threadId: thread.id });
+      const retrievedMessages = await store.getMessages({ threadId: thread.id });
       expect(retrievedMessages).toHaveLength(3);
 
       // Verify order is maintained
@@ -220,17 +264,17 @@ describe('PostgresStore', () => {
 
     it('should rollback on error during message save', async () => {
       const thread = createSampleThread();
-      await store.__saveThread({ thread });
+      await store.saveThread({ thread });
 
       const messages = [
         createSampleMessage(thread.id),
         { ...createSampleMessage(thread.id), id: null } as any, // This will cause an error
       ];
 
-      await expect(store.__saveMessages({ messages })).rejects.toThrow();
+      await expect(store.saveMessages({ messages })).rejects.toThrow();
 
       // Verify no messages were saved
-      const savedMessages = await store.__getMessages({ threadId: thread.id });
+      const savedMessages = await store.getMessages({ threadId: thread.id });
       expect(savedMessages).toHaveLength(0);
     });
   });
@@ -248,8 +292,8 @@ describe('PostgresStore', () => {
         metadata: largeMetadata,
       };
 
-      await store.__saveThread({ thread: threadWithLargeMetadata });
-      const retrieved = await store.__getThreadById({ threadId: thread.id });
+      await store.saveThread({ thread: threadWithLargeMetadata });
+      const retrieved = await store.getThreadById({ threadId: thread.id });
 
       expect(retrieved?.metadata).toEqual(largeMetadata);
     });
@@ -260,19 +304,19 @@ describe('PostgresStore', () => {
         title: 'Special \'quotes\' and "double quotes" and emoji 🎉',
       };
 
-      await store.__saveThread({ thread });
-      const retrieved = await store.__getThreadById({ threadId: thread.id });
+      await store.saveThread({ thread });
+      const retrieved = await store.getThreadById({ threadId: thread.id });
 
       expect(retrieved?.title).toBe(thread.title);
     });
 
     it('should handle concurrent thread updates', async () => {
       const thread = createSampleThread();
-      await store.__saveThread({ thread });
+      await store.saveThread({ thread });
 
       // Perform multiple updates concurrently
       const updates = Array.from({ length: 5 }, (_, i) =>
-        store.__updateThread({
+        store.updateThread({
           id: thread.id,
           title: `Update ${i}`,
           metadata: { update: i },
@@ -282,7 +326,7 @@ describe('PostgresStore', () => {
       await expect(Promise.all(updates)).resolves.toBeDefined();
 
       // Verify final state
-      const finalThread = await store.__getThreadById({ threadId: thread.id });
+      const finalThread = await store.getThreadById({ threadId: thread.id });
       expect(finalThread).toBeDefined();
     });
   });
@@ -433,7 +477,7 @@ describe('PostgresStore', () => {
       await store.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
     });
     it('returns empty array when no workflows exist', async () => {
-      const { runs, total } = await store.__getWorkflowRuns();
+      const { runs, total } = await store.getWorkflowRuns();
       expect(runs).toEqual([]);
       expect(total).toBe(0);
     });
@@ -449,7 +493,7 @@ describe('PostgresStore', () => {
       await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
       await store.persistWorkflowSnapshot({ workflowName: workflowName2, runId: runId2, snapshot: workflow2 });
 
-      const { runs, total } = await store.__getWorkflowRuns();
+      const { runs, total } = await store.getWorkflowRuns();
       expect(runs).toHaveLength(2);
       expect(total).toBe(2);
       expect(runs[0]!.workflowName).toBe(workflowName2); // Most recent first
@@ -471,7 +515,7 @@ describe('PostgresStore', () => {
       await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
       await store.persistWorkflowSnapshot({ workflowName: workflowName2, runId: runId2, snapshot: workflow2 });
 
-      const { runs, total } = await store.__getWorkflowRuns({ workflowName: workflowName1 });
+      const { runs, total } = await store.getWorkflowRuns({ workflowName: workflowName1 });
       expect(runs).toHaveLength(1);
       expect(total).toBe(1);
       expect(runs[0]!.workflowName).toBe(workflowName1);
@@ -522,7 +566,7 @@ describe('PostgresStore', () => {
         },
       });
 
-      const { runs } = await store.__getWorkflowRuns({
+      const { runs } = await store.getWorkflowRuns({
         fromDate: yesterday,
         toDate: now,
       });
@@ -552,7 +596,7 @@ describe('PostgresStore', () => {
       await store.persistWorkflowSnapshot({ workflowName: workflowName3, runId: runId3, snapshot: workflow3 });
 
       // Get first page
-      const page1 = await store.__getWorkflowRuns({ limit: 2, offset: 0 });
+      const page1 = await store.getWorkflowRuns({ limit: 2, offset: 0 });
       expect(page1.runs).toHaveLength(2);
       expect(page1.total).toBe(3); // Total count of all records
       expect(page1.runs[0]!.workflowName).toBe(workflowName3);
@@ -563,7 +607,7 @@ describe('PostgresStore', () => {
       expect(secondSnapshot.context?.steps[stepId2]?.status).toBe('running');
 
       // Get second page
-      const page2 = await store.__getWorkflowRuns({ limit: 2, offset: 2 });
+      const page2 = await store.getWorkflowRuns({ limit: 2, offset: 2 });
       expect(page2.runs).toHaveLength(1);
       expect(page2.total).toBe(3);
       expect(page2.runs[0]!.workflowName).toBe(workflowName1);
@@ -662,7 +706,7 @@ describe('PostgresStore', () => {
     beforeAll(async () => {
       customSchemaStore = new PostgresStore({
         ...TEST_CONFIG,
-        schema: customSchema,
+        schemaName: customSchema,
       });
 
       await customSchemaStore.init();
@@ -691,10 +735,10 @@ describe('PostgresStore', () => {
       it('should create and query tables in custom schema', async () => {
         // Create thread in custom schema
         const thread = createSampleThread();
-        await customSchemaStore.__saveThread({ thread });
+        await customSchemaStore.saveThread({ thread });
 
         // Verify thread exists in custom schema
-        const retrieved = await customSchemaStore.__getThreadById({ threadId: thread.id });
+        const retrieved = await customSchemaStore.getThreadById({ threadId: thread.id });
         expect(retrieved?.title).toBe(thread.title);
       });
 
@@ -703,19 +747,19 @@ describe('PostgresStore', () => {
         const defaultThread = createSampleThread();
         const customThread = createSampleThread();
 
-        await store.__saveThread({ thread: defaultThread });
-        await customSchemaStore.__saveThread({ thread: customThread });
+        await store.saveThread({ thread: defaultThread });
+        await customSchemaStore.saveThread({ thread: customThread });
 
         // Verify threads exist in respective schemas
-        const defaultResult = await store.__getThreadById({ threadId: defaultThread.id });
-        const customResult = await customSchemaStore.__getThreadById({ threadId: customThread.id });
+        const defaultResult = await store.getThreadById({ threadId: defaultThread.id });
+        const customResult = await customSchemaStore.getThreadById({ threadId: customThread.id });
 
         expect(defaultResult?.id).toBe(defaultThread.id);
         expect(customResult?.id).toBe(customThread.id);
 
         // Verify cross-schema isolation
-        const defaultInCustom = await customSchemaStore.__getThreadById({ threadId: defaultThread.id });
-        const customInDefault = await store.__getThreadById({ threadId: customThread.id });
+        const defaultInCustom = await customSchemaStore.getThreadById({ threadId: defaultThread.id });
+        const customInDefault = await store.getThreadById({ threadId: customThread.id });
 
         expect(defaultInCustom).toBeNull();
         expect(customInDefault).toBeNull();
@@ -844,7 +888,7 @@ describe('PostgresStore', () => {
           ...TEST_CONFIG,
           user: schemaRestrictedUser,
           password: restrictedPassword,
-          schema: testSchema,
+          schemaName: testSchema,
         });
 
         // Create a fresh connection for verification
@@ -876,7 +920,7 @@ describe('PostgresStore', () => {
           ...TEST_CONFIG,
           user: schemaRestrictedUser,
           password: restrictedPassword,
-          schema: testSchema,
+          schemaName: testSchema,
         });
 
         // Create a fresh connection for verification
@@ -887,7 +931,7 @@ describe('PostgresStore', () => {
           await expect(async () => {
             await restrictedDB.init();
             const thread = createSampleThread();
-            await restrictedDB.__saveThread({ thread });
+            await restrictedDB.saveThread({ thread });
           }).rejects.toThrow(
             `Unable to create schema "${testSchema}". This requires CREATE privilege on the database.`,
           );

package/src/storage/index.ts

@@ -13,7 +13,13 @@ import type { WorkflowRunState } from '@mastra/core/workflows';
 import pgPromise from 'pg-promise';
 import type { ISSLConfig } from 'pg-promise/typescript/pg-subset';
 
-export type PostgresConfig = { schema?: string } & (
+export type PostgresConfig = {
+  schemaName?: string;
+  /**
+   * @deprecated Use `schemaName` instead. Support for `schema` will be removed in a future release.
+   */
+  schema?: string;
+} & (
   | {
       host: string;
       port: number;
@@ -35,9 +41,36 @@ export class PostgresStore extends MastraStorage {
   private schemaSetupComplete: boolean | undefined = undefined;
 
   constructor(config: PostgresConfig) {
+    // Validation: connectionString or host/database/user/password must not be empty
+    if ('connectionString' in config) {
+      if (
+        !config.connectionString ||
+        typeof config.connectionString !== 'string' ||
+        config.connectionString.trim() === ''
+      ) {
+        throw new Error(
+          'PostgresStore: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults.',
+        );
+      }
+    } else {
+      const required = ['host', 'database', 'user', 'password'];
+      for (const key of required) {
+        if (!(key in config) || typeof (config as any)[key] !== 'string' || (config as any)[key].trim() === '') {
+          throw new Error(
+            `PostgresStore: ${key} must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults.`,
+          );
+        }
+      }
+    }
     super({ name: 'PostgresStore' });
     this.pgp = pgPromise();
-    this.schema = config.schema;
+    // Deprecation notice for schema (old option)
+    if ('schema' in config && config.schema) {
+      console.warn(
+        '[DEPRECATION NOTICE] The "schema" option in PostgresStore is deprecated. Please use "schemaName" instead. Support for "schema" will be removed in a future release.',
+      );
+    }
+    this.schema = config.schemaName ?? config.schema;
     this.db = this.pgp(
       `connectionString` in config
         ? { connectionString: config.connectionString }

package/src/vector/index.test.ts

@@ -21,6 +21,24 @@ describe('PgVector', () => {
     await vectorDB.disconnect();
   });
 
+  // --- Validation tests ---
+  describe('Validation', () => {
+    it('throws if connectionString is empty (string)', () => {
+      expect(() => new PgVector('')).toThrow(/connectionString must be provided and cannot be empty/);
+    });
+    it('throws if connectionString is empty (object)', () => {
+      expect(() => new PgVector({ connectionString: '' })).toThrow(
+        /connectionString must be provided and cannot be empty/,
+      );
+    });
+    it('does not throw on non-empty connection string (string)', () => {
+      expect(() => new PgVector(connectionString)).not.toThrow();
+    });
+    it('does not throw on non-empty connection string (object)', () => {
+      expect(() => new PgVector({ connectionString })).not.toThrow();
+    });
+  });
+
   // Index Management Tests
   describe('Index Management', () => {
     describe('createIndex', () => {
@@ -329,8 +347,8 @@ describe('PgVector', () => {
         expect(results[0]?.vector).toEqual(newVector);
       });
 
-      it('should throw exception when no updates are given', () => {
-        expect(vectorDB.updateIndexById(testIndexName, 'id', {})).rejects.toThrow('No updates provided');
+      it('should throw exception when no updates are given', async () => {
+        await expect(vectorDB.updateIndexById(testIndexName, 'id', {})).rejects.toThrow('No updates provided');
       });
     });
 

package/src/vector/index.ts

@@ -73,9 +73,14 @@ export class PgVector extends MastraVector {
   constructor(connectionString: string);
   constructor(config: { connectionString: string; schemaName?: string });
   constructor(config: string | { connectionString: string; schemaName?: string }) {
+    const connectionString = typeof config === 'string' ? config : config.connectionString;
+    if (!connectionString || typeof connectionString !== 'string' || connectionString.trim() === '') {
+      throw new Error(
+        'PgVector: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults.',
+      );
+    }
     super();
 
-    const connectionString = typeof config === 'string' ? config : config.connectionString;
     this.schema = typeof config === 'string' ? undefined : config.schemaName;
 
     const basePool = new pg.Pool({