Add user patch batch (#586)

* Add status to patch request

* Add user patch batch

Author: dorsha

lib/management/paths.ts

@@ -6,6 +6,7 @@ export default {
     createBatch: '/v1/mgmt/user/create/batch',
     update: '/v1/mgmt/user/update',
     patch: '/v1/mgmt/user/patch',
+    patchBatch: '/v1/mgmt/user/patch/batch',
     delete: '/v1/mgmt/user/delete',
     deleteBatch: '/v1/mgmt/user/delete/batch',
     deleteAllTestUsers: '/v1/mgmt/user/test/delete/all',

lib/management/types.ts

@@ -565,6 +565,12 @@ export type CreateOrInviteBatchResponse = {
   additionalErrors: Record<string, string>;
 };
 
+export type PatchUserBatchResponse = {
+  patchedUsers: UserResponse[];
+  failedUsers: UserFailedResponse[];
+  additionalErrors: Record<string, string>;
+};
+
 /**
  * Search options to filter which audit records we should retrieve.
  * All parameters are optional. `From` is currently limited to 30 days.

lib/management/user.test.ts

@@ -9,6 +9,7 @@ import {
   ProviderTokenResponse,
   GenerateEmbeddedLinkResponse,
   CreateOrInviteBatchResponse,
+  PatchUserBatchResponse,
   UserPasswordHashed,
 } from './types';
 
@@ -36,6 +37,17 @@ const mockMgmtInviteBatchResponse = {
   ],
 };
 
+const mockMgmtPatchBatchResponse = {
+  patchedUsers: [{ loginId: 'user1', email: '[email protected]' }],
+  failedUsers: [
+    {
+      failure: 'user not found',
+      user: { loginId: 'user2', email: '[email protected]' },
+    },
+  ],
+  additionalErrors: { user3: 'invalid email format' },
+};
+
 describe('Management User', () => {
   afterEach(() => {
     jest.clearAllMocks();
@@ -575,6 +587,7 @@ describe('Management User', () => {
         verifiedPhone: false,
         scim: true,
         ssoAppIds: ['sso1', 'sso2'],
+        status: 'invited',
       });
 
       expect(mockHttpClient.patch).toHaveBeenCalledWith(apiPaths.user.patch, {
@@ -587,6 +600,120 @@ describe('Management User', () => {
         verifiedPhone: false,
         ssoAppIds: ['sso1', 'sso2'],
         scim: true,
+        status: 'invited',
+      });
+    });
+  });
+
+  describe('patchBatch', () => {
+    it('should send the correct request and receive correct response', async () => {
+      const httpResponse = {
+        ok: true,
+        json: () => mockMgmtPatchBatchResponse,
+        clone: () => ({
+          json: () => Promise.resolve(mockMgmtPatchBatchResponse),
+        }),
+        status: 200,
+      };
+      mockHttpClient.patch.mockResolvedValue(httpResponse);
+      const resp: SdkResponse<PatchUserBatchResponse> = await management.user.patchBatch([
+        {
+          loginId: 'user1',
+          email: '[email protected]',
+          displayName: 'User One',
+          roles: ['role1'],
+        },
+        {
+          loginId: 'user2',
+          phone: '+1234567890',
+          verifiedPhone: true,
+          customAttributes: { department: 'engineering' },
+        },
+        {
+          loginId: 'user3',
+          status: 'disabled',
+        },
+      ]);
+      expect(mockHttpClient.patch).toHaveBeenCalledWith(apiPaths.user.patchBatch, {
+        users: [
+          {
+            loginId: 'user1',
+            email: '[email protected]',
+            displayName: 'User One',
+            roleNames: ['role1'],
+          },
+          {
+            loginId: 'user2',
+            phone: '+1234567890',
+            verifiedPhone: true,
+            customAttributes: { department: 'engineering' },
+          },
+          {
+            loginId: 'user3',
+            status: 'disabled',
+          },
+        ],
+      });
+      expect(resp).toEqual({
+        code: 200,
+        data: mockMgmtPatchBatchResponse,
+        ok: true,
+        response: httpResponse,
+      });
+    });
+
+    it('should handle empty user array', async () => {
+      const httpResponse = {
+        ok: true,
+        json: () => ({ patchedUsers: [], failedUsers: [], additionalErrors: {} }),
+        clone: () => ({
+          json: () => Promise.resolve({ patchedUsers: [], failedUsers: [], additionalErrors: {} }),
+        }),
+        status: 200,
+      };
+      mockHttpClient.patch.mockResolvedValue(httpResponse);
+      const resp: SdkResponse<PatchUserBatchResponse> = await management.user.patchBatch([]);
+      expect(mockHttpClient.patch).toHaveBeenCalledWith(apiPaths.user.patchBatch, {
+        users: [],
+      });
+      expect(resp).toEqual({
+        code: 200,
+        data: { patchedUsers: [], failedUsers: [], additionalErrors: {} },
+        ok: true,
+        response: httpResponse,
+      });
+    });
+
+    it('should only include defined fields in patch request', async () => {
+      const httpResponse = {
+        ok: true,
+        json: () => mockMgmtPatchBatchResponse,
+        clone: () => ({
+          json: () => Promise.resolve(mockMgmtPatchBatchResponse),
+        }),
+        status: 200,
+      };
+      mockHttpClient.patch.mockResolvedValue(httpResponse);
+      await management.user.patchBatch([
+        {
+          loginId: 'user1',
+          email: '[email protected]',
+          phone: undefined,
+          displayName: 'Updated Name',
+          roles: undefined,
+          verifiedEmail: true,
+          verifiedPhone: undefined,
+        },
+      ]);
+      expect(mockHttpClient.patch).toHaveBeenCalledWith(apiPaths.user.patchBatch, {
+        users: [
+          {
+            loginId: 'user1',
+            email: '[email protected]',
+            displayName: 'Updated Name',
+            verifiedEmail: true,
+          },
+        ],
       });
     });
   });

lib/management/user.ts

@@ -17,6 +17,7 @@ import {
   UserStatus,
   User,
   CreateOrInviteBatchResponse,
+  PatchUserBatchResponse,
   TemplateOptions,
   ProviderTokenOptions,
   UserOptions,
@@ -373,11 +374,11 @@ const withUser = (httpClient: HttpClient) => {
   /* Update User End */
 
   /**
-   * Patches an existing user.
+   * Helper function to build patch request body from options
    * @param loginId The login ID of the user
-   * @param options The fields to update. Only the provided ones will be updated.
+   * @param options The fields to update
    */
-  function patch(loginId: string, options: PatchUserOptions): Promise<SdkResponse<UserResponse>> {
+  function buildPatchRequestBody(loginId: string, options: PatchUserOptions): any {
     const body = {
       loginId,
     } as any;
@@ -424,13 +425,44 @@ const withUser = (httpClient: HttpClient) => {
     if (options.scim !== undefined) {
       body.scim = options.scim;
     }
+    if (options.status !== undefined) {
+      body.status = options.status;
+    }
+
+    return body;
+  }
+
+  /**
+   * Patches an existing user.
+   * @param loginId The login ID of the user
+   * @param options The fields to update. Only the provided ones will be updated.
+   */
+  function patch(loginId: string, options: PatchUserOptions): Promise<SdkResponse<UserResponse>> {
+    const body = buildPatchRequestBody(loginId, options);
 
     return transformResponse<SingleUserResponse, UserResponse>(
       httpClient.patch(apiPaths.user.patch, body),
       (data) => data.user,
     );
   }
 
+  /**
+   * Patches multiple users in batch.
+   * @param users Array of patch requests, each containing loginId and the fields to update
+   */
+  function patchBatch(
+    users: Array<{ loginId: string } & PatchUserOptions>,
+  ): Promise<SdkResponse<PatchUserBatchResponse>> {
+    const body = {
+      users: users.map((user) => buildPatchRequestBody(user.loginId, user)),
+    };
+
+    return transformResponse<PatchUserBatchResponse, PatchUserBatchResponse>(
+      httpClient.patch(apiPaths.user.patchBatch, body),
+      (data) => data,
+    );
+  }
+
   return {
     create,
     /**
@@ -476,6 +508,7 @@ const withUser = (httpClient: HttpClient) => {
       transformResponse(httpClient.post(apiPaths.user.deleteBatch, { userIds })),
     update,
     patch,
+    patchBatch,
     /**
      * Delete an existing user.
      * @param loginId The login ID of the user
@@ -968,6 +1001,7 @@ export interface PatchUserOptions {
   familyName?: string;
   ssoAppIds?: string[];
   scim?: boolean;
+  status?: UserStatus;
 }
 
 export default withUser;