Fix IndexHostSingleton holding onto one instance of ManageIndexesAPI

src/data/__tests__/indexHostSingleton.test.ts

@@ -1,20 +1,22 @@
 import { IndexHostSingleton } from '../indexHostSingleton';
 
 const mockDescribeIndex = jest.fn();
+const mockIndexOperationsBuilder = jest.fn();
 
 jest.mock('../../control', () => {
   const realControl = jest.requireActual('../../control');
-
   return {
     ...realControl,
     describeIndex: () => mockDescribeIndex,
+    indexOperationsBuilder: (config) => mockIndexOperationsBuilder(config),
   };
 });
 
 describe('IndexHostSingleton', () => {
   afterEach(() => {
     IndexHostSingleton._reset();
     mockDescribeIndex.mockReset();
+    mockIndexOperationsBuilder.mockReset();
   });
 
   test('calls describeIndex to resolve host for a specific apiKey and indexName, prepends protocol to host', async () => {
@@ -140,4 +142,50 @@ describe('IndexHostSingleton', () => {
     await IndexHostSingleton.getHostUrl(pineconeConfig, 'test-index');
     expect(mockDescribeIndex).toHaveBeenCalledTimes(1);
   });
+
+  test.only('calling getHostUrl with different apiKey configurations should instantiate new ManageIndexesApi classes', async () => {
+    const pineconeConfig1 = { apiKey: 'test-key-1' };
+    const pineconeConfig2 = { apiKey: 'test-key-2' };
+
+    mockDescribeIndex
+      .mockResolvedValueOnce({
+        name: 'index-1',
+        dimensions: 10,
+        metric: 'cosine',
+        host: 'test-host-1',
+        spec: { pod: { pods: 1, replicas: 1, shards: 1, podType: 'p1.x1' } },
+        status: { ready: true, state: 'Ready' },
+      })
+      .mockResolvedValueOnce({
+        name: 'index-2',
+        dimensions: 10,
+        metric: 'cosine',
+        host: 'test-host-2',
+        spec: { pod: { pods: 1, replicas: 1, shards: 1, podType: 'p1.x1' } },
+        status: { ready: true, state: 'Ready' },
+      });
+    mockIndexOperationsBuilder.mockReturnValue({ test: 'one', test2: 'two' });
+
+    await IndexHostSingleton.getHostUrl(pineconeConfig1, 'index-1');
+    await IndexHostSingleton.getHostUrl(pineconeConfig2, 'index-2');
+
+    expect(mockDescribeIndex).toHaveBeenCalledTimes(2);
+    expect(mockDescribeIndex).toHaveBeenNthCalledWith(1, 'index-1');
+    expect(mockDescribeIndex).toHaveBeenNthCalledWith(2, 'index-2');
+
+    console.log(
+      'mockIndexOperationsBuilder',
+      JSON.stringify(mockIndexOperationsBuilder.mock)
+    );
+
+    expect(mockIndexOperationsBuilder).toHaveBeenCalledTimes(2);
+    expect(mockIndexOperationsBuilder).toHaveBeenNthCalledWith(
+      1,
+      pineconeConfig1
+    );
+    expect(mockIndexOperationsBuilder).toHaveBeenNthCalledWith(
+      2,
+      pineconeConfig2
+    );
+  });
 });

src/data/indexHostSingleton.ts

@@ -1,4 +1,3 @@
-import { ManageIndexesApi } from '../pinecone-generated-ts-fetch';
 import type { PineconeConfiguration } from './types';
 import type { IndexName } from '../control';
 import { describeIndex, indexOperationsBuilder } from '../control';
@@ -10,16 +9,12 @@ import { normalizeUrl } from '../utils';
 // and index, so we cache them in a singleton for reuse.
 export const IndexHostSingleton = (function () {
   const hostUrls = {}; // map of apiKey-indexName to hostUrl
-  let indexOperationsApi: InstanceType<typeof ManageIndexesApi> | null = null;
 
   const _describeIndex = async (
     config: PineconeConfiguration,
     indexName: IndexName
   ): Promise<string> => {
-    if (!indexOperationsApi) {
-      indexOperationsApi = indexOperationsBuilder(config);
-    }
-
+    const indexOperationsApi = indexOperationsBuilder(config);
     const describeResponse = await describeIndex(indexOperationsApi)(indexName);
     const host = describeResponse.host;
 
@@ -34,19 +29,17 @@ export const IndexHostSingleton = (function () {
     }
   };
 
-  const key = (config, indexName) => `${config.apiKey}-${indexName}`;
+  const _key = (config: PineconeConfiguration, indexName: string) =>
+    `${config.apiKey}-${indexName}`;
 
-  return {
-    getHostUrl: async function (
-      config: PineconeConfiguration,
-      indexName: IndexName
-    ) {
-      const cacheKey = key(config, indexName);
+  const singleton = {
+    getHostUrl: async (config: PineconeConfiguration, indexName: IndexName) => {
+      const cacheKey = _key(config, indexName);
       if (cacheKey in hostUrls) {
         return hostUrls[cacheKey];
       } else {
         const hostUrl = await _describeIndex(config, indexName);
-        this._set(config, indexName, hostUrl);
+        singleton._set(config, indexName, hostUrl);
 
         if (!hostUrls[cacheKey]) {
           throw new PineconeUnableToResolveHostError(
@@ -74,13 +67,15 @@ export const IndexHostSingleton = (function () {
         return;
       }
 
-      const cacheKey = key(config, indexName);
+      const cacheKey = _key(config, indexName);
       hostUrls[cacheKey] = normalizedHostUrl;
     },
 
     _delete: (config: PineconeConfiguration, indexName: IndexName) => {
-      const cacheKey = key(config, indexName);
+      const cacheKey = _key(config, indexName);
       delete hostUrls[cacheKey];
     },
   };
+
+  return singleton;
 })();