@mastra/opensearch 0.0.0-vector-sources-20250516175436 → 0.0.0-vector-query-tool-provider-options-20250828222356

package/src/vector/filter.ts

@@ -1,30 +1,48 @@
-import type { FieldCondition, OperatorSupport, QueryOperator, VectorFilter } from '@mastra/core/vector/filter';
+import type {
+  BlacklistedRootOperators,
+  LogicalOperatorValueMap,
+  OperatorSupport,
+  OperatorValueMap,
+  QueryOperator,
+  VectorFilter,
+} from '@mastra/core/vector/filter';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
+type OpenSearchOperatorValueMap = Omit<OperatorValueMap, '$options' | '$nor' | '$elemMatch'>;
+
+type OpenSearchLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
+
+type OpenSearchBlacklisted = BlacklistedRootOperators | '$nor';
+
+export type OpenSearchVectorFilter = VectorFilter<
+  keyof OpenSearchOperatorValueMap,
+  OpenSearchOperatorValueMap,
+  OpenSearchLogicalOperatorValueMap,
+  OpenSearchBlacklisted
+>;
 /**
  * Translator for OpenSearch filter queries.
  * Maintains OpenSearch-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export class OpenSearchFilterTranslator extends BaseFilterTranslator {
+export class OpenSearchFilterTranslator extends BaseFilterTranslator<OpenSearchVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
       logical: ['$and', '$or', '$not'],
       array: ['$in', '$nin', '$all'],
-      element: ['$exists'],
       regex: ['$regex'],
       custom: [],
     };
   }
 
-  translate(filter?: VectorFilter): VectorFilter {
+  translate(filter?: OpenSearchVectorFilter): OpenSearchVectorFilter {
     if (this.isEmpty(filter)) return undefined;
     this.validateFilter(filter);
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition): any {
+  private translateNode(node: OpenSearchVectorFilter): any {
     // Handle primitive values and arrays
     if (this.isPrimitive(node) || Array.isArray(node)) {
       return node;

package/src/vector/index.test.ts

@@ -1,5 +1,5 @@
 // To setup a Opensearch server, run the docker compose file in the opensearch directory
-import type { QueryResult, QueryVectorParams } from '@mastra/core';
+import type { QueryResult } from '@mastra/core/vector';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { OpenSearchVector } from './index';
@@ -215,12 +215,11 @@ describe('OpenSearchVector', () => {
 
         await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors, metadata: testMetadata });
 
-        const queryParams: QueryVectorParams = {
+        const results = await vectorDB.query({
           indexName: testIndexName,
           queryVector: [1.0, 0.1, 0.1],
           topK: 3,
-        };
-        const results = await vectorDB.query(queryParams);
+        });
 
         expect(results).toHaveLength(3);
         expect(results[0]?.score).toBeGreaterThan(0);
@@ -1197,7 +1196,7 @@ describe('OpenSearchVector', () => {
           vectorDB.query({
             indexName,
             queryVector: [1, 0, 0],
-            filter: { price: { $invalid: 100 } },
+            filter: { price: { $invalid: 100 } as any },
           }),
         ).rejects.toThrow('Unsupported operator: $invalid');
       });

package/src/vector/index.ts

@@ -1,19 +1,19 @@
+import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
 import type {
   CreateIndexParams,
   DeleteIndexParams,
   DeleteVectorParams,
   DescribeIndexParams,
   IndexStats,
-  ParamsToArgs,
   QueryResult,
   QueryVectorParams,
   UpdateVectorParams,
   UpsertVectorParams,
-} from '@mastra/core';
+} from '@mastra/core/vector';
 import { MastraVector } from '@mastra/core/vector';
-import type { VectorFilter } from '@mastra/core/vector/filter';
 import { Client as OpenSearchClient } from '@opensearch-project/opensearch';
 import { OpenSearchFilterTranslator } from './filter';
+import type { OpenSearchVectorFilter } from './filter';
 
 const METRIC_MAPPING = {
   cosine: 'cosinesimil',
@@ -27,36 +27,18 @@ const REVERSE_METRIC_MAPPING = {
   innerproduct: 'dotproduct',
 } as const;
 
-export class OpenSearchVector extends MastraVector {
+type OpenSearchVectorParams = QueryVectorParams<OpenSearchVectorFilter>;
+
+export class OpenSearchVector extends MastraVector<OpenSearchVectorFilter> {
   private client: OpenSearchClient;
 
-  /**
-   * @deprecated Passing a string URL is deprecated. Use an object parameter: { url }.
-   * @param url - The OpenSearch node URL (deprecated)
-   */
-  constructor(url: string);
   /**
    * Creates a new OpenSearchVector client.
    *
-   * @param params - An object with a url property specifying the OpenSearch node.
+   * @param {string} url - The url of the OpenSearch node.
    */
