@upstash/vector 0.1.0-alpha → 0.1.0-alpha-2

package/README.md

@@ -1,15 +1,221 @@
-# vector-sdk
+# Upstash Vector Node.js Client
 
-To install dependencies:
+This is the official Node.js client for [Upstash](https://upstash.com/), written in TypeScript.
 
-```bash
-bun install
+## Documentation
+
+- [**Reference Documentation**](https://upstash.com/docs/vector/overall/getstarted)
+
+## Installation
+
+```
+npm install @upstash/vector
+pnpm add @upstash/vector
 ```
 
-To run:
+## Usage
+
+### Initializing the client
+
+There are two pieces of configuration required to use the Upstash vector client: an REST token and REST URL. These values can be passed using environment variables or in code through a configuration object. Find your configuration values in the console dashboard at [https://console.upstash.com/](https://console.upstash.com/).
+
+#### Using environment variables
+
+The environment variables used to configure the client are the following:
 
 ```bash
-bun run index.ts
+UPSTASH_VECTOR_REST_URL="your_rest_url"
+UPSTASH_VECTOR_REST_TOKEN="your_rest_token"
+```
+
+When these environment variables are set, the client constructor does not require any additional arguments.
+
+```typescript
+import { fromEnv } from "@upstash/vector";
+
+const index = fromEnv();
+```
+
+#### Using a configuration object
+
+If you prefer to pass configuration in code, the constructor accepts a config object containing the `url` and `token` values. This
+could be useful if your application needs to interact with multiple projects, each with a different configuration.
+
+```typescript
+import { Index } from "@upstash/vector";
+
+const index = new Index({
+  url: "<UPSTASH_VECTOR_REST_URL>",
+  token: "<UPSTASH_VECTOR_REST_TOKEN>",
+});
+```
+
+## Index operations
+
+Upstash vector indexes support operations for working with vector data using operations such as upsert, query, fetch, and delete.
+
+### Targeting an index
+
+To perform data operations on an index, you target it using the `index` method.
+
+```typescript
+const index = new Index();
+
+// Now perform index operations
+await index.fetch([1, 2, 3], { includeMetadata: true, includeVectors: true });
+```
+
+### Targeting an index, with metadata typing
+
+If you are storing metadata alongside your vector values, you can pass a type parameter to `index()` in order to get proper TypeScript typechecking.
+
+```typescript
+const index = new Index();
+
+type Metadata = {
+  title: string,
+  genre: 'sci-fi' | 'fantasy' | 'horror' | 'action'
+}
+
+await index.upsert([{
+  id: '1234',
+  vector: [
+    .... // embedding values
+  ],
+  metadata: {
+    title: 'Lord of The Rings',
+    genre: 'drama',
+    category: 'classic'
+  }
+}])
+
+const results = await index.query<Metadata>({
+  vector: [
+    ... // query embedding
+  ],
+  includeVectors: true,
+  topK: 1,
+})
+
+if (results[0].metadata) {
+  // Since we passed the Metadata type parameter above,
+  // we can interact with metadata fields without having to
+  // do any typecasting.
+  const { title, genre, category } = movie.metadata;
+  console.log(`The best match in fantasy was ${title}`)
+}
 ```
 
-This project was created using `bun init` in bun v1.0.4. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
+### Upsert records
+
+Upstash vector expects records inserted into indexes to have the following form:
+
+```typescript
+type UpstashRecord = {
+  id: number | string;
+  vector: number[];
+  metadata?: Record<string, unknown>;
+};
+```
+
+To upsert some records, you can use the client like so:
+
+```typescript
+const index = new Index();
+
+// Prepare your data. The length of each array
+// of vector values must match the dimension of
+// the index where you plan to store them.
+const records = [
+  {
+    id: "1",
+    vector: [0.236, 0.971, 0.559],
+  },
+  {
+    id: "2",
+    vector: [0.685, 0.111, 0.857],
+  },
+];
+
+// Upsert the data into your index
+await index.upsert(records);
+```
+
+### Querying
+
+#### Querying with vector values
+
+The query method accepts a large number of options. The dimension of the query vector must match the dimension of your index.
+
+```typescript
+type QueryOptions = {
+  vector: number[];
+  topK: number;
+  includeVectors?: boolean;
+  includeMetadata?: boolean;
+};
+```
+
+For example, to query by vector values you would pass the `vector` param in the options configuration. For brevity sake this example query vector is tiny (dimension 2), but in a more realistic use case this query vector would be an embedding outputted by a model. Look at the [Example code](#example-code) to see more realistic examples of how to use `query`.
+
+```typescript
+> await index.query({ topK: 3, vector: [ 0.22, 0.66 ]})
+{
+  matches: [
+    {
+      id: '6345',
+      score: 1.00000012,
+      vector: [],
+      metadata: undefined
+    },
+    {
+      id: '1233',
+      score: 1.00000012,
+      vector: [],
+      metadata: undefined
+    },
+    {
+      id: '4142',
+      score: 1.00000012,
+      vector: [],
+      metadata: undefined
+    }
+  ],
+  namespace: ''
+}
+```
+
+You include options to `includeMetadata: true` or `includeVectors: true` if you need this information. By default these are not returned to keep the response payload small.
+
+### Update a record
+
+You may want to update vector `vector` or `metadata`. Specify the id and the attribute value you want to update.
+
+```typescript
+await index.upsert({
+  id: "18593",
+  metadata: { genre: "romance" },
+});
+```
+
+### Fetch records by their IDs
+
+```typescript
+const fetchResult = await index.fetch(["id-1", "id-2"]);
+```
+
+### Delete records
+
+For convenience there are several delete-related options. You can verify the results of a delete operation by trying to `fetch()` a record.
+
+#### Delete one
+
+```typescript
+await index.delete("id-to-delete");
+```
+
+#### Delete many by id
+
+```typescript
+await index.delete(["id-1", "id-2", "id-3"]);
+```

package/dist/index.d.mts

@@ -42,12 +42,6 @@ type RequesterConfig = {
     cache?: CacheSetting;
 };
 
-type Vector<TMetadata> = {
-    id: string;
-    vector: number[];
-    metadata?: TMetadata;
-};
-
 declare const ENDPOINTS: readonly ["upsert", "query", "delete", "fetch", "reset", "range"];
 type EndpointVariants = (typeof ENDPOINTS)[number];
 /**
@@ -63,55 +57,17 @@ declare class Command<TResult> {
     exec(client: Requester): Promise<TResult>;
 }
 
-/**
- * Payload Type Definition for DeleteCommand
- *
- * This type defines the structure of the payload specifically used in the DeleteCommand.
- *
- * Properties:
- *  - ids: An array of numbers or strings representing the unique identifiers of the records to be deleted. These could be database IDs, unique keys, or any identifier used to uniquely refer to records in a specific context.
- *
- * Usage:
- * This type is typically used in scenarios where a batch deletion of records is required. The `ids` array allows specifying multiple records for deletion in a single command, thereby facilitating efficient bulk operations.
- */
-type Payload$4 = {
-    ids: number[] | string[];
-};
-/**
- * DeleteCommand Class
- *
- * This class extends the generic Command class to implement the deletion functionality.
- *
- * Example:
- *  ```
- *  const deletionIds = [123, 456, 789];
- *  const deleteCommand = new DeleteCommand({ ids: deletionIds });
- *  // Use deleteCommand to execute the deletion operation
- *  ```
- */
-declare class DeleteCommand extends Command<string> {
-    constructor(payload: Payload$4);
+declare class DeleteCommand extends Command<{
+    deleted: number;
+}> {
+    constructor(id: (number[] | string[]) | number | string);
 }
 
-/**
- * Payload Type Definition
- *
- * This type defines the structure of the payload used in a specific function or API call.
- *
- * Properties:
- *  - vector: An array of numbers representing a specific vector. This could be coordinates, data points, or any numerical representation depending on the context of the function or API.
- *
- *  - topK: A number indicating the 'top K' elements to be considered or returned. In many contexts, this refers to the top 'K' results, items, or entities based on certain criteria like highest score, most relevance, etc.
- *
- *  - includeVectors: A boolean value indicating whether to include the vector data in the response or output. Setting this to 'true' includes the vector data.
- *
- * Usage:
- * This type is typically used when sending or receiving data where a combination of a numerical vector, a limit on the number of elements to consider, and an option to include or exclude detailed vector data is required.
- */
-type Payload$3 = {
+type QueryCommandPayload = {
     vector: number[];
     topK: number;
-    includeVectors: boolean;
+    includeVectors?: boolean;
+    includeMetadata?: boolean;
 };
 type QueryReturnResponse<TMetadata> = {
     id: number | string;
@@ -119,141 +75,39 @@ type QueryReturnResponse<TMetadata> = {
     vector: number[];
     metadata?: TMetadata;
 };
-/**
- * QueryCommand Class
- * Example:
- *  ```
- *  const payload = { vector: [1, 2, 3], topK: 5, includeVectors: true };
- *  const queryCommand = new QueryCommand(payload);
- *  // Use queryCommand for further operations
- *  ```
- */
-declare class QueryCommand<TResult> extends Command<QueryReturnResponse<TResult>[]> {
-    constructor(payload: Payload$3);
+declare class QueryCommand<TMetadata> extends Command<QueryReturnResponse<TMetadata>[]> {
+    constructor(payload: QueryCommandPayload);
 }
 
-/**
- * Payload Type Definition for UpsertCommand
- *
- * This type defines the structure of the payload used in the UpsertCommand.
- *
- * Properties:
- *  - id: A number or string representing the unique identifier of the record to be upserted (inserted or updated).
- *  - vector: An array of numbers representing a specific vector. This could be coordinates, data points, or any numerical representation depending on the context.
- *  - metadata (optional): An object with key-value pairs, where the keys are strings and the values are of unknown type. This allows for flexible and additional data to be associated with the record being upserted.
- *
- * Usage:
- * This type is primarily used in scenarios where a record needs to be inserted into a database if it does not already exist, or updated if it does. The flexibility of the metadata field allows for various additional information to be passed along with the primary data.
- */
-type Payload$2 = {
+type UpsertCommandPayload = {
     id: number | string;
     vector: number[];
     metadata?: Record<string, unknown>;
 };
-/**
- * UpsertCommand Class
- *
- * Extends the generic Command class to implement an upsert (insert or update) operation.
- *
- * Example:
- *  ```
- *  const upsertPayload = { id: 123, vector: [1.1, 2.2, 3.3], metadata: { key: "value" } };
- *  const upsertCommand = new UpsertCommand(upsertPayload);
- *  // Use upsertCommand to execute the upsert operation
- *  ```
- *
- * The UpsertCommand takes a payload containing the necessary data for the upsert operation. It supports handling both insertion and update of records based on the provided identifier.
- */
 declare class UpsertCommand extends Command<string> {
-    constructor(payload: Payload$2);
+    constructor(payload: UpsertCommandPayload | UpsertCommandPayload[]);
 }
 
-/**
- * Type definition for FetchCommand payload
- *
- * Properties:
- *  - ids: An array of numbers or strings, representing the unique identifiers of the records to be fetched.
- *  - includeMetadata (optional): A boolean flag indicating whether to include metadata in the response.
- *  - includeVectors (optional): A boolean flag indicating whether to include vector data in the response.
- *
- * The Payload type is used in the FetchCommand to specify the data required to fetch specific records.
- * The optional flags allow for more detailed responses depending on the requirements.
- */
-type Payload$1 = {
-    ids: number[] | string[];
-    includeMetadata?: boolean;
-    includeVectors?: boolean;
+type Vector<TMetadata> = {
+    id: string;
+    vector: number[];
+    metadata?: TMetadata;
 };
-/**
- * Generic response type for FetchCommand
- *
- * This type represents the possible return type of a FetchCommand. It can be either a Vector
- * containing metadata or null, depending on whether the fetch operation was successful or not.
- */
+
 type FetchReturnResponse<TMetadata> = Vector<TMetadata> | null;
-/**
- * FetchCommand Class
- *
- * Extends the generic Command class to implement a fetch operation.
- *
- * Example:
- *  ```
- *  const fetchPayload = { ids: [1, 2, 3], includeMetadata: true };
- *  const fetchCommand = new FetchCommand(fetchPayload);
- *  // Use fetchCommand to execute the fetch operation
- *  ```
- */
-declare class FetchCommand<TMetadata> extends Command<FetchReturnResponse<TMetadata>[]> {
-    constructor(payload: Payload$1);
-}
 
-/**
- * Type definition for RangeCommand payload
- *
- * This type specifies the structure of the payload used in the RangeCommand.
- *
- * Properties:
- *  - cursor: A number indicating the starting point for the range query.
- *  - limit: A number specifying the maximum number of records to be returned.
- *  - includeVectors (optional): A boolean flag indicating whether to include vector data in the response.
- *  - includeMetadata (optional): A boolean flag indicating whether to include metadata in the response.
- *
- * This payload type is used for range queries, where a set of records is retrieved based on the specified cursor
- * and limit. The optional inclusion of vectors and metadata allows for flexible and detailed data retrieval.
- */
-type Payload = {
-    cursor: number;
+type RangeCommandPayload = {
+    cursor: number | string;
     limit: number;
     includeVectors?: boolean;
     includeMetadata?: boolean;
 };
-/**
- * Type definition for the response returned by RangeCommand
- *
- * This type outlines the structure of the response from a RangeCommand.
- *
- * Properties:
- *  - nextCursor: A string that indicates the cursor to be used for the next range query, facilitating pagination.
- *  - vectors: An array of Vector objects, each containing TMetadata, representing the data retrieved in the range query.
- *
- * The RangeReturnResponse type is crucial for operations that involve retrieving a range of records,
- * providing both the data (in the form of vectors) and the means to continue fetching subsequent ranges (via nextCursor).
- */
 type RangeReturnResponse<TMetadata> = {
     nextCursor: string;
     vectors: Vector<TMetadata>[];
 };
-/**
- * RangeCommand Class
- * Example:
- *  ```
- *  const rangePayload = { cursor: 0, limit: 10, includeVectors: true };
- *  const rangeCommand = new RangeCommand(rangePayload);
- *  // Use rangeCommand to execute the range query and retrieve data
- *  ```
- */
-declare class RangeCommand<TResult> extends Command<RangeReturnResponse<TResult>> {
-    constructor(payload: Payload);
+declare class RangeCommand<TMetadata> extends Command<RangeReturnResponse<TMetadata>> {
+    constructor(payload: RangeCommandPayload);
 }
 
 type CommandArgs<TCommand extends new (_args: any) => any> = ConstructorParameters<TCommand>[0];
@@ -274,27 +128,129 @@ declare class Index$1 {
      * ```
      */
     constructor(client: Requester);
-    delete: (args: CommandArgs<typeof DeleteCommand>) => Promise<string>;
-    query: (args: CommandArgs<typeof QueryCommand>) => Promise<{
-        id: string | number;
-        score: number;
-        vector: number[];
-        metadata?: unknown;
-    }[]>;
+    /**
+     * Deletes a specific item or items from the index by their ID(s).   *
+     *
+     * @example
+     * ```js
+     * await index.delete('test-id')
+     * ```
+     *
+     * @param id - List of ids or single id
+     * @returns A promise that resolves when the request to delete the index is completed.
+     */
+    delete: (args: CommandArgs<typeof DeleteCommand>) => Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Queries an index with specified parameters.
+     * This method creates and executes a query command on an index based on the provided arguments.
+     *
+     * @example
+     * ```js
+     * await index.query({ topK: 3, vector: [ 0.22, 0.66 ]})
+     * ```
+     *
+     * @param {Object} args - The arguments for the query command.
+     * @param {number[]} args.vector - An array of numbers representing the feature vector for the query.
+     *                                This vector is utilized to find the most relevant items in the index.
+     * @param {number} args.topK - The desired number of top results to be returned, based on relevance or similarity to the query vector.
+     * @param {boolean} [args.includeVectors=false] - When set to true, includes the feature vectors of the returned items in the response.
+     * @param {boolean} [args.includeMetadata=false] - When set to true, includes additional metadata of the returned items in the response.
+     *
+     * @returns A promise that resolves with an array of query result objects when the request to query the index is completed.
+     */
+    query: (args: CommandArgs<typeof QueryCommand>) => Promise<QueryReturnResponse<unknown>[]>;
+    /**
+     * Upserts (Updates and Inserts) specific items into the index.
+     * It's used for adding new items to the index or updating existing ones.
+     *
+     * @example
+     * ```js
+     * const upsertArgs = {
+     *   id: '123',
+     *   vector: [0.42, 0.87, ...],
+     *   metadata: { property1: 'value1', property2: 'value2' }
+     * };
+     * const upsertResult = await index.upsert(upsertArgs);
+     * console.log(upsertResult); // Outputs the result of the upsert operation
+     * ```
+     *
+     * @param {CommandArgs<typeof UpsertCommand>} args - The arguments for the upsert command.
+     * @param {number|string} args.id - The unique identifier for the item being upserted.
+     * @param {number[]} args.vector - The feature vector associated with the item.
+     * @param {Record<string, unknown>} [args.metadata] - Optional metadata to be associated with the item.
+     *
+     * @returns {string} A promise that resolves with the result of the upsert operation after the command is executed.
+     */
     upsert: (args: CommandArgs<typeof UpsertCommand>) => Promise<string>;
-    fetch: (args: CommandArgs<typeof FetchCommand>) => Promise<(Vector<unknown> | null)[]>;
+    /**
+     * It's used for retrieving specific items from the index, optionally including
+     * their metadata and feature vectors.
+     *
+     * @example
+     * ```js
+     * const fetchIds = ['123', '456'];
+     * const fetchOptions = { includeMetadata: true, includeVectors: false };
+     * const fetchResults = await index.fetch(fetchIds, fetchOptions);
+     * console.log(fetchResults); // Outputs the fetched items
+     * ```
+     *
+     * @param {...CommandArgs<typeof FetchCommand>} args - The arguments for the fetch command.
+     * @param {(number[]|string[])} args[0] - An array of IDs of the items to be fetched.
+     * @param {FetchCommandOptions} args[1] - Options for the fetch operation.
+     * @param {boolean} [args[1].includeMetadata=false] - Optionally include metadata of the fetched items.
+     * @param {boolean} [args[1].includeVectors=false] - Optionally include feature vectors of the fetched items.
+     *
+     * @returns {Promise<FetchReturnResponse<TMetadata>[]>} A promise that resolves with an array of fetched items or null if not found, after the command is executed.
+     */
+    fetch: (ids: string[] | number[], opts: {
+        includeMetadata?: boolean | undefined;
+        includeVectors?: boolean | undefined;
+    }) => Promise<FetchReturnResponse<unknown>[]>;
+    /**
+     * It's used for wiping an entire index.
+     *
+     * @example
+     * ```js
+     * await index.reset();
+     * console.log('Index has been reset');
+     * ```
+     *
+     * @returns {Promise<string>} A promise that resolves with the result of the reset operation after the command is executed.
+     */
     reset: () => Promise<string>;
-    range: (args: CommandArgs<typeof RangeCommand>) => Promise<{
-        nextCursor: string;
-        vectors: Vector<unknown>[];
-    }>;
+    /**
+     * Retrieves a range of items from the index.
+     *
+     * @example
+     * ```js
+     * const rangeArgs = {
+     *   cursor: 0,
+     *   limit: 10,
+     *   includeVectors: true,
+     *   includeMetadata: false
+     * };
+     * const rangeResults = await index.range(rangeArgs);
+     * console.log(rangeResults); // Outputs the result of the range operation
+     * ```
+     *
+     * @param {CommandArgs<typeof RangeCommand>} args - The arguments for the range command.
+     * @param {number|string} args.cursor - The starting point (cursor) for the range query.
+     * @param {number} args.limit - The maximum number of items to return in this range.
+     * @param {boolean} [args.includeVectors=false] - Optionally include the feature vectors of the items in the response.
+     * @param {boolean} [args.includeMetadata=false] - Optionally include additional metadata of the items in the response.
+     *
+     * @returns {Promise<RangeReturnResponse<TMetadata>>} A promise that resolves with the response containing the next cursor and an array of vectors, after the command is executed.
+     */
+    range: (args: CommandArgs<typeof RangeCommand>) => Promise<RangeReturnResponse<unknown>>;
 }
 
 /**
  * Connection credentials for upstash vector.
  * Get them from https://console.upstash.com/vector/<uuid>
  */
