@mastra/pg 0.11.1-alpha.1 → 0.12.0-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.11.1-alpha.1",
+  "version": "0.12.0-alpha.3",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -29,16 +29,16 @@
     "@microsoft/api-extractor": "^7.52.8",
     "@types/node": "^20.19.0",
     "@types/pg": "^8.15.4",
-    "eslint": "^9.28.0",
+    "eslint": "^9.29.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
-    "@internal/storage-test-utils": "0.0.9",
     "@internal/lint": "0.0.13",
-    "@mastra/core": "0.10.7-alpha.1"
+    "@internal/storage-test-utils": "0.0.9",
+    "@mastra/core": "0.10.7-alpha.3"
   },
   "peerDependencies": {
-    "@mastra/core": ">=0.10.4-0 <0.11.0"
+    "@mastra/core": ">=0.10.7-0 <0.11.0-0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/storage/index.test.ts

@@ -591,6 +591,81 @@ describe('PostgresStore', () => {
       expect(thread2Messages).toHaveLength(1);
       expect(thread2Messages[0].id).toBe(message.id);
     });
+    it('should upsert messages: duplicate id+threadId results in update, not duplicate row', async () => {
+      const thread = await createSampleThread();
+      await store.saveThread({ thread });
+      const baseMessage = createSampleMessageV2({
+        threadId: thread.id,
+        createdAt: new Date(),
+        content: { content: 'Original' },
+        resourceId: thread.resourceId,
+      });
+
+      // Insert the message for the first time
+      await store.saveMessages({ messages: [baseMessage], format: 'v2' });
+
+      // Insert again with the same id and threadId but different content
+      const updatedMessage = {
+        ...createSampleMessageV2({
+          threadId: thread.id,
+          createdAt: new Date(),
+          content: { content: 'Updated' },
+          resourceId: thread.resourceId,
+        }),
+        id: baseMessage.id,
+      };
+
+      await store.saveMessages({ messages: [updatedMessage], format: 'v2' });
+
+      // Retrieve messages for the thread
+      const retrievedMessages = await store.getMessages({ threadId: thread.id, format: 'v2' });
+
+      // Only one message should exist for that id+threadId
+      expect(retrievedMessages.filter(m => m.id === baseMessage.id)).toHaveLength(1);
+
+      // The content should be the updated one
+      expect(retrievedMessages.find(m => m.id === baseMessage.id)?.content.content).toBe('Updated');
+    });
+
+    it('should upsert messages: duplicate id and different threadid', async () => {
+      const thread1 = await createSampleThread();
+      const thread2 = await createSampleThread();
+      await store.saveThread({ thread: thread1 });
+      await store.saveThread({ thread: thread2 });
+
+      const message = createSampleMessageV2({
+        threadId: thread1.id,
+        createdAt: new Date(),
+        content: { content: 'Thread1 Content' },
+        resourceId: thread1.resourceId,
+      });
+
+      // Insert message into thread1
+      await store.saveMessages({ messages: [message], format: 'v2' });
+
+      // Attempt to insert a message with the same id but different threadId
+      const conflictingMessage = {
+        ...createSampleMessageV2({
+          threadId: thread2.id, // different thread
+          content: { content: 'Thread2 Content' },
+          resourceId: thread2.resourceId,
+        }),
+        id: message.id,
+      };
+
+      // Save should move the message to the new thread
+      await store.saveMessages({ messages: [conflictingMessage], format: 'v2' });
+
+      // Retrieve messages for both threads
+      const thread1Messages = await store.getMessages({ threadId: thread1.id, format: 'v2' });
+      const thread2Messages = await store.getMessages({ threadId: thread2.id, format: 'v2' });
+
+      // Thread 1 should NOT have the message with that id
+      expect(thread1Messages.find(m => m.id === message.id)).toBeUndefined();
+
+      // Thread 2 should have the message with that id
+      expect(thread2Messages.find(m => m.id === message.id)?.content.content).toBe('Thread2 Content');
+    });
   });
 
   describe('Edge Cases and Error Handling', () => {
@@ -1615,7 +1690,6 @@ describe('PostgresStore', () => {
           selectBy: { pagination: { page: 0, perPage: 5 } },
           format: 'v2',
         });
-        console.log(page1);
         expect(page1.messages).toHaveLength(5);
         expect(page1.total).toBe(15);
         expect(page1.page).toBe(0);
@@ -1686,6 +1760,286 @@ describe('PostgresStore', () => {
           );
         }
       });