-  constructor(params: { url: string });
-  constructor(paramsOrUrl: { url: string } | string) {
+  constructor({ url }: { url: string }) {
     super();
-    let url: string;
-    if (typeof paramsOrUrl === 'string') {
-      // Deprecation warning for positional argument
-      if (typeof console !== 'undefined' && console.warn) {
-        console.warn(
-          'Deprecation Warning: OpenSearchVector constructor positional arguments are deprecated. Please use a single object parameter instead. This signature will be removed on May 20th, 2025.',
-        );
-      }
-      url = paramsOrUrl;
-    } else if (typeof paramsOrUrl === 'object' && paramsOrUrl !== null && 'url' in paramsOrUrl) {
-      url = paramsOrUrl.url;
-    } else {
-      throw new Error('Invalid parameters for OpenSearchVector constructor. Expected { url: string }.');
-    }
     this.client = new OpenSearchClient({ node: url });
   }
 
@@ -68,11 +50,15 @@ export class OpenSearchVector extends MastraVector {
    * @param {'cosine' | 'euclidean' | 'dotproduct'} [metric=cosine] - The metric to use to sort vectors in the collection.
    * @returns {Promise<void>} A promise that resolves when the collection is created.
    */
-  async createIndex(params: CreateIndexParams): Promise<void> {
-    const { indexName, dimension, metric = 'cosine' } = params;
-
+  async createIndex({ indexName, dimension, metric = 'cosine' }: CreateIndexParams): Promise<void> {
     if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error('Dimension must be a positive integer');
+      throw new MastraError({
+        id: 'STORAGE_OPENSEARCH_VECTOR_CREATE_INDEX_INVALID_ARGS',
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: 'Dimension must be a positive integer',
+        details: { indexName, dimension },
+      });
     }
 
     try {
@@ -105,8 +91,15 @@ export class OpenSearchVector extends MastraVector {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
-      console.error(`Failed to create index ${indexName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_OPENSEARCH_VECTOR_CREATE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, dimension, metric },
+        },
+        error,
+      );
     }
   }
 
@@ -123,23 +116,25 @@ export class OpenSearchVector extends MastraVector {
         .filter((index: string | undefined) => index !== undefined);
 
       return indexes;
-    } catch (error: any) {
-      console.error('Failed to list indexes:', error);
-      throw new Error(`Failed to list indexes: ${error.message}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_OPENSEARCH_VECTOR_LIST_INDEXES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+        },
+        error,
+      );
     }
   }
 
   /**
    * Retrieves statistics about a vector index.
    *
-   * @param params - The parameters for describing an index
-   * @param params.indexName - The name of the index to describe
+   * @param {string} indexName - The name of the index to describe
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
-  async describeIndex(...args: ParamsToArgs<DescribeIndexParams>): Promise<IndexStats> {
-    const params = this.normalizeArgs<DescribeIndexParams>('describeIndex', args);
-
-    const { indexName } = params;
+  async describeIndex({ indexName }: DescribeIndexParams): Promise<IndexStats> {
     const { body: indexInfo } = await this.client.indices.get({ index: indexName });
     const mappings = indexInfo[indexName]?.mappings;
     const embedding: any = mappings?.properties?.embedding;
@@ -160,14 +155,21 @@ export class OpenSearchVector extends MastraVector {
    * @param {string} indexName - The name of the index to delete.
    * @returns {Promise<void>} A promise that resolves when the index is deleted.
    */
-  async deleteIndex(...args: ParamsToArgs<DeleteIndexParams>): Promise<void> {
-    const params = this.normalizeArgs<DeleteIndexParams>('deleteIndex', args);
-
-    const { indexName } = params;
+  async deleteIndex({ indexName }: DeleteIndexParams): Promise<void> {
     try {
       await this.client.indices.delete({ index: indexName });
     } catch (error) {
-      console.error(`Failed to delete index ${indexName}:`, error);
+      const mastraError = new MastraError(
+        {
+          id: 'STORAGE_OPENSEARCH_VECTOR_DELETE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
     }
   }
 
@@ -180,45 +182,50 @@ export class OpenSearchVector extends MastraVector {
    * @param {string[]} [ids] - An optional array of IDs corresponding to each vector. If not provided, new IDs will be generated.
    * @returns {Promise<string[]>} A promise that resolves to an array of IDs of the upserted vectors.
    */
-  async upsert(params: UpsertVectorParams): Promise<string[]> {
-    const { indexName, vectors, metadata = [], ids } = params;
-
+  async upsert({ indexName, vectors, metadata = [], ids }: UpsertVectorParams): Promise<string[]> {
     const vectorIds = ids || vectors.map(() => crypto.randomUUID());
     const operations = [];
 
-    // Get index stats to check dimension
-    const indexInfo = await this.describeIndex({ indexName });
+    try {
+      // Get index stats to check dimension
+      const indexInfo = await this.describeIndex({ indexName });
 
-    // Validate vector dimensions
-    this.validateVectorDimensions(vectors, indexInfo.dimension);
+      // Validate vector dimensions
+      this.validateVectorDimensions(vectors, indexInfo.dimension);
 
-    for (let i = 0; i < vectors.length; i++) {
-      const operation = {
-        index: {
-          _index: indexName,
-          _id: vectorIds[i],
-        },
-      };
+      for (let i = 0; i < vectors.length; i++) {
+        const operation = {
+          index: {
+            _index: indexName,
+            _id: vectorIds[i],
+          },
+        };
 
-      const document = {
-        id: vectorIds[i],
-        embedding: vectors[i],
-        metadata: metadata[i] || {},
-      };
+        const document = {
+          id: vectorIds[i],
+          embedding: vectors[i],
+          metadata: metadata[i] || {},
+        };
 
-      operations.push(operation);
-      operations.push(document);
-    }
+        operations.push(operation);
+        operations.push(document);
+      }
 
-    try {
       if (operations.length > 0) {
         await this.client.bulk({ body: operations, refresh: true });
       }
 
       return vectorIds;
     } catch (error) {
-      console.error('Failed to upsert vectors:', error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_OPENSEARCH_VECTOR_UPSERT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, vectorCount: vectors?.length || 0 },
+        },
+        error,
+      );
     }
   }
 
@@ -232,9 +239,13 @@ export class OpenSearchVector extends MastraVector {
    * @param {boolean} [includeVectors=false] - Whether to include the vectors in the response.
    * @returns {Promise<QueryResult[]>} A promise that resolves to an array of query results.
    */
-  async query(params: QueryVectorParams): Promise<QueryResult[]> {
-    const { indexName, queryVector, filter, topK = 10, includeVector = false } = params;
-
+  async query({
+    indexName,
+    queryVector,
+    filter,
+    topK = 10,
+    includeVector = false,
+  }: OpenSearchVectorParams): Promise<QueryResult[]> {
     try {
       const translatedFilter = this.transformFilter(filter);
 
@@ -262,9 +273,16 @@ export class OpenSearchVector extends MastraVector {
       });
 
       return results;
-    } catch (error: any) {
-      console.error('Failed to query vectors:', error);
-      throw new Error(`Failed to query vectors for index ${indexName}: ${error.message}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_OPENSEARCH_VECTOR_QUERY_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, topK },
+        },
+        error,
+      );
     }
   }
 
@@ -284,39 +302,14 @@ export class OpenSearchVector extends MastraVector {
   /**
    * Transforms the filter to the OpenSearch DSL.
    *
-   * @param {VectorFilter} filter - The filter to transform.
+   * @param {OpenSearchVectorFilter} filter - The filter to transform.
    * @returns {Record<string, any>} The transformed filter.
    */
-  private transformFilter(filter?: VectorFilter) {
+  private transformFilter(filter?: OpenSearchVectorFilter): any {
     const translator = new OpenSearchFilterTranslator();
     return translator.translate(filter);
   }
 
-  /**
-   * @deprecated Use {@link updateVector} instead. This method will be removed on May 20th, 2025.
-   *
-   * Updates a vector by its ID with the provided vector and/or metadata.
-   * @param indexName - The name of the index containing the vector.
-   * @param id - The ID of the vector to update.
-   * @param update - An object containing the vector and/or metadata to update.
-   * @param update.vector - An optional array of numbers representing the new vector.
-   * @param update.metadata - An optional record containing the new metadata.
-   * @returns A promise that resolves when the update is complete.
-   * @throws Will throw an error if no updates are provided or if the update operation fails.
-   */
-  async updateIndexById(
-    indexName: string,
-    id: string,
-    update: { vector?: number[]; metadata?: Record<string, any> },
-  ): Promise<void> {
-    this.logger.warn(
-      `Deprecation Warning: updateIndexById() is deprecated. 
-      Please use updateVector() instead. 
-      updateIndexById() will be removed on May 20th, 2025.`,
-    );
-    await this.updateVector({ indexName, id, update });
-  }
-
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
    * @param indexName - The name of the index containing the vector.
@@ -327,16 +320,16 @@ export class OpenSearchVector extends MastraVector {
    * @returns A promise that resolves when the update is complete.
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
-  async updateVector(...args: ParamsToArgs<UpdateVectorParams>): Promise<void> {
-    const params = this.normalizeArgs<UpdateVectorParams>('updateVector', args);
-    const { indexName, id, update } = params;
-    if (!update.vector && !update.metadata) {
-      throw new Error('No updates provided');
-    }
-
+  async updateVector({ indexName, id, update }: UpdateVectorParams): Promise<void> {
+    let existingDoc;
     try {
+      if (!update.vector && !update.metadata) {
+        throw new Error('No updates provided');
+      }
+
       // First get the current document to merge with updates
-      const { body: existingDoc } = await this.client
+      const { body } = await this.client
+
         .get({
           index: indexName,
           id: id,
@@ -345,25 +338,40 @@ export class OpenSearchVector extends MastraVector {
           throw new Error(`Document with ID ${id} not found in index ${indexName}`);
         });
 
-      if (!existingDoc || !existingDoc._source) {
+      if (!body || !body._source) {
         throw new Error(`Document with ID ${id} has no source data in index ${indexName}`);
       }
+      existingDoc = body;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_OPENSEARCH_VECTOR_UPDATE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName, id },
+        },
+        error,
+      );
+    }
 
-      const source = existingDoc._source;
-      const updatedDoc: Record<string, any> = {
-        id: source.id || id,
-      };
+    const source = existingDoc._source;
+    const updatedDoc: Record<string, any> = {
+      id: source?.id || id,
+    };
 
+    try {
       // Update vector if provided
       if (update.vector) {
         // Get index stats to check dimension
+        console.log(`1`);
         const indexInfo = await this.describeIndex({ indexName });
 
         // Validate vector dimensions
+        console.log(`2`);
         this.validateVectorDimensions([update.vector], indexInfo.dimension);
 
         updatedDoc.embedding = update.vector;
-      } else if (source.embedding) {
+      } else if (source?.embedding) {
         updatedDoc.embedding = source.embedding;
       }
 
@@ -371,10 +379,11 @@ export class OpenSearchVector extends MastraVector {
       if (update.metadata) {
         updatedDoc.metadata = update.metadata;
       } else {
-        updatedDoc.metadata = source.metadata || {};
+        updatedDoc.metadata = source?.metadata || {};
       }
 
       // Update the document
+      console.log(`3`);
       await this.client.index({
         index: indexName,
         id: id,
@@ -382,29 +391,18 @@ export class OpenSearchVector extends MastraVector {
         refresh: true,
       });
     } catch (error) {
-      console.error(`Failed to update document with ID ${id} in index ${indexName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_OPENSEARCH_VECTOR_UPDATE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id },
+        },
+        error,
+      );
     }
   }
 
-  /**
-   * @deprecated Use {@link deleteVector} instead. This method will be removed on May 20th, 2025.
-   *
-   * Deletes a vector by its ID.
-   * @param indexName - The name of the index containing the vector.
-   * @param id - The ID of the vector to delete.
-   * @returns A promise that resolves when the deletion is complete.
-   * @throws Will throw an error if the deletion operation fails.
-   */
-  async deleteIndexById(indexName: string, id: string): Promise<void> {
-    this.logger.warn(
-      `Deprecation Warning: deleteIndexById() is deprecated. 
-      Please use deleteVector() instead. 
-      deleteIndexById() will be removed on May 20th, 2025.`,
-    );
-    await this.deleteVector({ indexName, id });
-  }
-
   /**
    * Deletes a vector by its ID.
    * @param indexName - The name of the index containing the vector.
@@ -412,9 +410,7 @@ export class OpenSearchVector extends MastraVector {
    * @returns A promise that resolves when the deletion is complete.
    * @throws Will throw an error if the deletion operation fails.
    */
-  async deleteVector(...args: ParamsToArgs<DeleteVectorParams>): Promise<void> {
-    const params = this.normalizeArgs<DeleteVectorParams>('deleteVector', args);
-    const { indexName, id } = params;
+  async deleteVector({ indexName, id }: DeleteVectorParams): Promise<void> {
     try {
       await this.client.delete({
         index: indexName,
@@ -422,11 +418,19 @@ export class OpenSearchVector extends MastraVector {
         refresh: true,
       });
     } catch (error: unknown) {
-      console.error(`Failed to delete document with ID ${id} from index ${indexName}:`, error);
-      // Don't throw error if document doesn't exist, just log it
-      if (error && typeof error === 'object' && 'statusCode' in error && error.statusCode !== 404) {
-        throw error;
+      // Don't throw error if document doesn't exist (404)
+      if (error && typeof error === 'object' && 'statusCode' in error && error.statusCode === 404) {
+        return;
       }
+      throw new MastraError(
+        {
+          id: 'STORAGE_OPENSEARCH_VECTOR_DELETE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id },
+        },
+        error,
+      );
     }
   }
 }

package/src/vector/prompt.ts

@@ -0,0 +1,82 @@
+/**
+ * Vector store prompt for OpenSearch. This prompt details supported filter operators, syntax, and usage examples.
+ * Use this as a guide for constructing valid filters for OpenSearch vector queries in Mastra.
+ */
+export const OPENSEARCH_PROMPT = `When querying OpenSearch, you can ONLY use the operators listed below. Any other operators will be rejected.
+Important: Do not explain how to construct the filter—use the specified operators and fields to search the content and return relevant results.
+If a user tries to use an unsupported operator, reject the filter entirely and let them know that the operator is not supported.
+
+Basic Comparison Operators:
+- $eq: Exact match (default for field: value)
+  Example: { "category": "electronics" }
+- $ne: Not equal
+  Example: { "category": { "$ne": "electronics" } }
+- $gt: Greater than
+  Example: { "price": { "$gt": 100 } }
+- $gte: Greater than or equal
+  Example: { "price": { "$gte": 100 } }
+- $lt: Less than
+  Example: { "price": { "$lt": 100 } }
+- $lte: Less than or equal
+  Example: { "price": { "$lte": 100 } }
+
+Array Operators:
+- $in: Match any value in array
+  Example: { "category": { "$in": ["electronics", "books"] } }
+- $nin: Does not match any value in array
+  Example: { "category": { "$nin": ["electronics", "books"] } }
+- $all: Match all values in array
+  Example: { "tags": { "$all": ["premium", "sale"] } }
+
+Logical Operators:
+- $and: Logical AND (implicit when using multiple conditions)
+  Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
+- $or: Logical OR
+  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
+- $not: Logical NOT
+  Example: { "$not": { "category": "electronics" } }
+
+Element Operators:
+- $exists: Check if field exists
+  Example: { "rating": { "$exists": true } }
+
+Regex Operator:
+- $regex: Match using a regular expression (ECMAScript syntax)
+  Example: { "name": { "$regex": "^Sam.*son$" } }
+  Note: Regex queries are supported for string fields only. Use valid ECMAScript patterns; invalid patterns will throw an error.
+
+Restrictions:
+- Nested fields are supported using dot notation (e.g., "address.city").
+- Multiple conditions on the same field are supported (e.g., { "price": { "$gte": 100, "$lte": 1000 } }).
+- Only logical operators ($and, $or, $not) can be used at the top level.
+- All other operators must be used within a field condition.
+  Valid: { "field": { "$gt": 100 } }
+  Valid: { "$and": [...] }
+  Invalid: { "$gt": 100 }
+- Logical operators must contain field conditions, not direct operators.
+  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
+  Invalid: { "$and": [{ "$gt": 100 }] }
+- $not operator:
+  - Must be an object
+  - Cannot be empty
+  - Can be used at field level or top level
+  - Valid: { "$not": { "field": "value" } }
+  - Valid: { "field": { "$not": { "$eq": "value" } } }
+- Array operators work on array fields only.
+- Empty arrays in conditions are handled gracefully.
+- Regex queries are case-sensitive by default; use patterns accordingly.
+
+Example Complex Query:
+{
+  "$and": [
+    { "category": { "$in": ["electronics", "computers"] } },
+    { "price": { "$gte": 100, "$lte": 1000 } },
+    { "tags": { "$all": ["premium"] } },
+    { "rating": { "$exists": true, "$gt": 4 } },
+    { "$or": [
+      { "stock": { "$gt": 0 } },
+      { "preorder": true }
+    ]},
+    { "name": { "$regex": "^Sam.*son$" } }
+  ]
+}`;

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": ["./tsconfig.json", "../../tsconfig.build.json"],
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts", "src/**/*.mock.ts"]
+}

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
   "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "tsup.config.ts"],
   "exclude": ["node_modules", "**/*.test.ts"]
 }

package/tsup.config.ts

@@ -0,0 +1,17 @@
+import { generateTypes } from '@internal/types-builder';
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  clean: true,
+  dts: false,
+  splitting: true,
+  treeshake: {
+    preset: 'smallest',
+  },
+  sourcemap: true,
+  onSuccess: async () => {
+    await generateTypes(process.cwd());
+  },
+});