@mastra/pg 0.2.11-alpha.1 → 0.3.0-alpha.3

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.2.11-alpha.1 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.3.0-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 10662ms
+TSC ⚡️ Build success in 10982ms
 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 11555ms
+DTS ⚡️ Build success in 12779ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
 ESM dist/index.js 45.68 KB
-ESM ⚡️ Build success in 1451ms
+ESM ⚡️ Build success in 1276ms
 CJS dist/index.cjs 46.10 KB
-CJS ⚡️ Build success in 1451ms
+CJS ⚡️ Build success in 1276ms

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @mastra/pg
 
+## 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
+
+- Updated dependencies [9ee4293]
+  - @mastra/core@0.8.4-alpha.2
+
 ## 0.2.11-alpha.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.2.11-alpha.1",
+  "version": "0.3.0-alpha.3",
   "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.1"
+    "@mastra/core": "^0.9.0-alpha.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",

package/src/storage/index.test.ts

@@ -109,16 +109,16 @@ describe('PostgresStore', () => {
       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 +126,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 +152,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 +178,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 +207,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 +220,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 +248,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 +260,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 +282,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 +433,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 +449,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 +471,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 +522,7 @@ describe('PostgresStore', () => {
         },
       });
 
-      const { runs } = await store.__getWorkflowRuns({
+      const { runs } = await store.getWorkflowRuns({
         fromDate: yesterday,
         toDate: now,
       });
@@ -552,7 +552,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 +563,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);
@@ -691,10 +691,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 +703,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();
@@ -887,7 +887,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.`,
           );