@mastra/astra 0.11.4 → 0.11.7-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @mastra/astra
 
+## 0.11.7-alpha.0
+
+### Patch Changes
+
+- [#7343](https://github.com/mastra-ai/mastra/pull/7343) [`de3cbc6`](https://github.com/mastra-ai/mastra/commit/de3cbc61079211431bd30487982ea3653517278e) Thanks [@LekoArts](https://github.com/LekoArts)! - Update the `package.json` file to include additional fields like `repository`, `homepage` or `files`.
+
+- Updated dependencies [[`85ef90b`](https://github.com/mastra-ai/mastra/commit/85ef90bb2cd4ae4df855c7ac175f7d392c55c1bf), [`de3cbc6`](https://github.com/mastra-ai/mastra/commit/de3cbc61079211431bd30487982ea3653517278e)]:
+  - @mastra/core@0.15.3-alpha.5
+
+## 0.11.6
+
+### Patch Changes
+
+- [`c6113ed`](https://github.com/mastra-ai/mastra/commit/c6113ed7f9df297e130d94436ceee310273d6430) Thanks [@wardpeet](https://github.com/wardpeet)! - Fix peerdpes for @mastra/core
+
+- Updated dependencies []:
+  - @mastra/core@0.15.2
+
+## 0.11.5
+
+### Patch Changes
+
+- [`95b2aa9`](https://github.com/mastra-ai/mastra/commit/95b2aa908230919e67efcac0d69005a2d5745298) Thanks [@wardpeet](https://github.com/wardpeet)! - Fix peerdeps @mastra/core
+
+- Updated dependencies []:
+  - @mastra/core@0.15.1
+
 ## 0.11.4
 
 ### Patch Changes

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@mastra/astra",
-  "version": "0.11.4",
+  "version": "0.11.7-alpha.0",
   "description": "Astra DB provider for Mastra - includes vector store capabilities",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
   "exports": {
     ".": {
       "import": {
@@ -18,7 +22,7 @@
     },
     "./package.json": "./package.json"
   },
-  "license": "MIT",
+  "license": "Apache-2.0",
   "dependencies": {
     "@datastax/astra-db-ts": "^1.5.0"
   },
@@ -29,12 +33,21 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@internal/lint": "0.0.30",
-    "@mastra/core": "0.14.0",
-    "@internal/types-builder": "0.0.5"
+    "@internal/lint": "0.0.34",
+    "@mastra/core": "0.15.3-alpha.5",
+    "@internal/types-builder": "0.0.9"
   },
   "peerDependencies": {
-    "@mastra/core": ">=0.10.7-0 <0.15.0-0"
+    "@mastra/core": ">=0.10.7-0 <0.16.0-0"
+  },
+  "homepage": "https://mastra.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mastra-ai/mastra.git",
+    "directory": "stores/astra"
+  },
+  "bugs": {
+    "url": "https://github.com/mastra-ai/mastra/issues"
   },
   "scripts": {
     "build": "tsup --silent --config tsup.config.ts",

package/.turbo/turbo-build.log

@@ -1,4 +0,0 @@
-
-> @mastra/astra@0.11.4-alpha.0 build /home/runner/work/mastra/mastra/stores/astra
-> tsup --silent --config tsup.config.ts
-

package/eslint.config.js

@@ -1,6 +0,0 @@
-import { createConfig } from '@internal/lint/eslint';
-
-const config = await createConfig();
-
-/** @type {import("eslint").Linter.Config[]} */
-export default [...config];

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './vector';
-export { ASTRA_PROMPT } from './vector/prompt';

package/src/vector/filter.test.ts

@@ -1,353 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-
-import type { AstraVectorFilter } from './filter';
-import { AstraFilterTranslator } from './filter';
-
-describe('AstraFilterTranslator', () => {
-  let translator: AstraFilterTranslator;
-
-  beforeEach(() => {
-    translator = new AstraFilterTranslator();
-  });
-
-  // Basic Filter Operations
-  describe('basic operations', () => {
-    it('handles simple equality', () => {
-      const filter: AstraVectorFilter = { field: 'value' };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('handles comparison operators', () => {
-      const filter: AstraVectorFilter = {
-        age: { $gt: 25 },
-        score: { $lte: 100 },
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('handles valid multiple operators on same field', () => {
-      const filter: AstraVectorFilter = {
-        price: { $gt: 100, $lt: 200 },
-        quantity: { $gte: 10, $lte: 20 },
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('handles null values correctly', () => {
-      const filter: AstraVectorFilter = {
-        field: null,
-        other: { $eq: null },
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('throws on unsupported combinations', () => {
-      const filter: AstraVectorFilter = {
-        field: { $gt: 100, $lt: 200 },
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-  });
-
-  // Array Operations
-  describe('array operations', () => {
-    it('handles array operators', () => {
-      const filter: AstraVectorFilter = {
-        tags: { $all: ['tag1', 'tag2'] },
-        categories: { $in: ['A', 'B'] },
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-    it('handles empty array values', () => {
-      const filter: AstraVectorFilter = {
-        tags: { $in: [] },
-        categories: { $all: [] },
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('handles nested array operators', () => {
-      const filter: AstraVectorFilter = {
-        $and: [{ tags: { $all: ['tag1', 'tag2'] } }, { 'nested.array': { $in: [1, 2, 3] } }],
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-  });
-
-  // Logical Operators
-  describe('logical operators', () => {
-    it('handles logical operators', () => {
-      const filter: AstraVectorFilter = {
-        $or: [{ status: 'active' }, { age: { $gt: 25 } }],
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('handles nested logical operators', () => {
-      const filter: AstraVectorFilter = {
-        $and: [
-          { status: 'active' },
-          { $or: [{ category: { $in: ['A', 'B'] } }, { $and: [{ price: { $gt: 100 } }, { stock: { $lt: 50 } }] }] },
-        ],
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('handles empty conditions in logical operators', () => {
-      const filter: AstraVectorFilter = {
-        $and: [],
-        $or: [{}],
-        field: 'value',
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('allows multiple logical operators at root level with complex conditions', () => {
-      expect(() =>
-        translator.translate({
-          $and: [{ field1: { $gt: 10 } }],
-          $or: [{ field2: { $lt: 20 } }],
-          field4: { $not: { $eq: 'value' } },
-        }),
-      ).not.toThrow();
-    });
-
-    it('allows logical operators at root level', () => {
-      expect(() =>
-        translator.translate({
-          $and: [{ field1: 'value1' }, { field2: 'value2' }],
-          $or: [{ field3: 'value3' }, { field4: 'value4' }],
-        }),
-      ).not.toThrow();
-    });
-
-    it('allows logical operators nested within other logical operators', () => {
-      expect(() =>
-        translator.translate({
-          $and: [
-            {
-              $or: [{ field1: 'value1' }, { field2: 'value2' }],
-            },
-            {
-              $and: [{ field3: 'value3' }, { field4: 'value4' }],
-            },
-          ],
-        }),
-      ).not.toThrow();
-    });
-  });
-
-  // Logical Operator Validation
-  describe('logical operator validation', () => {
-    it('throws error for direct operators in logical operator arrays', () => {
-      expect(() =>
-        translator.translate({
-          $and: [{ $eq: 'value' }, { $gt: 100 }],
-        }),
-      ).toThrow(/Logical operators must contain field conditions/);
-
-      expect(() =>
-        translator.translate({
-          $or: [{ $in: ['value1', 'value2'] as any }],
-        }),
-      ).toThrow(/Logical operators must contain field conditions/);
-    });
-
-    it('throws error for deeply nested logical operators in non-logical contexts', () => {
-      expect(() =>
-        translator.translate({
-          field: {
-            $gt: {
-              $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
-            } as any,
-          },
-        }),
-      ).toThrow();
-
-      expect(() =>
-        translator.translate({
-          field: {
-            $in: [
-              {
-                $and: [{ subfield: 'value1' }, { subfield: 'value2' }],
-              } as any,
-            ],
-          },
-        }),
-      ).toThrow();
-    });
-
-    it('throws error for logical operators nested in non-logical contexts', () => {
-      expect(() =>
-        translator.translate({
-          field: {
-            $gt: {
-              $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
-            } as any,
-          },
-        }),
-      ).toThrow();
-
-      expect(() =>
-        translator.translate({
-          field: {
-            $not: {
-              $and: [{ subfield: 'value1' }, { subfield: 'value2' }],
-            },
-          },
-        }),
-      ).not.toThrow(); // $not is allowed to contain logical operators
-    });
-
-    it('throws error for $not if not an object', () => {
-      expect(() => translator.translate({ $not: 'value' })).toThrow();
-      expect(() => translator.translate({ $not: [{ field: 'value' }] } as any)).toThrow();
-    });
-
-    it('throws error for $not if empty', () => {
-      expect(() => translator.translate({ $not: {} })).toThrow();
-    });
-  });
-
-  // Nested Objects and Fields
-  describe('nested objects and fields', () => {
-    it('handles nested objects', () => {
-      const filter: AstraVectorFilter = {
-        'user.profile.age': { $gt: 25 },
-        'user.status': 'active',
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('handles deeply nested field paths', () => {
-      const filter: AstraVectorFilter = {
-        'user.profile.address.city': { $eq: 'New York' },
-        'deep.nested.field': { $gt: 100 },
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('preserves nested empty objects', () => {
-      const filter: AstraVectorFilter = {
-        status: 'active',
-        metadata: {},
-        'user.profile': {},
-        'usersettings.theme': null,
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('handles mix of operators and empty objects', () => {
-      const filter: AstraVectorFilter = {
-        tags: { $in: ['a', 'b'] },
-        metadata: {},
-        'nested.field': { $eq: 'value' },
-        'nested.empty': {},
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-
-    it('handles deeply nested operators', () => {
-      const filter: AstraVectorFilter = {
-        'user.profile.preferences.theme': { $in: ['dark', 'light'] },
-      };
-      expect(translator.translate(filter)).toEqual(filter);
-    });
-  });
-
-  // Special Cases
-  describe('special cases', () => {
-    it('handles empty filters', () => {
-      expect(translator.translate({})).toEqual({});
-      expect(translator.translate(null)).toEqual(null);
-      expect(translator.translate(undefined)).toEqual(undefined);
-    });
-
-    it('normalizes dates', () => {
-      const date = new Date('2024-01-01');
-      const filter: AstraVectorFilter = { timestamp: { $gt: date } };
-      expect(translator.translate(filter)).toEqual({
-        timestamp: { $gt: date.toISOString() },
-      });
-    });
-
-    it('allows $not in field-level conditions', () => {
-      expect(() =>
-        translator.translate({
-          field1: { $not: { $eq: 'value1' } },
-          field2: { $not: { $in: ['value2', 'value3'] } },
-          field3: { $not: { $regex: 'pattern' } },
-        }),
-      ).not.toThrow();
-    });
-  });
-
-  describe('operator validation', () => {
-    it('ensure all operator filters are supported', () => {
-      const supportedFilters: AstraVectorFilter[] = [
-        // Basic comparison operators
-        { field: { $eq: 'value' } },
-        { field: { $ne: 'value' } },
-        { field: { $gt: 'value' } },
-        { field: { $gte: 'value' } },
-        { field: { $lt: 'value' } },
-        { field: { $lte: 'value' } },
-
-        // Array operators
-        { field: { $in: ['value'] } },
-        { field: { $nin: ['value'] } },
-        { field: { $all: ['value'] } },
-
-        // Existence
-        { field: { $exists: true } },
-
-        { $and: [{ field1: 'value1' }, { field2: 'value2' }] },
-        { $or: [{ field1: 'value1' }, { field2: 'value2' }] },
-
-        { $not: { field: 'value' } },
-
-        { $or: [{ $and: [{ field1: 'value1' }] }, { $not: { field2: 'value2' } }] },
-
-        { field: { $not: { $eq: 'value' } } },
-        { field: { $not: { $in: ['value1', 'value2'] } } },
-        { field: { $not: { $gt: 100 } } },
-        { field: { $not: { $lt: 50 } } },
-
-        { field: { $size: 1 } },
-      ];
-
-      supportedFilters.forEach(filter => {
-        expect(() => translator.translate(filter)).not.toThrow();
-      });
-    });
-
-    it('throws on unsupported operators', () => {
-      expect(() => translator.translate({ field: { $regex: 'value' } as any })).toThrow('Unsupported operator: $regex');
-      const filter: any = { field: /pattern/i };
-      expect(() => translator.translate(filter)).toThrow();
-      expect(() => translator.translate({ $nor: [{ field: 'value' }] } as any)).toThrow('Unsupported operator: $nor');
-      expect(() => translator.translate({ field: { $elemMatch: { $gt: 5 } } } as any)).toThrow(
-        'Unsupported operator: $elemMatch',
-      );
-    });
-    it('throws error for non-logical operators at top level', () => {
-      const invalidFilters: any = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $exists: true }];
-
-      invalidFilters.forEach(filter => {
-        expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);
-      });
-    });
-
-    it('allows logical operators at top level', () => {
-      const validFilters: AstraVectorFilter[] = [
-        { $and: [{ field: 'value' }] },
-        { $or: [{ field: 'value' }] },
-        { $not: { field: 'value' } },
-      ];
-
-      validFilters.forEach(filter => {
-        expect(() => translator.translate(filter)).not.toThrow();
-      });
-    });
-  });
-});

package/src/vector/filter.ts

@@ -1,83 +0,0 @@
-import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type {
-  VectorFilter,
-  OperatorSupport,
-  QueryOperator,
-  OperatorValueMap,
-  LogicalOperatorValueMap,
-  BlacklistedRootOperators,
-} from '@mastra/core/vector/filter';
-
-type AstraOperatorValueMap = Omit<OperatorValueMap, '$elemMatch' | '$regex' | '$options'> & {
-  $size: number; // Astra-specific
-};
-
-type AstraLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
-
-type AstraBlacklisted = BlacklistedRootOperators | '$nor' | '$size';
-
-export type AstraVectorFilter = VectorFilter<
-  keyof AstraOperatorValueMap,
-  AstraOperatorValueMap,
-  AstraLogicalOperatorValueMap,
-  AstraBlacklisted
->;
-
-/**
- * Translator for Astra DB filter queries.
- * Maintains MongoDB-compatible syntax while ensuring proper validation
- * and normalization of values.
- */
-export class AstraFilterTranslator extends BaseFilterTranslator<AstraVectorFilter> {
-  protected override getSupportedOperators(): OperatorSupport {
-    return {
-      ...BaseFilterTranslator.DEFAULT_OPERATORS,
-      array: ['$all', '$in', '$nin'],
-      logical: ['$and', '$or', '$not'],
-      regex: [],
-      custom: ['$size'],
-    };
-  }
-
-  translate(filter?: AstraVectorFilter): AstraVectorFilter {
-    if (this.isEmpty(filter)) return filter;
-    this.validateFilter(filter);
-
-    return this.translateNode(filter);
-  }
-
-  private translateNode(node: AstraVectorFilter): any {
-    // Handle primitive values and arrays
-    if (this.isRegex(node)) {
-      throw new Error('Regex is not supported in Astra DB');
-    }
-    if (this.isPrimitive(node) || Array.isArray(node)) {
-      return node;
-    }
-
-    const entries = Object.entries(node as Record<string, any>);
-    const translatedEntries = entries.map(([key, value]) => {
-      // Handle operators
-      if (this.isOperator(key)) {
-        return [key, this.translateOperatorValue(key, value)];
-      }
-
-      // Handle nested paths and objects
-      return [key, this.translateNode(value)];
-    });
-
-    return Object.fromEntries(translatedEntries);
-  }
-
-  private translateOperatorValue(operator: QueryOperator, value: any): any {
-    if (this.isBasicOperator(operator) || this.isNumericOperator(operator)) {
-      return this.normalizeComparisonValue(value);
-    }
-
-    if (this.isArrayOperator(operator) && Array.isArray(value)) {
-      return this.normalizeArrayValues(value);
-    }
-
-    return this.translateNode(value);
-  }
-}