Implement Namespaces API

src/data/index.ts

@@ -31,6 +31,10 @@ import { ListImportsCommand } from './bulk/listImports';
 import { DescribeImportCommand } from './bulk/describeImport';
 import { CancelImportCommand } from './bulk/cancelImport';
 import { BulkOperationsProvider } from './bulk/bulkOperationsProvider';
+import { NamespaceOperationsProvider } from './namespaces/namespacesOperationsProvider';
+import { listNamespaces } from './namespaces/listNamespaces';
+import { describeNamespace } from './namespaces/describeNamespace';
+import { deleteNamespace } from './namespaces/deleteNamespace';
 
 export type {
   PineconeConfiguration,
@@ -167,6 +171,12 @@ export class Index<T extends RecordMetadata = RecordMetadata> {
   private _describeImportCommand: DescribeImportCommand;
   /** @hidden */
   private _cancelImportCommand: CancelImportCommand;
+  /** @hidden */
+  private _listNamespacesCommand: ReturnType<typeof listNamespaces>;
+  /** @hidden */
+  private _describeNamespaceCommand: ReturnType<typeof describeNamespace>;
+  /** @hidden */
+  private _deleteNamespaceCommand: ReturnType<typeof deleteNamespace>;
 
   /** @internal */
   private config: PineconeConfiguration;
@@ -269,6 +279,17 @@ export class Index<T extends RecordMetadata = RecordMetadata> {
       bulkApiProvider,
       namespace
     );
+
+    // namespace operations
+    const namespaceApiProvider = new NamespaceOperationsProvider(
+      config,
+      indexName,
+      indexHostUrl,
+      additionalHeaders
+    );
+    this._listNamespacesCommand = listNamespaces(namespaceApiProvider);
+    this._describeNamespaceCommand = describeNamespace(namespaceApiProvider);
+    this._deleteNamespaceCommand = deleteNamespace(namespaceApiProvider);
   }
 
   /**
@@ -798,4 +819,16 @@ export class Index<T extends RecordMetadata = RecordMetadata> {
   async cancelImport(id: string) {
     return await this._cancelImportCommand.run(id);
   }
+
+  async listNamespaces() {
+    return await this._listNamespacesCommand();
+  }
+
+  async describeNamespace(namespace: string) {
+    return await this._describeNamespaceCommand(namespace);
+  }
+
+  async deleteNamespace(namespace: string) {
+    return await this._deleteNamespaceCommand(namespace);
+  }
 }

src/data/namespaces/deleteNamespace.ts

@@ -0,0 +1,9 @@
+import { NamespaceOperationsProvider } from '../namespaces/namespacesOperationsProvider';
+
+export const deleteNamespace = (apiProvider: NamespaceOperationsProvider) => {
+  return async (namespace: string): Promise<void> => {
+    const api = await apiProvider.provide();
+    await api.deleteNamespace({ namespace });
+    return;
+  };
+};

src/data/namespaces/describeNamespace.ts

@@ -0,0 +1,9 @@
+import { NamespaceDescription } from '../../pinecone-generated-ts-fetch/db_data';
+import { NamespaceOperationsProvider } from '../namespaces/namespacesOperationsProvider';
+
+export const describeNamespace = (apiProvider: NamespaceOperationsProvider) => {
+  return async (namespace: string): Promise<NamespaceDescription> => {
+    const api = await apiProvider.provide();
+    return await api.describeNamespace({ namespace });
+  };
+};

src/data/namespaces/listNamespaces.ts

@@ -0,0 +1,9 @@
+import { ListNamespacesResponse } from '../../pinecone-generated-ts-fetch/db_data';
+import { NamespaceOperationsProvider } from '../namespaces/namespacesOperationsProvider';
+
+export const listNamespaces = (apiProvider: NamespaceOperationsProvider) => {
+  return async (): Promise<ListNamespacesResponse> => {
+    const api = await apiProvider.provide();
+    return await api.listNamespaces();
+  };
+};

src/data/namespaces/namespacesOperationsProvider.ts

@@ -0,0 +1,77 @@
+import type { PineconeConfiguration } from '../vectors/types';
+import type { HTTPHeaders } from '../../pinecone-generated-ts-fetch/db_data';
+import {
+  Configuration,
+  ConfigurationParameters,
+  NamespaceOperationsApi,
+  X_PINECONE_API_VERSION,
+} from '../../pinecone-generated-ts-fetch/db_data';
+import {
+  buildUserAgent,
+  getFetch,
+  normalizeUrl,
+  queryParamsStringify,
+} from '../../utils';
+import { IndexHostSingleton } from '../indexHostSingleton';
+import { middleware } from '../../utils/middleware';
+
+export class NamespaceOperationsProvider {
+  private readonly config: PineconeConfiguration;
+  private readonly indexName: string;
+  private indexHostUrl?: string;
+  private namespaceOperations?: NamespaceOperationsApi;
+  private readonly additionalHeaders?: HTTPHeaders;
+
+  constructor(
+    config: PineconeConfiguration,
+    indexName: string,
+    indexHostUrl?: string,
+    additionalHeaders?: HTTPHeaders
+  ) {
+    this.config = config;
+    this.indexName = indexName;
+    this.indexHostUrl = normalizeUrl(indexHostUrl);
+    this.additionalHeaders = additionalHeaders;
+  }
+
+  async provide() {
+    if (this.namespaceOperations) {
+      return this.namespaceOperations;
+    }
+
+    // If an indexHostUrl has been manually passed we use that,
+    // otherwise we rely on resolving the host from the IndexHostSingleton
+    if (this.indexHostUrl) {
+      this.namespaceOperations = this.buildNamespaceOperationsConfig();
+    } else {
+      this.indexHostUrl = await IndexHostSingleton.getHostUrl(
+        this.config,
+        this.indexName
+      );
+
+      this.namespaceOperations = this.buildNamespaceOperationsConfig();
+    }
+
+    return this.namespaceOperations;
+  }
+
+  buildNamespaceOperationsConfig() {
+    const headers = this.additionalHeaders || null;
+
+    const indexConfigurationParameters: ConfigurationParameters = {
+      basePath: this.indexHostUrl,
+      apiKey: this.config.apiKey,
+      queryParamsStringify,
+      headers: {
+        'User-Agent': buildUserAgent(this.config),
+        'X-Pinecone-Api-Version': X_PINECONE_API_VERSION,
+        ...headers,
+      },
+      fetchApi: getFetch(this.config),
+      middleware,
+    };
+
+    const indexConfiguration = new Configuration(indexConfigurationParameters);
+    return new NamespaceOperationsApi(indexConfiguration);
+  }
+}