avoid extra network call on configureIndex when no spec params provided, make sure we're not discarding things on unknown spec types, update unit tests

Author: austin-denoble

src/control/__tests__/configureIndex.test.ts

@@ -274,6 +274,62 @@ describe('configureIndex', () => {
     expect(IOA.describeIndex).toHaveBeenCalled();
     expect(IOA.configureIndex).not.toHaveBeenCalled();
   });
+
+  test('skips describeIndex when only non-spec params are updated', async () => {
+    const fakeConfigure: (
+      req: ConfigureIndexOperationRequest,
+    ) => Promise<IndexModel> = jest.fn().mockResolvedValue(podIndexModel);
+    const IOA = {
+      describeIndex: jest.fn(),
+      configureIndex: fakeConfigure,
+    } as unknown as ManageIndexesApi;
+
+    const returned = await configureIndex(IOA)({
+      name: 'pod-index',
+      deletionProtection: 'enabled',
+      tags: { env: 'prod' },
+    });
+
+    expect(returned).toBe(podIndexModel);
+    // describeIndex must NOT be called — no spec params were supplied
+    expect(IOA.describeIndex).not.toHaveBeenCalled();
+    expect(IOA.configureIndex).toHaveBeenCalledWith({
+      indexName: 'pod-index',
+      configureIndexRequest: {
+        spec: undefined,
+        deletionProtection: 'enabled',
+        tags: { env: 'prod' },
+        embed: undefined,
+      },
+      xPineconeApiVersion: X_PINECONE_API_VERSION,
+    });
+  });
+
+  test('throws error when spec type cannot be determined and spec params are supplied', async () => {
+    // Return an IndexModel whose spec has no recognisable type
+    const unknownSpecModel = {
+      ...podIndexModel,
+      spec: {},
+    } as unknown as IndexModel;
+    const fakeDescribe: (req: DescribeIndexRequest) => Promise<IndexModel> =
+      jest.fn().mockResolvedValue(unknownSpecModel);
+    const IOA = {
+      describeIndex: fakeDescribe,
+      configureIndex: jest.fn(),
+    } as unknown as ManageIndexesApi;
+
+    await expect(
+      configureIndex(IOA)({
+        name: 'pod-index',
+        podReplicas: 2,
+      }),
+    ).rejects.toThrow(
+      'Could not determine the index spec type. Verify the index exists and try again.',
+    );
+
+    expect(IOA.describeIndex).toHaveBeenCalled();
+    expect(IOA.configureIndex).not.toHaveBeenCalled();
+  });
 });
 
 describe('getIndexSpecType', () => {

src/control/configureIndex.ts

@@ -87,9 +87,18 @@ export const configureIndex = (api: ManageIndexesApi) => {
   return async (options: ConfigureIndexOptions): Promise<IndexModel> => {
     validator(options);
 
-    // Describe the index to determine its spec type
-    const indexDescription = await describeIndex(api)(options.name);
-    const specType = getIndexSpecType(indexDescription.spec);
+    // Only fetch the index description when spec-type-dependent params are present,
+    // avoiding an extra network round-trip for common updates (deletionProtection, tags, embed).
+    const needsSpecType =
+      options.podReplicas !== undefined ||
+      options.podType !== undefined ||
+      options.readCapacity !== undefined;
+
+    let specType: 'pod' | 'serverless' | 'byoc' | 'unknown' = 'unknown';
+    if (needsSpecType) {
+      const indexDescription = await describeIndex(api)(options.name);
+      specType = getIndexSpecType(indexDescription.spec);
+    }
 
     // Validate that spec-specific parameters match the index type
     if (specType === 'pod' && options.readCapacity !== undefined) {
@@ -105,6 +114,12 @@ export const configureIndex = (api: ManageIndexesApi) => {
         `Cannot configure podReplicas or podType on a ${specType} index; these parameters are only supported for pod indexes.`,
       );
     }
+    // Guard against silently discarding spec params when the index type could not be determined.
+    if (needsSpecType && specType === 'unknown') {
+      throw new PineconeArgumentError(
+        'Could not determine the index spec type. Verify the index exists and try again.',
+      );
+    }
 
     const spec = buildConfigureSpec(options, specType);
     const request: ConfigureIndexRequest = {