@mastra/pg 0.3.0-alpha.6 → 0.3.0-alpha.8

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.3.0-alpha.6 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.3.0-alpha.8 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 11111ms
+TSC ⚡️ Build success in 11894ms
 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 11009ms
+DTS ⚡️ Build success in 12889ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 47.42 KB
-CJS ⚡️ Build success in 1596ms
-ESM dist/index.js 46.99 KB
-ESM ⚡️ Build success in 1596ms
+ESM dist/index.js 48.21 KB
+ESM ⚡️ Build success in 1550ms
+CJS dist/index.cjs 48.63 KB
+CJS ⚡️ Build success in 1553ms

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @mastra/pg
 
+## 0.3.0-alpha.8
+
+### Patch Changes
+
+- c0f22b4: [MASTRA-3130] Metadata Filter Update for PG and Libsql
+- Updated dependencies [000a6d4]
+- Updated dependencies [ed2f549]
+- Updated dependencies [c0f22b4]
+- Updated dependencies [0a033fa]
+- Updated dependencies [9c26508]
+- Updated dependencies [0f4eae3]
+- Updated dependencies [16a8648]
+  - @mastra/core@0.9.0-alpha.8
+
+## 0.3.0-alpha.7
+
+### Patch Changes
+
+- Updated dependencies [71d9444]
+  - @mastra/core@0.9.0-alpha.7
+
 ## 0.3.0-alpha.6
 
 ### Patch Changes

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