-type VectorConfig = {
+type IndexConfig = {
     /**
      * UPSTASH_VECTOR_REST_URL
      */
@@ -318,13 +274,13 @@ declare class Index extends Index$1 {
      *
      * @example
      * ```typescript
-     * const vector = new Vector({
+     * const index = new Index({
      *  url: "<UPSTASH_VECTOR_REST_URL>",
      *  token: "<UPSTASH_VECTOR_REST_TOKEN>",
      * });
      * ```
      */
-    constructor(config: VectorConfig);
+    constructor(config: IndexConfig);
     /**
      * Create a new vector client by providing a custom `Requester` implementation
      *
@@ -352,7 +308,7 @@ declare class Index extends Index$1 {
      * This tries to load `UPSTASH_VECTOR_REST_URL` and `UPSTASH_VECTOR_REST_TOKEN` from
      * your environment using `process.env`.
      */
-    static fromEnv(config?: Omit<VectorConfig, "url" | "token">): Index;
+    static fromEnv(config?: Omit<IndexConfig, "url" | "token">): Index;
 }
 
-export { Index, type Requester, type UpstashRequest, type UpstashResponse, type VectorConfig };
+export { Index, type IndexConfig, type Requester, type UpstashRequest, type UpstashResponse };

package/dist/index.d.ts

@@ -42,12 +42,6 @@ type RequesterConfig = {
     cache?: CacheSetting;
 };
 
-type Vector<TMetadata> = {
-    id: string;
-    vector: number[];
-    metadata?: TMetadata;
-};
-
 declare const ENDPOINTS: readonly ["upsert", "query", "delete", "fetch", "reset", "range"];
 type EndpointVariants = (typeof ENDPOINTS)[number];
 /**
@@ -63,55 +57,17 @@ declare class Command<TResult> {
     exec(client: Requester): Promise<TResult>;
 }
 
-/**
- * Payload Type Definition for DeleteCommand
- *
- * This type defines the structure of the payload specifically used in the DeleteCommand.
- *
- * Properties:
- *  - ids: An array of numbers or strings representing the unique identifiers of the records to be deleted. These could be database IDs, unique keys, or any identifier used to uniquely refer to records in a specific context.
- *
- * Usage:
- * This type is typically used in scenarios where a batch deletion of records is required. The `ids` array allows specifying multiple records for deletion in a single command, thereby facilitating efficient bulk operations.
- */
-type Payload$4 = {
-    ids: number[] | string[];
-};
-/**
- * DeleteCommand Class
- *
- * This class extends the generic Command class to implement the deletion functionality.
- *
- * Example:
- *  ```
- *  const deletionIds = [123, 456, 789];
- *  const deleteCommand = new DeleteCommand({ ids: deletionIds });
- *  // Use deleteCommand to execute the deletion operation
- *  ```
- */
-declare class DeleteCommand extends Command<string> {
-    constructor(payload: Payload$4);
+declare class DeleteCommand extends Command<{
+    deleted: number;
+}> {
+    constructor(id: (number[] | string[]) | number | string);
 }
 
-/**
- * Payload Type Definition
- *
- * This type defines the structure of the payload used in a specific function or API call.
- *
- * Properties:
- *  - vector: An array of numbers representing a specific vector. This could be coordinates, data points, or any numerical representation depending on the context of the function or API.
- *
- *  - topK: A number indicating the 'top K' elements to be considered or returned. In many contexts, this refers to the top 'K' results, items, or entities based on certain criteria like highest score, most relevance, etc.
- *
- *  - includeVectors: A boolean value indicating whether to include the vector data in the response or output. Setting this to 'true' includes the vector data.
- *
- * Usage:
- * This type is typically used when sending or receiving data where a combination of a numerical vector, a limit on the number of elements to consider, and an option to include or exclude detailed vector data is required.
- */
-type Payload$3 = {
+type QueryCommandPayload = {
     vector: number[];
     topK: number;
-    includeVectors: boolean;
+    includeVectors?: boolean;
+    includeMetadata?: boolean;
 };
 type QueryReturnResponse<TMetadata> = {
     id: number | string;
@@ -119,141 +75,39 @@ type QueryReturnResponse<TMetadata> = {
     vector: number[];
     metadata?: TMetadata;
 };
-/**
- * QueryCommand Class
- * Example:
- *  ```
- *  const payload = { vector: [1, 2, 3], topK: 5, includeVectors: true };
- *  const queryCommand = new QueryCommand(payload);
- *  // Use queryCommand for further operations
- *  ```
- */
-declare class QueryCommand<TResult> extends Command<QueryReturnResponse<TResult>[]> {
-    constructor(payload: Payload$3);
+declare class QueryCommand<TMetadata> extends Command<QueryReturnResponse<TMetadata>[]> {
+    constructor(payload: QueryCommandPayload);
 }
 
-/**
- * Payload Type Definition for UpsertCommand
- *
- * This type defines the structure of the payload used in the UpsertCommand.
- *
- * Properties:
- *  - id: A number or string representing the unique identifier of the record to be upserted (inserted or updated).
- *  - vector: An array of numbers representing a specific vector. This could be coordinates, data points, or any numerical representation depending on the context.
- *  - metadata (optional): An object with key-value pairs, where the keys are strings and the values are of unknown type. This allows for flexible and additional data to be associated with the record being upserted.
- *
- * Usage:
- * This type is primarily used in scenarios where a record needs to be inserted into a database if it does not already exist, or updated if it does. The flexibility of the metadata field allows for various additional information to be passed along with the primary data.
- */
-type Payload$2 = {
+type UpsertCommandPayload = {
     id: number | string;
     vector: number[];
     metadata?: Record<string, unknown>;
 };
-/**
- * UpsertCommand Class
- *
- * Extends the generic Command class to implement an upsert (insert or update) operation.
- *
- * Example:
- *  ```
- *  const upsertPayload = { id: 123, vector: [1.1, 2.2, 3.3], metadata: { key: "value" } };
- *  const upsertCommand = new UpsertCommand(upsertPayload);
- *  // Use upsertCommand to execute the upsert operation
- *  ```
- *
- * The UpsertCommand takes a payload containing the necessary data for the upsert operation. It supports handling both insertion and update of records based on the provided identifier.
- */
 declare class UpsertCommand extends Command<string> {
-    constructor(payload: Payload$2);
+    constructor(payload: UpsertCommandPayload | UpsertCommandPayload[]);
 }
 
-/**
- * Type definition for FetchCommand payload
- *
- * Properties:
- *  - ids: An array of numbers or strings, representing the unique identifiers of the records to be fetched.
- *  - includeMetadata (optional): A boolean flag indicating whether to include metadata in the response.
- *  - includeVectors (optional): A boolean flag indicating whether to include vector data in the response.
- *
- * The Payload type is used in the FetchCommand to specify the data required to fetch specific records.
- * The optional flags allow for more detailed responses depending on the requirements.
- */
-type Payload$1 = {
-    ids: number[] | string[];
-    includeMetadata?: boolean;
-    includeVectors?: boolean;
+type Vector<TMetadata> = {
+    id: string;
+    vector: number[];
+    metadata?: TMetadata;
 };
-/**
- * Generic response type for FetchCommand
- *
- * This type represents the possible return type of a FetchCommand. It can be either a Vector
- * containing metadata or null, depending on whether the fetch operation was successful or not.
- */
+
 type FetchReturnResponse<TMetadata> = Vector<TMetadata> | null;
-/**
- * FetchCommand Class
- *
- * Extends the generic Command class to implement a fetch operation.
- *
- * Example:
- *  ```
- *  const fetchPayload = { ids: [1, 2, 3], includeMetadata: true };
- *  const fetchCommand = new FetchCommand(fetchPayload);
- *  // Use fetchCommand to execute the fetch operation
- *  ```
- */
-declare class FetchCommand<TMetadata> extends Command<FetchReturnResponse<TMetadata>[]> {
-    constructor(payload: Payload$1);
-}
 
-/**
- * Type definition for RangeCommand payload
- *
- * This type specifies the structure of the payload used in the RangeCommand.
- *
- * Properties:
- *  - cursor: A number indicating the starting point for the range query.
- *  - limit: A number specifying the maximum number of records to be returned.
- *  - includeVectors (optional): A boolean flag indicating whether to include vector data in the response.
- *  - includeMetadata (optional): A boolean flag indicating whether to include metadata in the response.
- *
- * This payload type is used for range queries, where a set of records is retrieved based on the specified cursor
- * and limit. The optional inclusion of vectors and metadata allows for flexible and detailed data retrieval.
- */
-type Payload = {
-    cursor: number;
+type RangeCommandPayload = {
+    cursor: number | string;
     limit: number;
     includeVectors?: boolean;
     includeMetadata?: boolean;
 };
-/**
- * Type definition for the response returned by RangeCommand
- *
- * This type outlines the structure of the response from a RangeCommand.
- *
- * Properties:
- *  - nextCursor: A string that indicates the cursor to be used for the next range query, facilitating pagination.
- *  - vectors: An array of Vector objects, each containing TMetadata, representing the data retrieved in the range query.
- *
- * The RangeReturnResponse type is crucial for operations that involve retrieving a range of records,
- * providing both the data (in the form of vectors) and the means to continue fetching subsequent ranges (via nextCursor).
- */
 type RangeReturnResponse<TMetadata> = {
     nextCursor: string;
     vectors: Vector<TMetadata>[];
 };
-/**
- * RangeCommand Class
- * Example:
- *  ```
- *  const rangePayload = { cursor: 0, limit: 10, includeVectors: true };
- *  const rangeCommand = new RangeCommand(rangePayload);
- *  // Use rangeCommand to execute the range query and retrieve data
- *  ```
- */
-declare class RangeCommand<TResult> extends Command<RangeReturnResponse<TResult>> {
-    constructor(payload: Payload);
+declare class RangeCommand<TMetadata> extends Command<RangeReturnResponse<TMetadata>> {
+    constructor(payload: RangeCommandPayload);
 }
 
 type CommandArgs<TCommand extends new (_args: any) => any> = ConstructorParameters<TCommand>[0];
@@ -274,27 +128,129 @@ declare class Index$1 {
      * ```
      */
     constructor(client: Requester);
-    delete: (args: CommandArgs<typeof DeleteCommand>) => Promise<string>;
-    query: (args: CommandArgs<typeof QueryCommand>) => Promise<{
-        id: string | number;
-        score: number;
-        vector: number[];
-        metadata?: unknown;
-    }[]>;
+    /**
+     * Deletes a specific item or items from the index by their ID(s).   *
+     *
+     * @example
+     * ```js
+     * await index.delete('test-id')
+     * ```
+     *
+     * @param id - List of ids or single id
+     * @returns A promise that resolves when the request to delete the index is completed.
+     */
+    delete: (args: CommandArgs<typeof DeleteCommand>) => Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Queries an index with specified parameters.
+     * This method creates and executes a query command on an index based on the provided arguments.
+     *
+     * @example
+     * ```js
+     * await index.query({ topK: 3, vector: [ 0.22, 0.66 ]})
+     * ```
+     *
+     * @param {Object} args - The arguments for the query command.
+     * @param {number[]} args.vector - An array of numbers representing the feature vector for the query.
+     *                                This vector is utilized to find the most relevant items in the index.
+     * @param {number} args.topK - The desired number of top results to be returned, based on relevance or similarity to the query vector.
+     * @param {boolean} [args.includeVectors=false] - When set to true, includes the feature vectors of the returned items in the response.
+     * @param {boolean} [args.includeMetadata=false] - When set to true, includes additional metadata of the returned items in the response.
+     *
+     * @returns A promise that resolves with an array of query result objects when the request to query the index is completed.
+     */
+    query: (args: CommandArgs<typeof QueryCommand>) => Promise<QueryReturnResponse<unknown>[]>;
+    /**
+     * Upserts (Updates and Inserts) specific items into the index.
+     * It's used for adding new items to the index or updating existing ones.
+     *
+     * @example
+     * ```js
+     * const upsertArgs = {
+     *   id: '123',
+     *   vector: [0.42, 0.87, ...],
+     *   metadata: { property1: 'value1', property2: 'value2' }
+     * };
+     * const upsertResult = await index.upsert(upsertArgs);
+     * console.log(upsertResult); // Outputs the result of the upsert operation
+     * ```
+     *
+     * @param {CommandArgs<typeof UpsertCommand>} args - The arguments for the upsert command.
+     * @param {number|string} args.id - The unique identifier for the item being upserted.
+     * @param {number[]} args.vector - The feature vector associated with the item.
+     * @param {Record<string, unknown>} [args.metadata] - Optional metadata to be associated with the item.
+     *
+     * @returns {string} A promise that resolves with the result of the upsert operation after the command is executed.
+     */
     upsert: (args: CommandArgs<typeof UpsertCommand>) => Promise<string>;
-    fetch: (args: CommandArgs<typeof FetchCommand>) => Promise<(Vector<unknown> | null)[]>;
+    /**
+     * It's used for retrieving specific items from the index, optionally including
+     * their metadata and feature vectors.
+     *
+     * @example
+     * ```js
+     * const fetchIds = ['123', '456'];
+     * const fetchOptions = { includeMetadata: true, includeVectors: false };
+     * const fetchResults = await index.fetch(fetchIds, fetchOptions);
+     * console.log(fetchResults); // Outputs the fetched items
+     * ```
+     *
+     * @param {...CommandArgs<typeof FetchCommand>} args - The arguments for the fetch command.
+     * @param {(number[]|string[])} args[0] - An array of IDs of the items to be fetched.
+     * @param {FetchCommandOptions} args[1] - Options for the fetch operation.
+     * @param {boolean} [args[1].includeMetadata=false] - Optionally include metadata of the fetched items.
+     * @param {boolean} [args[1].includeVectors=false] - Optionally include feature vectors of the fetched items.
+     *
+     * @returns {Promise<FetchReturnResponse<TMetadata>[]>} A promise that resolves with an array of fetched items or null if not found, after the command is executed.
+     */
+    fetch: (ids: string[] | number[], opts: {
+        includeMetadata?: boolean | undefined;
+        includeVectors?: boolean | undefined;
+    }) => Promise<FetchReturnResponse<unknown>[]>;
+    /**
+     * It's used for wiping an entire index.
+     *
+     * @example
+     * ```js
+     * await index.reset();
+     * console.log('Index has been reset');
+     * ```
+     *
+     * @returns {Promise<string>} A promise that resolves with the result of the reset operation after the command is executed.
+     */
     reset: () => Promise<string>;
-    range: (args: CommandArgs<typeof RangeCommand>) => Promise<{
-        nextCursor: string;
-        vectors: Vector<unknown>[];
-    }>;
+    /**
+     * Retrieves a range of items from the index.
+     *
+     * @example
+     * ```js
+     * const rangeArgs = {
+     *   cursor: 0,
+     *   limit: 10,
+     *   includeVectors: true,
+     *   includeMetadata: false
+     * };
+     * const rangeResults = await index.range(rangeArgs);
+     * console.log(rangeResults); // Outputs the result of the range operation
+     * ```
+     *
+     * @param {CommandArgs<typeof RangeCommand>} args - The arguments for the range command.
+     * @param {number|string} args.cursor - The starting point (cursor) for the range query.
+     * @param {number} args.limit - The maximum number of items to return in this range.
+     * @param {boolean} [args.includeVectors=false] - Optionally include the feature vectors of the items in the response.
+     * @param {boolean} [args.includeMetadata=false] - Optionally include additional metadata of the items in the response.
+     *
+     * @returns {Promise<RangeReturnResponse<TMetadata>>} A promise that resolves with the response containing the next cursor and an array of vectors, after the command is executed.
+     */
+    range: (args: CommandArgs<typeof RangeCommand>) => Promise<RangeReturnResponse<unknown>>;
 }
 
 /**
  * Connection credentials for upstash vector.
  * Get them from https://console.upstash.com/vector/<uuid>
  */
-type VectorConfig = {
+type IndexConfig = {
     /**
      * UPSTASH_VECTOR_REST_URL
      */
@@ -318,13 +274,13 @@ declare class Index extends Index$1 {
      *
      * @example
      * ```typescript
-     * const vector = new Vector({
+     * const index = new Index({
      *  url: "<UPSTASH_VECTOR_REST_URL>",
      *  token: "<UPSTASH_VECTOR_REST_TOKEN>",
      * });
      * ```
      */
-    constructor(config: VectorConfig);
+    constructor(config: IndexConfig);
     /**
      * Create a new vector client by providing a custom `Requester` implementation
      *
@@ -352,7 +308,7 @@ declare class Index extends Index$1 {
      * This tries to load `UPSTASH_VECTOR_REST_URL` and `UPSTASH_VECTOR_REST_TOKEN` from
      * your environment using `process.env`.
      */
-    static fromEnv(config?: Omit<VectorConfig, "url" | "token">): Index;
+    static fromEnv(config?: Omit<IndexConfig, "url" | "token">): Index;
 }
 
-export { Index, type Requester, type UpstashRequest, type UpstashResponse, type VectorConfig };
+export { Index, type IndexConfig, type Requester, type UpstashRequest, type UpstashResponse };

package/dist/index.js

@@ -1,5 +1,5 @@
 'use strict';
 
-var n=class extends Error{constructor(e){super(e),this.name="UpstashError";}};var i=class{baseUrl;headers;options;retry;constructor(e){this.options={cache:e.cache,signal:e.signal},this.baseUrl=e.baseUrl.replace(/\/$/,""),this.headers={"Content-Type":"application/json",...e.headers},typeof e?.retry=="boolean"&&e?.retry===!1?this.retry={attempts:1,backoff:()=>0}:this.retry={attempts:e?.retry?.retries??5,backoff:e?.retry?.backoff??(s=>Math.exp(s)*50)};}async request(e){let s={cache:this.options.cache,method:"POST",headers:this.headers,body:JSON.stringify(e.body),keepalive:!0,signal:this.options.signal},o=null,f=null;for(let y=0;y<=this.retry.attempts;y++)try{o=await fetch([this.baseUrl,...e.path??[]].join("/"),s);break}catch(g){if(this.options.signal?.aborted){let R=new Blob([JSON.stringify({result:this.options.signal.reason??"Aborted"})]),T={status:200,statusText:this.options.signal.reason??"Aborted"};o=new Response(R,T);break}f=g,await new Promise(R=>setTimeout(R,this.retry.backoff(y)));}if(!o)throw f??new Error("Exhausted all retries");let a=await o.json();if(x(a)){if(!o.ok)throw new n(`${a.error}, command was: ${JSON.stringify(e.body)}`);return a}return {result:a}}};function x(t){return t&&typeof t=="object"&&("result"in t||"error"in t)}var r=class{payload;endpoint;constructor(e,s){this.payload=e,this.endpoint=s;}async exec(e){let{result:s,error:o}=await e.request({body:this.payload,path:[this.endpoint]});if(o)throw new n(o);if(typeof s>"u")throw new Error("Request did not return a result");return s}};var p=class extends r{constructor(e){super(e.ids,"delete");}};var l=class extends r{constructor(e){super({...e},"query");}};var u=class extends r{constructor(e){super({...e},"upsert");}};var c=class extends r{constructor(e){super({...e},"fetch");}};var m=class extends r{constructor(e){super(e,"range");}};var d=class extends r{constructor(){super([],"reset");}};var h=class{client;constructor(e){this.client=e;}delete=e=>new p(e).exec(this.client);query=e=>new l(e).exec(this.client);upsert=e=>new u(e).exec(this.client);fetch=e=>new c(e).exec(this.client);reset=()=>new d().exec(this.client);range=e=>new m(e).exec(this.client)};var b=class t extends h{constructor(e){if("request"in e){super(e);return}(e.url.startsWith(" ")||e.url.endsWith(" ")||/\r|\n/.test(e.url))&&console.warn("The vector url contains whitespace or newline, which can cause errors!"),(e.token.startsWith(" ")||e.token.endsWith(" ")||/\r|\n/.test(e.token))&&console.warn("The vector token contains whitespace or newline, which can cause errors!");let s=new i({baseUrl:e.url,retry:e.retry,headers:{authorization:`Bearer ${e.token}`},cache:e.cache||"no-store",signal:e.signal});super(s);}static fromEnv(e){let s=process?.env.UPSTASH_VECTOR_REST_URL;if(!s)throw new Error("Unable to find environment variable: `UPSTASH_VECTOR_REST_URL`");let o=process?.env.UPSTASH_VECTOR_REST_TOKEN;if(!o)throw new Error("Unable to find environment variable: `UPSTASH_VECTOR_REST_TOKEN`");return new t({...e,url:s,token:o})}};
+var n=class extends Error{constructor(e){super(e),this.name="UpstashError";}};var a=class{baseUrl;headers;options;retry;constructor(e){this.options={cache:e.cache,signal:e.signal},this.baseUrl=e.baseUrl.replace(/\/$/,""),this.headers={"Content-Type":"application/json",...e.headers},typeof e?.retry=="boolean"&&e?.retry===!1?this.retry={attempts:1,backoff:()=>0}:this.retry={attempts:e?.retry?.retries??5,backoff:e?.retry?.backoff??(t=>Math.exp(t)*50)};}async request(e){let t={cache:this.options.cache,method:"POST",headers:this.headers,body:JSON.stringify(e.body),keepalive:!0,signal:this.options.signal},o=null,f=null;for(let y=0;y<=this.retry.attempts;y++)try{o=await fetch([this.baseUrl,...e.path??[]].join("/"),t);break}catch(g){if(this.options.signal?.aborted){let b=new Blob([JSON.stringify({result:this.options.signal.reason??"Aborted"})]),x={status:200,statusText:this.options.signal.reason??"Aborted"};o=new Response(b,x);break}f=g,await new Promise(b=>setTimeout(b,this.retry.backoff(y)));}if(!o)throw f??new Error("Exhausted all retries");let h=await o.json();if(!o.ok)throw new n(`${h.error}, command was: ${JSON.stringify(e.body)}`);return {result:h.result,error:h.error}}};var r=class{payload;endpoint;constructor(e,t){this.payload=e,this.endpoint=t;}async exec(e){let{result:t,error:o}=await e.request({body:this.payload,path:[this.endpoint]});if(o)throw new n(o);if(typeof t>"u")throw new Error("Request did not return a result");return t}};var i=class extends r{constructor(e){let t=[];Array.isArray(e)?t.push(...e):t.push(e),super(t,"delete");}};var p=class extends r{constructor(e){super(e,"query");}};var c=class extends r{constructor(e){super(e,"upsert");}};var u=class extends r{constructor([e,t]){super({ids:e,...t},"fetch");}};var l=class extends r{constructor(e){super(e,"range");}};var m=class extends r{constructor(){super([],"reset");}};var d=class{client;constructor(e){this.client=e;}delete=e=>new i(e).exec(this.client);query=e=>new p(e).exec(this.client);upsert=e=>new c(e).exec(this.client);fetch=(...e)=>new u(e).exec(this.client);reset=()=>new m().exec(this.client);range=e=>new l(e).exec(this.client)};var R=class s extends d{constructor(e){if("request"in e){super(e);return}(e.url.startsWith(" ")||e.url.endsWith(" ")||/\r|\n/.test(e.url))&&console.warn("The vector url contains whitespace or newline, which can cause errors!"),(e.token.startsWith(" ")||e.token.endsWith(" ")||/\r|\n/.test(e.token))&&console.warn("The vector token contains whitespace or newline, which can cause errors!");let t=new a({baseUrl:e.url,retry:e.retry,headers:{authorization:`Bearer ${e.token}`},cache:e.cache||"no-store",signal:e.signal});super(t);}static fromEnv(e){let t=process?.env.UPSTASH_VECTOR_REST_URL;if(!t)throw new Error("Unable to find environment variable: `UPSTASH_VECTOR_REST_URL`");let o=process?.env.UPSTASH_VECTOR_REST_TOKEN;if(!o)throw new Error("Unable to find environment variable: `UPSTASH_VECTOR_REST_TOKEN`");return new s({...e,url:t,token:o})}};
 
-exports.Index = b;
+exports.Index = R;

package/dist/index.mjs

@@ -1,3 +1,3 @@
-var n=class extends Error{constructor(e){super(e),this.name="UpstashError";}};var i=class{baseUrl;headers;options;retry;constructor(e){this.options={cache:e.cache,signal:e.signal},this.baseUrl=e.baseUrl.replace(/\/$/,""),this.headers={"Content-Type":"application/json",...e.headers},typeof e?.retry=="boolean"&&e?.retry===!1?this.retry={attempts:1,backoff:()=>0}:this.retry={attempts:e?.retry?.retries??5,backoff:e?.retry?.backoff??(s=>Math.exp(s)*50)};}async request(e){let s={cache:this.options.cache,method:"POST",headers:this.headers,body:JSON.stringify(e.body),keepalive:!0,signal:this.options.signal},o=null,f=null;for(let y=0;y<=this.retry.attempts;y++)try{o=await fetch([this.baseUrl,...e.path??[]].join("/"),s);break}catch(g){if(this.options.signal?.aborted){let R=new Blob([JSON.stringify({result:this.options.signal.reason??"Aborted"})]),T={status:200,statusText:this.options.signal.reason??"Aborted"};o=new Response(R,T);break}f=g,await new Promise(R=>setTimeout(R,this.retry.backoff(y)));}if(!o)throw f??new Error("Exhausted all retries");let a=await o.json();if(x(a)){if(!o.ok)throw new n(`${a.error}, command was: ${JSON.stringify(e.body)}`);return a}return {result:a}}};function x(t){return t&&typeof t=="object"&&("result"in t||"error"in t)}var r=class{payload;endpoint;constructor(e,s){this.payload=e,this.endpoint=s;}async exec(e){let{result:s,error:o}=await e.request({body:this.payload,path:[this.endpoint]});if(o)throw new n(o);if(typeof s>"u")throw new Error("Request did not return a result");return s}};var p=class extends r{constructor(e){super(e.ids,"delete");}};var l=class extends r{constructor(e){super({...e},"query");}};var u=class extends r{constructor(e){super({...e},"upsert");}};var c=class extends r{constructor(e){super({...e},"fetch");}};var m=class extends r{constructor(e){super(e,"range");}};var d=class extends r{constructor(){super([],"reset");}};var h=class{client;constructor(e){this.client=e;}delete=e=>new p(e).exec(this.client);query=e=>new l(e).exec(this.client);upsert=e=>new u(e).exec(this.client);fetch=e=>new c(e).exec(this.client);reset=()=>new d().exec(this.client);range=e=>new m(e).exec(this.client)};var b=class t extends h{constructor(e){if("request"in e){super(e);return}(e.url.startsWith(" ")||e.url.endsWith(" ")||/\r|\n/.test(e.url))&&console.warn("The vector url contains whitespace or newline, which can cause errors!"),(e.token.startsWith(" ")||e.token.endsWith(" ")||/\r|\n/.test(e.token))&&console.warn("The vector token contains whitespace or newline, which can cause errors!");let s=new i({baseUrl:e.url,retry:e.retry,headers:{authorization:`Bearer ${e.token}`},cache:e.cache||"no-store",signal:e.signal});super(s);}static fromEnv(e){let s=process?.env.UPSTASH_VECTOR_REST_URL;if(!s)throw new Error("Unable to find environment variable: `UPSTASH_VECTOR_REST_URL`");let o=process?.env.UPSTASH_VECTOR_REST_TOKEN;if(!o)throw new Error("Unable to find environment variable: `UPSTASH_VECTOR_REST_TOKEN`");return new t({...e,url:s,token:o})}};
+var n=class extends Error{constructor(e){super(e),this.name="UpstashError";}};var a=class{baseUrl;headers;options;retry;constructor(e){this.options={cache:e.cache,signal:e.signal},this.baseUrl=e.baseUrl.replace(/\/$/,""),this.headers={"Content-Type":"application/json",...e.headers},typeof e?.retry=="boolean"&&e?.retry===!1?this.retry={attempts:1,backoff:()=>0}:this.retry={attempts:e?.retry?.retries??5,backoff:e?.retry?.backoff??(t=>Math.exp(t)*50)};}async request(e){let t={cache:this.options.cache,method:"POST",headers:this.headers,body:JSON.stringify(e.body),keepalive:!0,signal:this.options.signal},o=null,f=null;for(let y=0;y<=this.retry.attempts;y++)try{o=await fetch([this.baseUrl,...e.path??[]].join("/"),t);break}catch(g){if(this.options.signal?.aborted){let b=new Blob([JSON.stringify({result:this.options.signal.reason??"Aborted"})]),x={status:200,statusText:this.options.signal.reason??"Aborted"};o=new Response(b,x);break}f=g,await new Promise(b=>setTimeout(b,this.retry.backoff(y)));}if(!o)throw f??new Error("Exhausted all retries");let h=await o.json();if(!o.ok)throw new n(`${h.error}, command was: ${JSON.stringify(e.body)}`);return {result:h.result,error:h.error}}};var r=class{payload;endpoint;constructor(e,t){this.payload=e,this.endpoint=t;}async exec(e){let{result:t,error:o}=await e.request({body:this.payload,path:[this.endpoint]});if(o)throw new n(o);if(typeof t>"u")throw new Error("Request did not return a result");return t}};var i=class extends r{constructor(e){let t=[];Array.isArray(e)?t.push(...e):t.push(e),super(t,"delete");}};var p=class extends r{constructor(e){super(e,"query");}};var c=class extends r{constructor(e){super(e,"upsert");}};var u=class extends r{constructor([e,t]){super({ids:e,...t},"fetch");}};var l=class extends r{constructor(e){super(e,"range");}};var m=class extends r{constructor(){super([],"reset");}};var d=class{client;constructor(e){this.client=e;}delete=e=>new i(e).exec(this.client);query=e=>new p(e).exec(this.client);upsert=e=>new c(e).exec(this.client);fetch=(...e)=>new u(e).exec(this.client);reset=()=>new m().exec(this.client);range=e=>new l(e).exec(this.client)};var R=class s extends d{constructor(e){if("request"in e){super(e);return}(e.url.startsWith(" ")||e.url.endsWith(" ")||/\r|\n/.test(e.url))&&console.warn("The vector url contains whitespace or newline, which can cause errors!"),(e.token.startsWith(" ")||e.token.endsWith(" ")||/\r|\n/.test(e.token))&&console.warn("The vector token contains whitespace or newline, which can cause errors!");let t=new a({baseUrl:e.url,retry:e.retry,headers:{authorization:`Bearer ${e.token}`},cache:e.cache||"no-store",signal:e.signal});super(t);}static fromEnv(e){let t=process?.env.UPSTASH_VECTOR_REST_URL;if(!t)throw new Error("Unable to find environment variable: `UPSTASH_VECTOR_REST_URL`");let o=process?.env.UPSTASH_VECTOR_REST_TOKEN;if(!o)throw new Error("Unable to find environment variable: `UPSTASH_VECTOR_REST_TOKEN`");return new s({...e,url:t,token:o})}};
 
-export { b as Index };
+export { R as Index };

package/package.json

@@ -4,7 +4,7 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "version": "v0.1.0-alpha",
+  "version": "v0.1.0-alpha-2",
   "keywords": [
     "vector",
     "upstash",