Juntuchen/js update (Azure#25543)

### Packages impacted by this PR


### Issues associated with this PR


### Describe the problem that is addressed by this PR


### What are the possible designs available to address the problem? If
there are more than one possible design, why was the one in this PR
chosen?


### Are there test cases added in this PR? _(If not, why?)_


### Provide a list of related PRs _(if any)_


### Command used to generate this PR:**_(Applicable only to SDK release
request PRs)_

### Checklists
- [ ] Added impacted package name to the issue description
- [ ] Does this PR needs any fixes in the SDK Generator?** _(If so,
create an Issue in the
[Autorest/typescript](https://github.com/Azure/autorest.typescript)
repository and link it here)_
- [ ] Added a changelog (if necessary)

Author: juntuchen-msft

sdk/communication/communication-call-automation/review/communication-call-automation.api.md

@@ -64,8 +64,9 @@ export class CallAutomationClient {
     constructor(connectionString: string, options?: CallAutomationClientOptions);
     constructor(endpoint: string, credential: KeyCredential, options?: CallAutomationClientOptions);
     constructor(endpoint: string, credential: TokenCredential, options?: CallAutomationClientOptions);
-    answerCall(incomingCallContext: string, callbackUri: string, options?: AnswerCallOptions): Promise<AnswerCallResult>;
-    createCall(target: CallInvite | CommunicationIdentifier[], callbackUri: string, options?: CreateCallOptions): Promise<CreateCallResult>;
+    answerCall(incomingCallContext: string, callbackUrl: string, options?: AnswerCallOptions): Promise<AnswerCallResult>;
+    createCall(target: CallInvite, callbackUrl: string, options?: CreateCallOptions): Promise<CreateCallResult>;
+    createGroupCall(targets: CommunicationIdentifier[], callbackUrl: string, options?: CreateCallOptions): Promise<CreateCallResult>;
     getCallConnection(callConnectionId: string): CallConnection;
     getCallRecording(): CallRecording;
     getSourceIdentity(): CommunicationUserIdentifier | undefined;
@@ -84,7 +85,7 @@ export type CallAutomationEvent = AddParticipantSucceeded | AddParticipantFailed
 // @public
 export class CallAutomationEventParser {
     // (undocumented)
-    parse(encodedEvents: string): Promise<CallAutomationEvent>;
+    parse(encodedEvent: string): Promise<CallAutomationEvent>;
     // (undocumented)
     parse(encodedEvents: Record<string, unknown>): Promise<CallAutomationEvent>;
 }

sdk/communication/communication-call-automation/src/callAutomationClient.ts

@@ -38,6 +38,7 @@ import {
   PhoneNumberIdentifierModelConverter,
 } from "./utli/converters";
 import { ContentDownloaderImpl } from "./contentDownloader";
+import { v4 as uuidv4 } from "uuid";
 
 /**
  * Client options used to configure CallAutomation Client API requests.
@@ -159,48 +160,16 @@ export class CallAutomationClient {
       : undefined;
   }
 
-  /**
-   * Create an outgoing call from source to target identities.
-   * @param target - Either a single target or a group of target identities.
-   * @param callbackUri - The callback url.
-   * @param options - Additional request options contains createCallConnection api options.
-   */
-  public async createCall(
-    target: CallInvite | CommunicationIdentifier[],
-    callbackUri: string,
-    options: CreateCallOptions = {}
+  private async createCallInternal(
+    request: CreateCallRequest,
+    options?: CreateCallOptions
   ): Promise<CreateCallResult> {
-    const request: CreateCallRequest = {
-      sourceIdentity: this.sourceIdentity,
-      targets:
-        target instanceof CallInvite
-          ? [communicationIdentifierModelConverter(target.target)]
-          : target.map((m) => communicationIdentifierModelConverter(m)),
-      callbackUri: callbackUri,
-      operationContext: options.operationContext,
-      azureCognitiveServicesEndpointUrl: options.azureCognitiveServicesEndpointUrl,
-      mediaStreamingConfiguration: options.mediaStreamingConfiguration,
-      customContext: {
-        sipHeaders:
-          target instanceof CallInvite ? target.sipHeaders : options.sipHeaders ?? undefined,
-        voipHeaders:
-          target instanceof CallInvite ? target.voipHeaders : options.voipHeaders ?? undefined,
-      },
-      sourceCallerIdNumber:
-        target instanceof CallInvite
-          ? PhoneNumberIdentifierModelConverter(target.sourceCallIdNumber)
-          : options.sourceCallIdNumber
-          ? PhoneNumberIdentifierModelConverter(options.sourceCallIdNumber)
-          : undefined,
-      sourceDisplayName:
-        target instanceof CallInvite
-          ? target.sourceDisplayName
-          : options.sourceDisplayName
-          ? options.sourceDisplayName
-          : undefined,
+    const optionsInternal = {
+      ...options,
+      repeatabilityFirstSent: new Date().toUTCString(),
+      repeatabilityRequestID: uuidv4(),
     };
-
-    const result = await this.callAutomationApiClient.createCall(request, options);
+    const result = await this.callAutomationApiClient.createCall(request, optionsInternal);
 
     if (result?.callConnectionId) {
       const callConnectionPropertiesDto: CallConnectionProperties = {
@@ -229,25 +198,87 @@ export class CallAutomationClient {
     throw "callConnectionProperties / callConnectionId is missing in createCall result";
   }
 
+  /**
+   * Create an outgoing call from source to a target identity.
+   * @param target - A single target.
+   * @param callbackUrl - The callback url.
+   * @param options - Additional request options contains createCallConnection api options.
+   */
+  public async createCall(
+    target: CallInvite,
+    callbackUrl: string,
+    options: CreateCallOptions = {}
+  ): Promise<CreateCallResult> {
+    const request: CreateCallRequest = {
+      sourceIdentity: this.sourceIdentity,
+      targets: [communicationIdentifierModelConverter(target.target)],
+      callbackUri: callbackUrl,
+      operationContext: options.operationContext,
+      azureCognitiveServicesEndpointUrl: options.azureCognitiveServicesEndpointUrl,
+      mediaStreamingConfiguration: options.mediaStreamingConfiguration,
+      customContext: {
+        sipHeaders: target.sipHeaders,
+        voipHeaders: target.voipHeaders,
+      },
+      sourceCallerIdNumber: PhoneNumberIdentifierModelConverter(target.sourceCallIdNumber),
+      sourceDisplayName: target.sourceDisplayName,
+    };
+
+    return this.createCallInternal(request, options);
+  }
+
+  /**
+   * Create an outgoing call from source to a group of targets identities.
+   * @param targets - A group of targets identities.
+   * @param callbackUrl - The callback url.
+   * @param options - Additional request options contains createCallConnection api options.
+   */
+  public async createGroupCall(
+    targets: CommunicationIdentifier[],
+    callbackUrl: string,
+    options: CreateCallOptions = {}
+  ): Promise<CreateCallResult> {
+    const request: CreateCallRequest = {
+      sourceIdentity: this.sourceIdentity,
+      targets: targets.map((target) => communicationIdentifierModelConverter(target)),
+      callbackUri: callbackUrl,
+      operationContext: options.operationContext,
+      azureCognitiveServicesEndpointUrl: options.azureCognitiveServicesEndpointUrl,
+      mediaStreamingConfiguration: options.mediaStreamingConfiguration,
+      customContext: {
+        sipHeaders: options.sipHeaders,
+        voipHeaders: options.voipHeaders,
+      },
+      sourceCallerIdNumber: PhoneNumberIdentifierModelConverter(options.sourceCallIdNumber),
+      sourceDisplayName: options.sourceDisplayName,
+    };
+
+    return this.createCallInternal(request, options);
+  }
+
   /**
    * Answer the call.
    * @param incomingCallContext - The context associated with the call.
-   * @param callbackUri - The callback url.
+   * @param callbackUrl - The callback url.
    * @param options - Additional request options contains answerCall api options.
    */
   public async answerCall(
     incomingCallContext: string,
-    callbackUri: string,
+    callbackUrl: string,
     options: AnswerCallOptions = {}
   ): Promise<AnswerCallResult> {
     const request: AnswerCallRequest = {
       incomingCallContext: incomingCallContext,
-      callbackUri: callbackUri,
+      callbackUri: callbackUrl,
       mediaStreamingConfiguration: options.mediaStreamingConfiguration,
       azureCognitiveServicesEndpointUrl: options.azureCognitiveServicesEndpointUrl,
     };
-
-    const result = await this.callAutomationApiClient.answerCall(request, options);
+    const optionsInternal = {
+      ...options,
+      repeatabilityFirstSent: new Date().toUTCString(),
+      repeatabilityRequestID: uuidv4(),
+    };
+    const result = await this.callAutomationApiClient.answerCall(request, optionsInternal);
 
     if (result?.callConnectionId) {
       const callConnectionProperties: CallConnectionProperties = {
@@ -296,8 +327,13 @@ export class CallAutomationClient {
           target instanceof CallInvite ? target.voipHeaders : options.voipHeaders ?? undefined,
       },
     };
+    const optionsInternal = {
+      ...options,
+      repeatabilityFirstSent: new Date().toUTCString(),
+      repeatabilityRequestID: uuidv4(),
+    };
 
-    return this.callAutomationApiClient.redirectCall(request, options);
+    return this.callAutomationApiClient.redirectCall(request, optionsInternal);
   }
 
   /**
@@ -314,7 +350,12 @@ export class CallAutomationClient {
       incomingCallContext: incomingCallContext,
       callRejectReason: options.callRejectReason,
     };
+    const optionsInternal = {
+      ...options,
+      repeatabilityFirstSent: new Date().toUTCString(),
+      repeatabilityRequestID: uuidv4(),
+    };
 
-    return this.callAutomationApiClient.rejectCall(request, options);
+    return this.callAutomationApiClient.rejectCall(request, optionsInternal);
   }
 }

sdk/communication/communication-call-automation/src/callAutomationEventParser.ts

@@ -34,7 +34,7 @@ const serializer = createSerializer();
  * Helper class for parsing Acs callback events.
  */
 export class CallAutomationEventParser {
-  public async parse(encodedEvents: string): Promise<CallAutomationEvent>;
+  public async parse(encodedEvent: string): Promise<CallAutomationEvent>;
 
   public async parse(encodedEvents: Record<string, unknown>): Promise<CallAutomationEvent>;
 

sdk/communication/communication-call-automation/src/callConnection.ts

@@ -31,6 +31,7 @@ import {
   phoneNumberIdentifierConverter,
   PhoneNumberIdentifierModelConverter,
 } from "./utli/converters";
+import { v4 as uuidv4 } from "uuid";
 
 /**
  * CallConnection class represents call connection based APIs.
@@ -84,7 +85,12 @@ export class CallConnection {
    */
   public async hangUp(isForEveryOne: boolean, options: HangUpOptions = {}): Promise<void> {
     if (isForEveryOne) {
-      await this.callConnectionImpl.terminateCall(this.callConnectionId, options);
+      const optionsInternal = {
+        ...options,
+        repeatabilityFirstSent: new Date().toUTCString(),
+        repeatabilityRequestID: uuidv4(),
+      };
+      await this.callConnectionImpl.terminateCall(this.callConnectionId, optionsInternal);
     } else {
       await this.callConnectionImpl.hangupCall(this.callConnectionId, options);
     }
@@ -150,11 +156,15 @@ export class CallConnection {
         voipHeaders: participant.voipHeaders,
       },
     };
-
+    const optionsInternal = {
+      ...options,
+      repeatabilityFirstSent: new Date().toUTCString(),
+      repeatabilityRequestID: uuidv4(),
+    };
     const result = await this.callConnectionImpl.addParticipant(
       this.callConnectionId,
       addParticipantRequest,
-      options
+      optionsInternal
     );
     const addParticipantsResult: AddParticipantResult = {
       ...result,
@@ -185,11 +195,15 @@ export class CallConnection {
         voipHeaders: target.voipHeaders,
       },
     };
-
+    const optionsInternal = {
+      ...options,
+      repeatabilityFirstSent: new Date().toUTCString(),
+      repeatabilityRequestID: uuidv4(),
+    };
     const result = await this.callConnectionImpl.transferToParticipant(
       this.callConnectionId,
       transferToParticipantRequest,
-      options
+      optionsInternal
     );
     const transferCallResult: TransferCallResult = { ...result };
     return transferCallResult;
@@ -208,11 +222,15 @@ export class CallConnection {
       participantToRemove: communicationIdentifierModelConverter(participant),
       operationContext: options.operationContext,
     };
-
+    const optionsInternal = {
+      ...options,
+      repeatabilityFirstSent: new Date().toUTCString(),
+      repeatabilityRequestID: uuidv4(),
+    };
     const result = await this.callConnectionImpl.removeParticipant(
       this.callConnectionId,
       removeParticipantRequest,
-      options
+      optionsInternal
     );
     const removeParticipantsResult: RemoveParticipantsResult = {
       ...result,

sdk/communication/communication-call-automation/src/callRecording.ts

@@ -15,6 +15,7 @@ import {
 import { communicationIdentifierModelConverter } from "./utli/converters";
 import { ContentDownloaderImpl } from "./contentDownloader";
 import * as fs from "fs";
+import { v4 as uuidv4 } from "uuid";
 
 /**
  * CallRecording class represents call recording related APIs.
@@ -64,9 +65,14 @@ export class CallRecording {
       startCallRecordingRequest.callLocator.serverCallId = options.callLocator.id;
     }
 
+    const optionsInternal = {
+      ...options,
+      repeatabilityFirstSent: new Date().toUTCString(),
+      repeatabilityRequestID: uuidv4(),
+    };
     const response = await this.callRecordingImpl.startRecording(
       startCallRecordingRequest,
-      options
+      optionsInternal
     );
 
     const result: RecordingStateResult = {

sdk/communication/communication-call-automation/test/callAutomationClient.spec.ts

@@ -5,7 +5,7 @@ import { Recorder } from "@azure-tools/test-recorder";
 import Sinon, { SinonStubbedInstance } from "sinon";
 import { CallConnectionProperties } from "../src/models/models";
 import { CreateCallResult } from "../src/models/responses";
-import { CALL_CALLBACK_URL, CALL_TARGET_ID } from "./utils/connectionUtils";
+import { CALL_CALLBACK_URL, CALL_TARGET_ID, CALL_TARGET_ID_2 } from "./utils/connectionUtils";
 import { CommunicationIdentifier, CommunicationUserIdentifier } from "@azure/communication-common";
 import { assert } from "chai";
 import { Context } from "mocha";
@@ -24,6 +24,7 @@ import {
   loadPersistedEvents,
   persistEvents,
 } from "./utils/recordedClient";
+import { v4 as uuidv4 } from "uuid";
 
 describe("Call Automation Client Unit Tests", () => {
   let targets: CommunicationIdentifier[];
@@ -35,33 +36,48 @@ describe("Call Automation Client Unit Tests", () => {
       {
         communicationUserId: CALL_TARGET_ID,
       },
+      {
+        communicationUserId: CALL_TARGET_ID_2,
+      },
     ];
     // stub CallAutomationClient
     client = Sinon.createStubInstance(
       CallAutomationClient
     ) as SinonStubbedInstance<CallAutomationClient> & CallAutomationClient;
   });
 
-  it("CreateCall", async () => {
+  it("RepeatabilityHeadersGeneration", async () => {
+    // mocks
+    const repeatabilityFirstSent: string = new Date().toUTCString();
+    const repeatabilityRequestID: string = uuidv4();
+
+    // asserts
+    assert.isNotNull(repeatabilityFirstSent);
+    assert.isNotNull(repeatabilityRequestID);
+    assert.typeOf(repeatabilityFirstSent, "string");
+    assert.typeOf(repeatabilityRequestID, "string");
+  });
+
+  it("CreateGroupCall", async () => {
     // mocks
-    const createCallResultMock: CreateCallResult = {
+    const createGroupCallResultMock: CreateCallResult = {
       callConnectionProperties: {} as CallConnectionProperties,
       callConnection: {} as CallConnection,
     };
-    client.createCall.returns(
+    client.createGroupCall.returns(
       new Promise((resolve) => {
-        resolve(createCallResultMock);
+        resolve(createGroupCallResultMock);
       })
     );
 
-    const promiseResult = client.createCall(targets, CALL_CALLBACK_URL);
+    const promiseResult = client.createGroupCall(targets, CALL_CALLBACK_URL);
 
     // asserts
     promiseResult
       .then((result: CreateCallResult) => {
         assert.isNotNull(result);
-        assert.isTrue(client.createCall.calledWith(targets, CALL_CALLBACK_URL));
-        assert.equal(result, createCallResultMock);
+        assert.isTrue(client.createGroupCall.calledWith(targets, CALL_CALLBACK_URL));
+        assert.equal(result, createGroupCallResultMock);
         return;
       })
       .catch((error) => console.error(error));

sdk/communication/communication-call-automation/test/utils/connectionUtils.ts

@@ -12,6 +12,7 @@ export const CALL_SERVER_CALL_ID = "serverCallId";
 export const CALL_CALLER_ID = "callerId";
 export const CALL_CALLER_DISPLAY_NAME = "callerDisplayName";
 export const CALL_TARGET_ID = "targetId";
+export const CALL_TARGET_ID_2 = "targetId2";
 export const CALL_CONNECTION_STATE = "connected";
 export const CALL_SUBJECT = "subject";
 export const CALL_CALLBACK_URL = "https://REDACTED.com/events";