+
+      it('should save and retrieve messages', async () => {
+        const thread = createSampleThread();
+        await store.saveThread({ thread });
+
+        const messages = [
+          createSampleMessageV1({ threadId: thread.id }),
+          createSampleMessageV1({ threadId: thread.id }),
+        ];
+
+        // Save messages
+        const savedMessages = await store.saveMessages({ messages });
+        expect(savedMessages).toEqual(messages);
+
+        // Retrieve messages
+        const retrievedMessages = await store.getMessagesPaginated({ threadId: thread.id, format: 'v1' });
+        expect(retrievedMessages.messages).toHaveLength(2);
+        const checkMessages = messages.map(m => {
+          const { resourceId, ...rest } = m;
+          return rest;
+        });
+        expect(retrievedMessages.messages).toEqual(expect.arrayContaining(checkMessages));
+      });
+
+      it('should maintain message order', async () => {
+        const thread = createSampleThread();
+        await store.saveThread({ thread });
+
+        const messageContent = ['First', 'Second', 'Third'];
+
+        const messages = messageContent.map(content =>
+          createSampleMessageV2({
+            threadId: thread.id,
+            content: { content, parts: [{ type: 'text', text: content }] },
+          }),
+        );
+
+        await store.saveMessages({ messages, format: 'v2' });
+
+        const retrievedMessages = await store.getMessagesPaginated({ threadId: thread.id, format: 'v2' });
+        expect(retrievedMessages.messages).toHaveLength(3);
+
+        // Verify order is maintained
+        retrievedMessages.messages.forEach((msg, idx) => {
+          expect((msg.content.parts[0] as any).text).toEqual(messageContent[idx]);
+        });
+      });
+
+      it('should rollback on error during message save', async () => {
+        const thread = createSampleThread();
+        await store.saveThread({ thread });
+
+        const messages = [
+          createSampleMessageV1({ threadId: thread.id }),
+          { ...createSampleMessageV1({ threadId: thread.id }), id: null } as any, // This will cause an error
+        ];
+
+        await expect(store.saveMessages({ messages })).rejects.toThrow();
+
+        // Verify no messages were saved
+        const savedMessages = await store.getMessagesPaginated({ threadId: thread.id, format: 'v2' });
+        expect(savedMessages.messages).toHaveLength(0);
+      });
+
+      it('should retrieve messages w/ next/prev messages by message id + resource id', async () => {
+        const thread = createSampleThread({ id: 'thread-one' });
+        await store.saveThread({ thread });
+
+        const thread2 = createSampleThread({ id: 'thread-two' });
+        await store.saveThread({ thread: thread2 });
+
+        const thread3 = createSampleThread({ id: 'thread-three' });
+        await store.saveThread({ thread: thread3 });
+
+        const messages: MastraMessageV2[] = [
+          createSampleMessageV2({
+            threadId: 'thread-one',
+            content: { content: 'First' },
+            resourceId: 'cross-thread-resource',
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-one',
+            content: { content: 'Second' },
+            resourceId: 'cross-thread-resource',
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-one',
+            content: { content: 'Third' },
+            resourceId: 'cross-thread-resource',
+          }),
+
+          createSampleMessageV2({
+            threadId: 'thread-two',
+            content: { content: 'Fourth' },
+            resourceId: 'cross-thread-resource',
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-two',
+            content: { content: 'Fifth' },
+            resourceId: 'cross-thread-resource',
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-two',
+            content: { content: 'Sixth' },
+            resourceId: 'cross-thread-resource',
+          }),
+
+          createSampleMessageV2({
+            threadId: 'thread-three',
+            content: { content: 'Seventh' },
+            resourceId: 'other-resource',
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-three',
+            content: { content: 'Eighth' },
+            resourceId: 'other-resource',
+          }),
+        ];
+
+        await store.saveMessages({ messages: messages, format: 'v2' });
+
+        const retrievedMessages = await store.getMessagesPaginated({ threadId: 'thread-one', format: 'v2' });
+        expect(retrievedMessages.messages).toHaveLength(3);
+        expect(retrievedMessages.messages.map((m: any) => m.content.parts[0].text)).toEqual([
+          'First',
+          'Second',
+          'Third',
+        ]);
+
+        const retrievedMessages2 = await store.getMessagesPaginated({ threadId: 'thread-two', format: 'v2' });
+        expect(retrievedMessages2.messages).toHaveLength(3);
+        expect(retrievedMessages2.messages.map((m: any) => m.content.parts[0].text)).toEqual([
+          'Fourth',
+          'Fifth',
+          'Sixth',
+        ]);
+
+        const retrievedMessages3 = await store.getMessagesPaginated({ threadId: 'thread-three', format: 'v2' });
+        expect(retrievedMessages3.messages).toHaveLength(2);
+        expect(retrievedMessages3.messages.map((m: any) => m.content.parts[0].text)).toEqual(['Seventh', 'Eighth']);
+
+        const { messages: crossThreadMessages } = await store.getMessagesPaginated({
+          threadId: 'thread-doesnt-exist',
+          format: 'v2',
+          selectBy: {
+            last: 0,
+            include: [
+              {
+                id: messages[1].id,
+                threadId: 'thread-one',
+                withNextMessages: 2,
+                withPreviousMessages: 2,
+              },
+              {
+                id: messages[4].id,
+                threadId: 'thread-two',
+                withPreviousMessages: 2,
+                withNextMessages: 2,
+              },
+            ],
+          },
+        });
+
+        expect(crossThreadMessages).toHaveLength(6);
+        expect(crossThreadMessages.filter(m => m.threadId === `thread-one`)).toHaveLength(3);
+        expect(crossThreadMessages.filter(m => m.threadId === `thread-two`)).toHaveLength(3);
+
+        const crossThreadMessages2 = await store.getMessagesPaginated({
+          threadId: 'thread-one',
+          format: 'v2',
+          selectBy: {
+            last: 0,
+            include: [
+              {
+                id: messages[4].id,
+                threadId: 'thread-two',
+                withPreviousMessages: 1,
+                withNextMessages: 1,
+              },
+            ],
+          },
+        });
+
+        expect(crossThreadMessages2.messages).toHaveLength(3);
+        expect(crossThreadMessages2.messages.filter(m => m.threadId === `thread-one`)).toHaveLength(0);
+        expect(crossThreadMessages2.messages.filter(m => m.threadId === `thread-two`)).toHaveLength(3);
+
+        const crossThreadMessages3 = await store.getMessagesPaginated({
+          threadId: 'thread-two',
+          format: 'v2',
+          selectBy: {
+            last: 0,
+            include: [
+              {
+                id: messages[1].id,
+                threadId: 'thread-one',
+                withNextMessages: 1,
+                withPreviousMessages: 1,
+              },
+            ],
+          },
+        });
+
+        expect(crossThreadMessages3.messages).toHaveLength(3);
+        expect(crossThreadMessages3.messages.filter(m => m.threadId === `thread-one`)).toHaveLength(3);
+        expect(crossThreadMessages3.messages.filter(m => m.threadId === `thread-two`)).toHaveLength(0);
+      });
+
+      it('should return messages using both last and include (cross-thread, deduped)', async () => {
+        const thread = createSampleThread({ id: 'thread-one' });
+        await store.saveThread({ thread });
+
+        const thread2 = createSampleThread({ id: 'thread-two' });
+        await store.saveThread({ thread: thread2 });
+
+        const now = new Date();
+
+        // Setup: create messages in two threads
+        const messages = [
+          createSampleMessageV2({
+            threadId: 'thread-one',
+            content: { content: 'A' },
+            createdAt: new Date(now.getTime()),
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-one',
+            content: { content: 'B' },
+            createdAt: new Date(now.getTime() + 1000),
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-one',
+            content: { content: 'C' },
+            createdAt: new Date(now.getTime() + 2000),
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-two',
+            content: { content: 'D' },
+            createdAt: new Date(now.getTime() + 3000),
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-two',
+            content: { content: 'E' },
+            createdAt: new Date(now.getTime() + 4000),
+          }),
+          createSampleMessageV2({
+            threadId: 'thread-two',
+            content: { content: 'F' },
+            createdAt: new Date(now.getTime() + 5000),
+          }),
+        ];
+        await store.saveMessages({ messages, format: 'v2' });
+
+        // Use last: 2 and include a message from another thread with context
+        const { messages: result } = await store.getMessagesPaginated({
+          threadId: 'thread-one',
+          format: 'v2',
+          selectBy: {
+            last: 2,
+            include: [
+              {
+                id: messages[4].id, // 'E' from thread-bar
+                threadId: 'thread-two',
+                withPreviousMessages: 1,
+                withNextMessages: 1,
+              },
+            ],
+          },
+        });
+
+        // Should include last 2 from thread-one and 3 from thread-two (D, E, F)
+        expect(result.map(m => m.content.content).sort()).toEqual(['B', 'C', 'D', 'E', 'F']);
+        // Should include 2 from thread-one
+        expect(result.filter(m => m.threadId === 'thread-one').map((m: any) => m.content.content)).toEqual(['B', 'C']);
+        // Should include 3 from thread-two
+        expect(result.filter(m => m.threadId === 'thread-two').map((m: any) => m.content.content)).toEqual([
+          'D',
+          'E',
+          'F',
+        ]);
+      });
     });
 
     describe('getThreadsByResourceId with pagination', () => {

package/src/storage/index.ts

@@ -8,6 +8,7 @@ import {
   TABLE_MESSAGES,
   TABLE_THREADS,
   TABLE_TRACES,
+  TABLE_RESOURCES,
   TABLE_WORKFLOW_SNAPSHOT,
   TABLE_EVALS,
 } from '@mastra/core/storage';
@@ -16,6 +17,7 @@ import type {
   PaginationInfo,
   StorageColumn,
   StorageGetMessagesArg,
+  StorageResourceType,
   TABLE_NAMES,
   WorkflowRun,
   WorkflowRuns,
@@ -101,9 +103,11 @@ export class PostgresStore extends MastraStorage {
 
   public get supports(): {
     selectByIncludeResourceScope: boolean;
+    resourceWorkingMemory: boolean;
   } {
     return {
       selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
     };
   }
 
@@ -1024,7 +1028,10 @@ export class PostgresStore extends MastraStorage {
     }
 
     try {
-      const perPage = perPageInput !== undefined ? perPageInput : 40;
+      const perPage =
+        perPageInput !== undefined
+          ? perPageInput
+          : this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
       const currentOffset = page * perPage;
 
       const conditions: string[] = [`thread_id = $1`];
@@ -1045,7 +1052,7 @@ export class PostgresStore extends MastraStorage {
       const countResult = await this.db.one(countQuery, queryParams);
       const total = parseInt(countResult.count, 10);
 
-      if (total === 0) {
+      if (total === 0 && messages.length === 0) {
         return {
           messages: [],
           total: 0,
@@ -1055,10 +1062,14 @@ export class PostgresStore extends MastraStorage {
         };
       }
 
+      const excludeIds = messages.map(m => m.id);
+      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + paramIndex}`).join(', ');
+      paramIndex += excludeIds.length;
+
       const dataQuery = `${selectStatement} FROM ${this.getTableName(
         TABLE_MESSAGES,
-      )} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
+      )} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ''}${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, ...excludeIds, perPage, currentOffset]);
       messages.push(...(rows || []));
 
       const list = new MessageList().add(messages, 'memory');
@@ -1140,7 +1151,13 @@ export class PostgresStore extends MastraStorage {
           }
           return t.none(
             `INSERT INTO ${this.getTableName(TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type, "resourceId") 
-             VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+             VALUES ($1, $2, $3, $4, $5, $6, $7)
+             ON CONFLICT (id) DO UPDATE SET
+              thread_id = EXCLUDED.thread_id,
+              content = EXCLUDED.content,
+              role = EXCLUDED.role,
+              type = EXCLUDED.type,
+              "resourceId" = EXCLUDED."resourceId"`,
             [
               message.id,
               message.threadId,
@@ -1658,4 +1675,101 @@ export class PostgresStore extends MastraStorage {
       return message;
     });
   }
+
+  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
+    const tableName = this.getTableName(TABLE_RESOURCES);
+    const result = await this.db.oneOrNone<StorageResourceType>(`SELECT * FROM ${tableName} WHERE id = $1`, [
+      resourceId,
+    ]);
+
+    if (!result) {
+      return null;
+    }
+
+    return {
+      ...result,
+      // Ensure workingMemory is always returned as a string, regardless of automatic parsing
+      workingMemory:
+        typeof result.workingMemory === 'object' ? JSON.stringify(result.workingMemory) : result.workingMemory,
+      metadata: typeof result.metadata === 'string' ? JSON.parse(result.metadata) : result.metadata,
+    };
+  }
+
+  async saveResource({ resource }: { resource: StorageResourceType }): Promise<StorageResourceType> {
+    const tableName = this.getTableName(TABLE_RESOURCES);
+    await this.db.none(
+      `INSERT INTO ${tableName} (id, "workingMemory", metadata, "createdAt", "updatedAt") 
+       VALUES ($1, $2, $3, $4, $5)`,
+      [
+        resource.id,
+        resource.workingMemory,
+        JSON.stringify(resource.metadata),
+        resource.createdAt.toISOString(),
+        resource.updatedAt.toISOString(),
+      ],
+    );
+
+    return resource;
+  }
+
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata,
+  }: {
+    resourceId: string;
+    workingMemory?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<StorageResourceType> {
+    const existingResource = await this.getResourceById({ resourceId });
+
+    if (!existingResource) {
+      // Create new resource if it doesn't exist
+      const newResource: StorageResourceType = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+      return this.saveResource({ resource: newResource });
+    }
+
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== undefined ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata,
+      },
+      updatedAt: new Date(),
+    };
+
+    const tableName = this.getTableName(TABLE_RESOURCES);
+    const updates: string[] = [];
+    const values: any[] = [];
+    let paramIndex = 1;
+
+    if (workingMemory !== undefined) {
+      updates.push(`"workingMemory" = $${paramIndex}`);
+      values.push(workingMemory);
+      paramIndex++;
+    }
+
+    if (metadata) {
+      updates.push(`metadata = $${paramIndex}`);
+      values.push(JSON.stringify(updatedResource.metadata));
+      paramIndex++;
+    }
+
+    updates.push(`"updatedAt" = $${paramIndex}`);
+    values.push(updatedResource.updatedAt.toISOString());
+    paramIndex++;
+
+    values.push(resourceId);
+
+    await this.db.none(`UPDATE ${tableName} SET ${updates.join(', ')} WHERE id = $${paramIndex}`, values);
+
+    return updatedResource;
+  }
 }