@@ -72,7 +72,7 @@ export declare const FILTER_OPERATORS: Record<string, OperatorFn>;
 declare type FilterOperator = {
     sql: string;
     needsValue: boolean;
-    transformValue?: (value: any) => any;
+    transformValue?: () => any;
 };
 
 export declare interface FilterResult {

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

@@ -72,7 +72,7 @@ export declare const FILTER_OPERATORS: Record<string, OperatorFn>;
 declare type FilterOperator = {
     sql: string;
     needsValue: boolean;
-    transformValue?: (value: any) => any;
+    transformValue?: () => any;
 };
 
 export declare interface FilterResult {

package/dist/index.cjs

@@ -148,11 +148,29 @@ var FILTER_OPERATORS = {
   $lte: createNumericOperator("<="),
   // Array Operators
   $in: (key, paramIndex) => ({
-    sql: `metadata#>>'{${handleKey(key)}}' = ANY($${paramIndex}::text[])`,
+    sql: `(
+      CASE
+        WHEN jsonb_typeof(metadata->'${handleKey(key)}') = 'array' THEN
+          EXISTS (
+            SELECT 1 FROM jsonb_array_elements_text(metadata->'${handleKey(key)}') as elem
+            WHERE elem = ANY($${paramIndex}::text[])
+          )
+        ELSE metadata#>>'{${handleKey(key)}}' = ANY($${paramIndex}::text[])
+      END
+    )`,
     needsValue: true
   }),
   $nin: (key, paramIndex) => ({
-    sql: `metadata#>>'{${handleKey(key)}}' != ALL($${paramIndex}::text[])`,
+    sql: `(
+      CASE
+        WHEN jsonb_typeof(metadata->'${handleKey(key)}') = 'array' THEN
+          NOT EXISTS (
+            SELECT 1 FROM jsonb_array_elements_text(metadata->'${handleKey(key)}') as elem
+            WHERE elem = ANY($${paramIndex}::text[])
+          )
+        ELSE metadata#>>'{${handleKey(key)}}' != ALL($${paramIndex}::text[])
+      END
+    )`,
     needsValue: true
   }),
   $all: (key, paramIndex) => ({
@@ -193,14 +211,33 @@ var FILTER_OPERATORS = {
     sql: `metadata#>>'{${handleKey(key)}}' ~ $${paramIndex}`,
     needsValue: true
   }),
-  $contains: (key, paramIndex) => ({
-    sql: `metadata @> $${paramIndex}::jsonb`,
-    needsValue: true,
-    transformValue: (value) => {
-      const parts = key.split(".");
-      return JSON.stringify(parts.reduceRight((value2, key2) => ({ [key2]: value2 }), value));
+  $contains: (key, paramIndex, value) => {
+    let sql;
+    if (Array.isArray(value)) {
+      sql = `(metadata->'${handleKey(key)}') ?& $${paramIndex}`;
+    } else if (typeof value === "string") {
+      sql = `metadata->>'${handleKey(key)}' ILIKE '%' || $${paramIndex} || '%'`;
+    } else {
+      sql = `metadata->>'${handleKey(key)}' = $${paramIndex}`;
     }
-  }),
+    return {
+      sql,
+      needsValue: true,
+      transformValue: () => Array.isArray(value) ? value.map(String) : value
+    };
+  },
+  /**
+   * $objectContains: Postgres-only operator for true JSONB object containment.
+   * Usage: { field: { $objectContains: { ...subobject } } }
+   */
+  // $objectContains: (key, paramIndex) => ({
+  //   sql: `metadata @> $${paramIndex}::jsonb`,
+  //   needsValue: true,
+  //   transformValue: value => {
+  //     const parts = key.split('.');
+  //     return JSON.stringify(parts.reduceRight((value, key) => ({ [key]: value }), value));
+  //   },
+  // }),
   $size: (key, paramIndex) => ({
     sql: `(
       CASE
@@ -244,7 +281,7 @@ function buildFilterQuery(filter, minScore) {
     const operatorFn = FILTER_OPERATORS[operator];
     const operatorResult = operatorFn(key, values.length + 1, operatorValue);
     if (operatorResult.needsValue) {
-      const transformedValue = operatorResult.transformValue ? operatorResult.transformValue(operatorValue) : operatorValue;
+      const transformedValue = operatorResult.transformValue ? operatorResult.transformValue() : operatorValue;
       if (Array.isArray(transformedValue) && operator === "$elemMatch") {
         values.push(...transformedValue);
       } else {

package/dist/index.js

@@ -140,11 +140,29 @@ var FILTER_OPERATORS = {
   $lte: createNumericOperator("<="),
   // Array Operators
   $in: (key, paramIndex) => ({
-    sql: `metadata#>>'{${handleKey(key)}}' = ANY($${paramIndex}::text[])`,
+    sql: `(
+      CASE
+        WHEN jsonb_typeof(metadata->'${handleKey(key)}') = 'array' THEN
+          EXISTS (
+            SELECT 1 FROM jsonb_array_elements_text(metadata->'${handleKey(key)}') as elem
+            WHERE elem = ANY($${paramIndex}::text[])
+          )
+        ELSE metadata#>>'{${handleKey(key)}}' = ANY($${paramIndex}::text[])
+      END
+    )`,
     needsValue: true
   }),
   $nin: (key, paramIndex) => ({
-    sql: `metadata#>>'{${handleKey(key)}}' != ALL($${paramIndex}::text[])`,
+    sql: `(
+      CASE
+        WHEN jsonb_typeof(metadata->'${handleKey(key)}') = 'array' THEN
+          NOT EXISTS (
+            SELECT 1 FROM jsonb_array_elements_text(metadata->'${handleKey(key)}') as elem
+            WHERE elem = ANY($${paramIndex}::text[])
+          )
+        ELSE metadata#>>'{${handleKey(key)}}' != ALL($${paramIndex}::text[])
+      END
+    )`,
     needsValue: true
   }),
   $all: (key, paramIndex) => ({
@@ -185,14 +203,33 @@ var FILTER_OPERATORS = {
     sql: `metadata#>>'{${handleKey(key)}}' ~ $${paramIndex}`,
     needsValue: true
   }),
-  $contains: (key, paramIndex) => ({
-    sql: `metadata @> $${paramIndex}::jsonb`,
-    needsValue: true,
-    transformValue: (value) => {
-      const parts = key.split(".");
-      return JSON.stringify(parts.reduceRight((value2, key2) => ({ [key2]: value2 }), value));
+  $contains: (key, paramIndex, value) => {
+    let sql;
+    if (Array.isArray(value)) {
+      sql = `(metadata->'${handleKey(key)}') ?& $${paramIndex}`;
+    } else if (typeof value === "string") {
+      sql = `metadata->>'${handleKey(key)}' ILIKE '%' || $${paramIndex} || '%'`;
+    } else {
+      sql = `metadata->>'${handleKey(key)}' = $${paramIndex}`;
     }
-  }),
+    return {
+      sql,
+      needsValue: true,
+      transformValue: () => Array.isArray(value) ? value.map(String) : value
+    };
+  },
+  /**
+   * $objectContains: Postgres-only operator for true JSONB object containment.
+   * Usage: { field: { $objectContains: { ...subobject } } }
+   */
+  // $objectContains: (key, paramIndex) => ({
+  //   sql: `metadata @> $${paramIndex}::jsonb`,
+  //   needsValue: true,
+  //   transformValue: value => {
+  //     const parts = key.split('.');
+  //     return JSON.stringify(parts.reduceRight((value, key) => ({ [key]: value }), value));
+  //   },
+  // }),
   $size: (key, paramIndex) => ({
     sql: `(
       CASE
@@ -236,7 +273,7 @@ function buildFilterQuery(filter, minScore) {
     const operatorFn = FILTER_OPERATORS[operator];
     const operatorResult = operatorFn(key, values.length + 1, operatorValue);
     if (operatorResult.needsValue) {
-      const transformedValue = operatorResult.transformValue ? operatorResult.transformValue(operatorValue) : operatorValue;
+      const transformedValue = operatorResult.transformValue ? operatorResult.transformValue() : operatorValue;
       if (Array.isArray(transformedValue) && operator === "$elemMatch") {
         values.push(...transformedValue);
       } else {

package/package.json

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

package/src/vector/index.test.ts

@@ -435,12 +435,7 @@ describe('PgVector', () => {
         });
 
         it('should handle filters correctly', async () => {
-          const results = await vectorDB.query({
-            indexName,
-            queryVector: [1, 0, 0],
-            topK: 10,
-            filter: { type: 'a' },
-          });
+          const results = await vectorDB.query({ indexName, queryVector: [1, 0, 0], topK: 10, filter: { type: 'a' } });
 
           expect(results).toHaveLength(1);
           results.forEach(result => {
@@ -606,7 +601,7 @@ describe('PgVector', () => {
 
     // Array Operator Tests
     describe('Array Operators', () => {
-      it('should filter with $in operator', async () => {
+      it('should filter with $in operator for scalar field', async () => {
         const results = await vectorDB.query({
           indexName,
           queryVector: [1, 0, 0],
@@ -618,7 +613,25 @@ describe('PgVector', () => {
         });
       });
 
-      it('should filter with $nin operator', async () => {
+      it('should filter with $in operator for array field', async () => {
+        // Insert a record with tags as array
+        await vectorDB.upsert({
+          indexName,
+          vectors: [[2, 0.2, 0]],
+          metadata: [{ tags: ['featured', 'sale', 'new'] }],
+        });
+        const results = await vectorDB.query({
+          indexName,
+          queryVector: [1, 0, 0],
+          filter: { tags: { $in: ['sale', 'clearance'] } },
+        });
+        expect(results.length).toBeGreaterThan(0);
+        results.forEach(result => {
+          expect(result.metadata?.tags.some((tag: string) => ['sale', 'clearance'].includes(tag))).toBe(true);
+        });
+      });
+
+      it('should filter with $nin operator for scalar field', async () => {
         const results = await vectorDB.query({
           indexName,
           queryVector: [1, 0, 0],
@@ -630,6 +643,24 @@ describe('PgVector', () => {
         });
       });
 
+      it('should filter with $nin operator for array field', async () => {
+        // Insert a record with tags as array
+        await vectorDB.upsert({
+          indexName,
+          vectors: [[2, 0.3, 0]],
+          metadata: [{ tags: ['clearance', 'used'] }],
+        });
+        const results = await vectorDB.query({
+          indexName,
+          queryVector: [1, 0, 0],
+          filter: { tags: { $nin: ['new', 'sale'] } },
+        });
+        expect(results.length).toBeGreaterThan(0);
+        results.forEach(result => {
+          expect(result.metadata?.tags.every((tag: string) => !['new', 'sale'].includes(tag))).toBe(true);
+        });
+      });
+
       it('should handle empty arrays in in/nin operators', async () => {
         // Should return no results for empty IN
         const resultsIn = await vectorDB.query({
@@ -660,6 +691,52 @@ describe('PgVector', () => {
         });
       });
 
+      it('should filter with $contains operator for string substring', async () => {
+        const results = await vectorDB.query({
+          indexName,
+          queryVector: [1, 0, 0],
+          filter: { category: { $contains: 'lectro' } },
+        });
+        expect(results.length).toBeGreaterThan(0);
+        results.forEach(result => {
+          expect(result.metadata?.category).toContain('lectro');
+        });
+      });
+
+      it('should not match deep object containment with $contains', async () => {
+        // Insert a record with a nested object
+        await vectorDB.upsert({
+          indexName,
+          vectors: [[1, 0.1, 0]],
+          metadata: [{ details: { color: 'red', size: 'large' }, category: 'clothing' }],
+        });
+        // $contains does NOT support deep object containment in Postgres
+        const results = await vectorDB.query({
+          indexName,
+          queryVector: [1, 0.1, 0],
+          filter: { details: { $contains: { color: 'red' } } },
+        });
+        expect(results.length).toBe(0);
+      });
+
+      it('should fallback to direct equality for non-array, non-string', async () => {
+        // Insert a record with a numeric field
+        await vectorDB.upsert({
+          indexName,
+          vectors: [[1, 0.2, 0]],
+          metadata: [{ price: 123 }],
+        });
+        const results = await vectorDB.query({
+          indexName,
+          queryVector: [1, 0, 0],
+          filter: { price: { $contains: 123 } },
+        });
+        expect(results.length).toBeGreaterThan(0);
+        results.forEach(result => {
+          expect(result.metadata?.price).toBe(123);
+        });
+      });
+
       it('should filter with $elemMatch operator', async () => {
         const results = await vectorDB.query({
           indexName,
@@ -810,29 +887,29 @@ describe('PgVector', () => {
         });
       });
 
-      it('should filter with $contains operator for nested objects', async () => {
-        // First insert a record with nested object
-        await vectorDB.upsert({
-          indexName,
-          vectors: [[1, 0.1, 0]],
-          metadata: [
-            {
-              details: { color: 'red', size: 'large' },
-              category: 'clothing',
-            },
-          ],
-        });
-
-        const results = await vectorDB.query({
-          indexName,
-          queryVector: [1, 0.1, 0],
-          filter: { details: { $contains: { color: 'red' } } },
-        });
-        expect(results.length).toBeGreaterThan(0);
-        results.forEach(result => {
-          expect(result.metadata?.details.color).toBe('red');
-        });
-      });
+      // it('should filter with $objectContains operator for nested objects', async () => {
+      //   // First insert a record with nested object
+      //   await vectorDB.upsert({
+      //     indexName,
+      //     vectors: [[1, 0.1, 0]],
+      //     metadata: [
+      //       {
+      //         details: { color: 'red', size: 'large' },
+      //         category: 'clothing',
+      //       },
+      //     ],
+      //   });
+
+      //   const results = await vectorDB.query({
+      //     indexName,
+      //     queryVector: [1, 0.1, 0],
+      //     filter: { details: { $objectContains: { color: 'red' } } },
+      //   });
+      //   expect(results.length).toBeGreaterThan(0);
+      //   results.forEach(result => {
+      //     expect(result.metadata?.details.color).toBe('red');
+      //   });
+      // });
 
       // String Pattern Tests
       it('should handle exact string matches', async () => {
@@ -1252,6 +1329,7 @@ describe('PgVector', () => {
           indexName,
           queryVector: [1, 0, 0],
           filter: { category: 'electronics' },
+          includeVector: false,
           minScore: 0.9,
         });
         expect(results.length).toBeGreaterThan(0);
@@ -1403,7 +1481,8 @@ describe('PgVector', () => {
           indexName,
           queryVector: [1, 0, 0],
           filter: { category: 'electronics' },
-          minScore: 0.9, // minScore
+          includeVector: false,
+          minScore: 0.9,
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -1457,7 +1536,11 @@ describe('PgVector', () => {
         const results = await vectorDB.query({
           indexName,
           queryVector: [1, 0, 0],
-          filter: { $and: [{ category: 'electronics' }], $or: [{ price: { $lt: 100 } }, { price: { $gt: 20 } }] },
+          filter: {
+            $and: [{ category: 'electronics' }],
+            $or: [{ price: { $lt: 100 } }, { price: { $gt: 20 } }],
+            $nor: [],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -1477,13 +1560,7 @@ describe('PgVector', () => {
         const results = await vectorDB.query({
           indexName,
           queryVector: [1, 0, 0],
-          filter: {
-            tags: {
-              $elemMatch: {
-                $eq: 'value',
-              },
-            },
-          },
+          filter: { tags: { $elemMatch: { $eq: 'value' } } },
         });
         expect(results).toHaveLength(0); // Should return no results for non-array field
       });

package/src/vector/sql-builder.ts

@@ -20,7 +20,7 @@ export type OperatorType =
 type FilterOperator = {
   sql: string;
   needsValue: boolean;
-  transformValue?: (value: any) => any;
+  transformValue?: () => any;
 };
 
 type OperatorFn = (key: string, paramIndex: number, value?: any) => FilterOperator;
@@ -103,11 +103,29 @@ export const FILTER_OPERATORS: Record<string, OperatorFn> = {
 
   // Array Operators
   $in: (key, paramIndex) => ({
-    sql: `metadata#>>'{${handleKey(key)}}' = ANY($${paramIndex}::text[])`,
+    sql: `(
+      CASE
+        WHEN jsonb_typeof(metadata->'${handleKey(key)}') = 'array' THEN
+          EXISTS (
+            SELECT 1 FROM jsonb_array_elements_text(metadata->'${handleKey(key)}') as elem
+            WHERE elem = ANY($${paramIndex}::text[])
+          )
+        ELSE metadata#>>'{${handleKey(key)}}' = ANY($${paramIndex}::text[])
+      END
+    )`,
     needsValue: true,
   }),
   $nin: (key, paramIndex) => ({
-    sql: `metadata#>>'{${handleKey(key)}}' != ALL($${paramIndex}::text[])`,
+    sql: `(
+      CASE
+        WHEN jsonb_typeof(metadata->'${handleKey(key)}') = 'array' THEN
+          NOT EXISTS (
+            SELECT 1 FROM jsonb_array_elements_text(metadata->'${handleKey(key)}') as elem
+            WHERE elem = ANY($${paramIndex}::text[])
+          )
+        ELSE metadata#>>'{${handleKey(key)}}' != ALL($${paramIndex}::text[])
+      END
+    )`,
     needsValue: true,
   }),
   $all: (key, paramIndex) => ({
@@ -151,14 +169,33 @@ export const FILTER_OPERATORS: Record<string, OperatorFn> = {
     needsValue: true,
   }),
 
-  $contains: (key, paramIndex) => ({
-    sql: `metadata @> $${paramIndex}::jsonb`,
-    needsValue: true,
-    transformValue: value => {
-      const parts = key.split('.');
-      return JSON.stringify(parts.reduceRight((value, key) => ({ [key]: value }), value));
-    },
-  }),
+  $contains: (key, paramIndex, value: any) => {
+    let sql;
+    if (Array.isArray(value)) {
+      sql = `(metadata->'${handleKey(key)}') ?& $${paramIndex}`;
+    } else if (typeof value === 'string') {
+      sql = `metadata->>'${handleKey(key)}' ILIKE '%' || $${paramIndex} || '%'`;
+    } else {
+      sql = `metadata->>'${handleKey(key)}' = $${paramIndex}`;
+    }
+    return {
+      sql,
+      needsValue: true,
+      transformValue: () => (Array.isArray(value) ? value.map(String) : value),
+    };
+  },
+  /**
+   * $objectContains: Postgres-only operator for true JSONB object containment.
+   * Usage: { field: { $objectContains: { ...subobject } } }
+   */
+  // $objectContains: (key, paramIndex) => ({
+  //   sql: `metadata @> $${paramIndex}::jsonb`,
+  //   needsValue: true,
+  //   transformValue: value => {
+  //     const parts = key.split('.');
+  //     return JSON.stringify(parts.reduceRight((value, key) => ({ [key]: value }), value));
+  //   },
+  // }),
   $size: (key: string, paramIndex: number) => ({
     sql: `(
       CASE
@@ -220,9 +257,7 @@ export function buildFilterQuery(filter: VectorFilter, minScore: number): Filter
     const operatorFn = FILTER_OPERATORS[operator as string]!;
     const operatorResult = operatorFn(key, values.length + 1, operatorValue);
     if (operatorResult.needsValue) {
-      const transformedValue = operatorResult.transformValue
-        ? operatorResult.transformValue(operatorValue)
-        : operatorValue;
+      const transformedValue = operatorResult.transformValue ? operatorResult.transformValue() : operatorValue;
       if (Array.isArray(transformedValue) && operator === '$elemMatch') {
         values.push(...transformedValue);
       } else {