package/src/vector/filter.test.ts

@@ -54,7 +54,7 @@ describe('PGFilterTranslator', () => {
         translator.translate({
           nested: {
             field: 'value',
-          },
+          } as any,
         }),
       ).toEqual({
         'nested.field': { $eq: 'value' },
@@ -634,7 +634,7 @@ describe('PGFilterTranslator', () => {
 
     it('throws error for $not if not an object', () => {
       expect(() => translator.translate({ $not: 'value' })).toThrow();
-      expect(() => translator.translate({ $not: [{ field: 'value' }] })).toThrow();
+      expect(() => translator.translate({ $not: [{ field: 'value' }] } as any)).toThrow();
     });
     it('throws error for $not if empty', () => {
       expect(() => translator.translate({ $not: {} })).toThrow();
@@ -645,21 +645,21 @@ describe('PGFilterTranslator', () => {
       // $and cannot be used in field conditions
       expect(() =>
         translator.translate({
-          field: { $and: [{ $eq: 'value1' }, { $eq: 'value2' }] },
+          field: { $and: [{ $eq: 'value1' }, { $eq: 'value2' }] } as any,
         }),
       ).toThrow();
 
       // $or cannot be used in field conditions
       expect(() =>
         translator.translate({
-          field: { $or: [{ $eq: 'value1' }, { $eq: 'value2' }] },
+          field: { $or: [{ $eq: 'value1' }, { $eq: 'value2' }] } as any,
         }),
       ).toThrow();
 
       // $nor cannot be used in field conditions
       expect(() =>
         translator.translate({
-          field: { $nor: [{ $eq: 'value1' }, { $eq: 'value2' }] },
+          field: { $nor: [{ $eq: 'value1' }, { $eq: 'value2' }] } as any,
         }),
       ).toThrow();
     });
@@ -710,7 +710,7 @@ describe('PGFilterTranslator', () => {
             $gt: {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
             },
-          },
+          } as any,
         }),
       ).toThrow();
 
@@ -721,7 +721,7 @@ describe('PGFilterTranslator', () => {
             $in: [
               {
                 $and: [{ subfield: 'value1' }, { subfield: 'value2' }],
-              },
+              } as any,
             ],
           },
         }),
@@ -730,7 +730,7 @@ describe('PGFilterTranslator', () => {
 
     it('validates $not operator structure', () => {
       // $not must be an object
-      expect(() => translator.translate({ field: { $not: 'value' } })).toThrow();
+      expect(() => translator.translate({ field: { $not: 'value' } } as any)).toThrow();
       expect(() => translator.translate({ field: { $not: ['value'] } })).toThrow();
       expect(() => translator.translate({ $not: 'value' })).toThrow();
       expect(() => translator.translate({ $not: ['value'] })).toThrow();
@@ -790,7 +790,7 @@ describe('PGFilterTranslator', () => {
     });
 
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
+      const invalidFilters: any = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
 
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);
@@ -808,13 +808,13 @@ describe('PGFilterTranslator', () => {
       // Should throw for non-object values
       expect(() =>
         translator.translate({
-          field: { $elemMatch: 'value' },
+          field: { $elemMatch: 'value' } as any,
         }),
       ).toThrow('$elemMatch requires an object with conditions');
 
       expect(() =>
         translator.translate({
-          field: { $elemMatch: ['value'] },
+          field: { $elemMatch: ['value'] } as any,
         }),
       ).toThrow('$elemMatch requires an object with conditions');
     });
@@ -917,7 +917,7 @@ describe('PGFilterTranslator', () => {
         translator.translate({
           nested: {
             field: { $regex: 'pattern', $options: 'i' },
-          },
+          } as any,
         }),
       ).toEqual({
         'nested.field': { $regex: '(?i)pattern' },