@azure-tools/rlc-common 0.28.0 → 0.29.0

package/src/static/pollingContent.ts

@@ -3,23 +3,14 @@
 
 export const pollingContent = `
 import { Client, HttpResponse } from "@azure-rest/core-client";
-{{#if useLegacyLro}}
-import {
-  LongRunningOperation,
-  LroEngine,
-  LroEngineOptions,
-  LroResponse,
-  PollerLike,
-  PollOperationState
-} from "@azure/core-lro";
-{{else}}
+import { AbortSignalLike } from "@azure/abort-controller";
 import {
+  CancelOnProgress,
   CreateHttpPollerOptions,
   LongRunningOperation,
-  LroResponse,
+  OperationResponse,
   OperationState,
-  SimplePollerLike,
-  createHttpPoller
+  createHttpPoller,
 } from "@azure/core-lro";
 {{#if clientOverload}}
 import {
@@ -28,7 +19,76 @@ import {
   {{/each}}
 } from "./responses{{#if isEsm}}.js{{/if}}";
 {{/if}}
-{{/if}}
+
+/**
+ * A simple poller that can be used to poll a long running operation.
+ */
+export interface SimplePollerLike<
+  TState extends OperationState<TResult>,
+  TResult
+> {
+  /**
+   * Returns true if the poller has finished polling.
+   */
+  isDone(): boolean;
+  /**
+   * Returns true if the poller is stopped.
+   */
+  isStopped(): boolean;
+  /**
+   * Returns the state of the operation.
+   */
+  getOperationState(): TState;
+  /**
+   * Returns the result value of the operation,
+   * regardless of the state of the poller.
+   * It can return undefined or an incomplete form of the final TResult value
+   * depending on the implementation.
+   */
+  getResult(): TResult | undefined;
+  /**
+   * Returns a promise that will resolve once a single polling request finishes.
+   * It does this by calling the update method of the Poller's operation.
+   */
+  poll(options?: { abortSignal?: AbortSignalLike }): Promise<TState>;
+  /**
+   * Returns a promise that will resolve once the underlying operation is completed.
+   */
+  pollUntilDone(pollOptions?: {
+    abortSignal?: AbortSignalLike;
+  }): Promise<TResult>;
+  /**
+   * Invokes the provided callback after each polling is completed,
+   * sending the current state of the poller's operation.
+   *
+   * It returns a method that can be used to stop receiving updates on the given callback function.
+   */
+  onProgress(callback: (state: TState) => void): CancelOnProgress;
+
+  /**
+   * Returns a promise that could be used for serialized version of the poller's operation
+   * by invoking the operation's serialize method.
+   */
+  serialize(): Promise<string>;
+
+  /**
+   * Wait the poller to be submitted.
+   */
+  submitted(): Promise<void>;
+
+  /**
+   * Returns a string representation of the poller's operation. Similar to serialize but returns a string.
+   * @deprecated Use serialize() instead.
+   */
+  toString(): string;
+
+  /**
+   * Stops the poller from continuing to poll. Please note this will only stop the client-side polling
+   * @deprecated Use abortSignal to stop polling instead.
+   */
+  stopPolling(): void;
+}
+
 /**
  * Helper function that builds a Poller object to help polling a long running operation.
  * @param client - Client to use for sending the request to get additional pages.
@@ -42,38 +102,52 @@ export async function getLongRunningPoller<
   TResult extends {{ this.finalResponses }}
 >(
   client: Client,
-  initialResponse: {{ this.initalResponses }},
+  initialResponse: {{ this.initialResponses }},
   options?: CreateHttpPollerOptions<TResult, OperationState<TResult>>
 ): Promise<SimplePollerLike<OperationState<TResult>, TResult>>;
 {{/each}}
 {{/if}}
-export {{#unless useLegacyLro}}async {{/unless}}function getLongRunningPoller<TResult extends HttpResponse>(
-  client: Client,
-  initialResponse: TResult,
-  {{#if useLegacyLro}}
-  options: LroEngineOptions<TResult, PollOperationState<TResult>> = {}
-  ): PollerLike<PollOperationState<TResult>, TResult> {
-    {{else}}
+export async function getLongRunningPoller<TResult extends HttpResponse>(
+    client: Client,
+    initialResponse: TResult,
     options: CreateHttpPollerOptions<TResult, OperationState<TResult>> = {}
-    ): Promise<SimplePollerLike<OperationState<TResult>, TResult>> {
-    {{/if}}  
-    const poller: LongRunningOperation<TResult> = {
-    requestMethod: initialResponse.request.method,
-    requestPath: initialResponse.request.url,
+    ): Promise<SimplePollerLike<OperationState<TResult>, TResult>> { 
+  const abortController = new AbortController();
+  const poller: LongRunningOperation<TResult> = {
     sendInitialRequest: async () => {
       // In the case of Rest Clients we are building the LRO poller object from a response that's the reason
       // we are not triggering the initial request here, just extracting the information from the
       // response we were provided.
       return getLroResponse(initialResponse);
     },
-    sendPollRequest: async path => {
+    sendPollRequest: async (
+      path,
+      options?: { abortSignal?: AbortSignalLike }
+    ) => {
       // This is the callback that is going to be called to poll the service
       // to get the latest status. We use the client provided and the polling path
       // which is an opaque URL provided by caller, the service sends this in one of the following headers: operation-location, azure-asyncoperation or location
       // depending on the lro pattern that the service implements. If non is provided we default to the initial path.
-      const response = await client
-        .pathUnchecked(path ?? initialResponse.request.url)
-        .get();
+      function abortListener(): void {
+        abortController.abort();
+      }
+      const inputAbortSignal = options?.abortSignal;
+      const abortSignal = abortController.signal;
+      if (inputAbortSignal?.aborted) {
+        abortController.abort();
+      } else if (!abortSignal.aborted) {
+        inputAbortSignal?.addEventListener("abort", abortListener, {
+          once: true
+        });
+      }
+      let response;
+      try {
+        response = await client
+          .pathUnchecked(path ?? initialResponse.request.url)
+          .get({ abortSignal });
+      } finally {
+        inputAbortSignal?.removeEventListener("abort", abortListener);
+      }
       const lroResponse = getLroResponse(response as TResult);
       lroResponse.rawResponse.headers["x-ms-original-url"] =
         initialResponse.request.url;
@@ -81,12 +155,46 @@ export {{#unless useLegacyLro}}async {{/unless}}function getLongRunningPoller<TR
     }
   };
 
-  {{#if useLegacyLro}}
-  return new LroEngine(poller, options);
-  {{else}}
   options.resolveOnUnsuccessful = options.resolveOnUnsuccessful ?? true;
-  return createHttpPoller(poller, options);
-  {{/if}}
+  const httpPoller = createHttpPoller(poller, options);
+  const simplePoller: SimplePollerLike<OperationState<TResult>, TResult> = {
+    isDone() {
+      return httpPoller.isDone;
+    },
+    isStopped() {
+      return httpPoller.isStopped;
+    },
+    getOperationState() {
+      if (!httpPoller.operationState) {
+        throw new Error(
+          "Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState()."
+        );
+      }
+      return httpPoller.operationState;
+    },
+    getResult() {
+      return httpPoller.result;
+    },
+    toString() {
+      if (!httpPoller.operationState) {
+        throw new Error(
+          "Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState()."
+        );
+      }
+      return JSON.stringify({
+        state: httpPoller.operationState
+      });
+    },
+    stopPolling() {
+      abortController.abort();
+    },
+    onProgress: httpPoller.onProgress,
+    poll: httpPoller.poll,
+    pollUntilDone: httpPoller.pollUntilDone,
+    serialize: httpPoller.serialize,
+    submitted: httpPoller.submitted
+  };
+  return simplePoller;
 }
 
 /**
@@ -96,7 +204,7 @@ export {{#unless useLegacyLro}}async {{/unless}}function getLongRunningPoller<TR
  */
 function getLroResponse<TResult extends HttpResponse>(
   response: TResult
-): LroResponse<TResult> {
+): OperationResponse<TResult>  {
   if (Number.isNaN(response.status)) {
     throw new TypeError(
       \`Status code of the response is not a number. Value: \${response.status}\`

package/src/transformSampleGroups.ts

@@ -85,7 +85,7 @@ export function transformSampleGroups(model: RLCModel, allowMockValue = true) {
         methodParamNames: "",
         method,
         isLRO: detail.operationHelperDetail?.lroDetails?.isLongRunning ?? false,
-        isPaging: detail.operationHelperDetail?.isPageable ?? false,
+        isPaging: detail.operationHelperDetail?.isPaging ?? false,
         useLegacyLro: false
       };
       // client-level, path-level and method-level parameter preparation
@@ -126,7 +126,7 @@ function enrichLROAndPagingInSample(
 ) {
   const isLRO =
       operation.operationHelperDetail?.lroDetails?.isLongRunning ?? false,
-    isPaging = operation.operationHelperDetail?.isPageable ?? false;
+    isPaging = operation.operationHelperDetail?.isPaging ?? false;
   if (isPaging) {
     if (isLRO) {
       // TODO: report warning this is not supported

package/types/interfaces.d.ts

@@ -132,7 +132,7 @@ export type PathParameter = {
 };
 export interface OperationHelperDetail {
     lroDetails?: OperationLroDetail;
-    isPageable?: boolean;
+    isPaging?: boolean;
 }
 export declare const OPERATION_LRO_HIGH_PRIORITY = 0, OPERATION_LRO_LOW_PRIORITY = 1;
 export interface OperationLroDetail {
@@ -193,6 +193,7 @@ export interface RLCOptions {
     flavor?: PackageFlavor;
     enableModelNamespace?: boolean;
     hierarchyClient?: boolean;
+    compatibilityMode?: boolean;
 }
 export interface ServiceInfo {
     title?: string;

package/types/static/pollingContent.d.ts

@@ -1 +1 @@
-export declare const pollingContent = "\nimport { Client, HttpResponse } from \"@azure-rest/core-client\";\n{{#if useLegacyLro}}\nimport {\n  LongRunningOperation,\n  LroEngine,\n  LroEngineOptions,\n  LroResponse,\n  PollerLike,\n  PollOperationState\n} from \"@azure/core-lro\";\n{{else}}\nimport {\n  CreateHttpPollerOptions,\n  LongRunningOperation,\n  LroResponse,\n  OperationState,\n  SimplePollerLike,\n  createHttpPoller\n} from \"@azure/core-lro\";\n{{#if clientOverload}}\nimport {\n  {{#each importedResponses}}\n  {{this}},\n  {{/each}}\n} from \"./responses{{#if isEsm}}.js{{/if}}\";\n{{/if}}\n{{/if}}\n/**\n * Helper function that builds a Poller object to help polling a long running operation.\n * @param client - Client to use for sending the request to get additional pages.\n * @param initialResponse - The initial response.\n * @param options - Options to set a resume state or custom polling interval.\n * @returns - A poller object to poll for operation state updates and eventually get the final response.\n */\n{{#if clientOverload}}\n{{#each overloadMap}}\nexport async function getLongRunningPoller<\n  TResult extends {{ this.finalResponses }}\n>(\n  client: Client,\n  initialResponse: {{ this.initalResponses }},\n  options?: CreateHttpPollerOptions<TResult, OperationState<TResult>>\n): Promise<SimplePollerLike<OperationState<TResult>, TResult>>;\n{{/each}}\n{{/if}}\nexport {{#unless useLegacyLro}}async {{/unless}}function getLongRunningPoller<TResult extends HttpResponse>(\n  client: Client,\n  initialResponse: TResult,\n  {{#if useLegacyLro}}\n  options: LroEngineOptions<TResult, PollOperationState<TResult>> = {}\n  ): PollerLike<PollOperationState<TResult>, TResult> {\n    {{else}}\n    options: CreateHttpPollerOptions<TResult, OperationState<TResult>> = {}\n    ): Promise<SimplePollerLike<OperationState<TResult>, TResult>> {\n    {{/if}}  \n    const poller: LongRunningOperation<TResult> = {\n    requestMethod: initialResponse.request.method,\n    requestPath: initialResponse.request.url,\n    sendInitialRequest: async () => {\n      // In the case of Rest Clients we are building the LRO poller object from a response that's the reason\n      // we are not triggering the initial request here, just extracting the information from the\n      // response we were provided.\n      return getLroResponse(initialResponse);\n    },\n    sendPollRequest: async path => {\n      // This is the callback that is going to be called to poll the service\n      // to get the latest status. We use the client provided and the polling path\n      // which is an opaque URL provided by caller, the service sends this in one of the following headers: operation-location, azure-asyncoperation or location\n      // depending on the lro pattern that the service implements. If non is provided we default to the initial path.\n      const response = await client\n        .pathUnchecked(path ?? initialResponse.request.url)\n        .get();\n      const lroResponse = getLroResponse(response as TResult);\n      lroResponse.rawResponse.headers[\"x-ms-original-url\"] =\n        initialResponse.request.url;\n      return lroResponse;\n    }\n  };\n\n  {{#if useLegacyLro}}\n  return new LroEngine(poller, options);\n  {{else}}\n  options.resolveOnUnsuccessful = options.resolveOnUnsuccessful ?? true;\n  return createHttpPoller(poller, options);\n  {{/if}}\n}\n\n/**\n * Converts a Rest Client response to a response that the LRO implementation understands\n * @param response - a rest client http response\n * @returns - An LRO response that the LRO implementation understands\n */\nfunction getLroResponse<TResult extends HttpResponse>(\n  response: TResult\n): LroResponse<TResult> {\n  if (Number.isNaN(response.status)) {\n    throw new TypeError(\n      `Status code of the response is not a number. Value: ${response.status}`\n    );\n  }\n\n  return {\n    flatResponse: response,\n    rawResponse: {\n      ...response,\n      statusCode: Number.parseInt(response.status),\n      body: response.body\n    }\n  };\n}\n";
+export declare const pollingContent = "\nimport { Client, HttpResponse } from \"@azure-rest/core-client\";\nimport { AbortSignalLike } from \"@azure/abort-controller\";\nimport {\n  CancelOnProgress,\n  CreateHttpPollerOptions,\n  LongRunningOperation,\n  OperationResponse,\n  OperationState,\n  createHttpPoller,\n} from \"@azure/core-lro\";\n{{#if clientOverload}}\nimport {\n  {{#each importedResponses}}\n  {{this}},\n  {{/each}}\n} from \"./responses{{#if isEsm}}.js{{/if}}\";\n{{/if}}\n\n/**\n * A simple poller that can be used to poll a long running operation.\n */\nexport interface SimplePollerLike<\n  TState extends OperationState<TResult>,\n  TResult\n> {\n  /**\n   * Returns true if the poller has finished polling.\n   */\n  isDone(): boolean;\n  /**\n   * Returns true if the poller is stopped.\n   */\n  isStopped(): boolean;\n  /**\n   * Returns the state of the operation.\n   */\n  getOperationState(): TState;\n  /**\n   * Returns the result value of the operation,\n   * regardless of the state of the poller.\n   * It can return undefined or an incomplete form of the final TResult value\n   * depending on the implementation.\n   */\n  getResult(): TResult | undefined;\n  /**\n   * Returns a promise that will resolve once a single polling request finishes.\n   * It does this by calling the update method of the Poller's operation.\n   */\n  poll(options?: { abortSignal?: AbortSignalLike }): Promise<TState>;\n  /**\n   * Returns a promise that will resolve once the underlying operation is completed.\n   */\n  pollUntilDone(pollOptions?: {\n    abortSignal?: AbortSignalLike;\n  }): Promise<TResult>;\n  /**\n   * Invokes the provided callback after each polling is completed,\n   * sending the current state of the poller's operation.\n   *\n   * It returns a method that can be used to stop receiving updates on the given callback function.\n   */\n  onProgress(callback: (state: TState) => void): CancelOnProgress;\n\n  /**\n   * Returns a promise that could be used for serialized version of the poller's operation\n   * by invoking the operation's serialize method.\n   */\n  serialize(): Promise<string>;\n\n  /**\n   * Wait the poller to be submitted.\n   */\n  submitted(): Promise<void>;\n\n  /**\n   * Returns a string representation of the poller's operation. Similar to serialize but returns a string.\n   * @deprecated Use serialize() instead.\n   */\n  toString(): string;\n\n  /**\n   * Stops the poller from continuing to poll. Please note this will only stop the client-side polling\n   * @deprecated Use abortSignal to stop polling instead.\n   */\n  stopPolling(): void;\n}\n\n/**\n * Helper function that builds a Poller object to help polling a long running operation.\n * @param client - Client to use for sending the request to get additional pages.\n * @param initialResponse - The initial response.\n * @param options - Options to set a resume state or custom polling interval.\n * @returns - A poller object to poll for operation state updates and eventually get the final response.\n */\n{{#if clientOverload}}\n{{#each overloadMap}}\nexport async function getLongRunningPoller<\n  TResult extends {{ this.finalResponses }}\n>(\n  client: Client,\n  initialResponse: {{ this.initialResponses }},\n  options?: CreateHttpPollerOptions<TResult, OperationState<TResult>>\n): Promise<SimplePollerLike<OperationState<TResult>, TResult>>;\n{{/each}}\n{{/if}}\nexport async function getLongRunningPoller<TResult extends HttpResponse>(\n    client: Client,\n    initialResponse: TResult,\n    options: CreateHttpPollerOptions<TResult, OperationState<TResult>> = {}\n    ): Promise<SimplePollerLike<OperationState<TResult>, TResult>> { \n  const abortController = new AbortController();\n  const poller: LongRunningOperation<TResult> = {\n    sendInitialRequest: async () => {\n      // In the case of Rest Clients we are building the LRO poller object from a response that's the reason\n      // we are not triggering the initial request here, just extracting the information from the\n      // response we were provided.\n      return getLroResponse(initialResponse);\n    },\n    sendPollRequest: async (\n      path,\n      options?: { abortSignal?: AbortSignalLike }\n    ) => {\n      // This is the callback that is going to be called to poll the service\n      // to get the latest status. We use the client provided and the polling path\n      // which is an opaque URL provided by caller, the service sends this in one of the following headers: operation-location, azure-asyncoperation or location\n      // depending on the lro pattern that the service implements. If non is provided we default to the initial path.\n      function abortListener(): void {\n        abortController.abort();\n      }\n      const inputAbortSignal = options?.abortSignal;\n      const abortSignal = abortController.signal;\n      if (inputAbortSignal?.aborted) {\n        abortController.abort();\n      } else if (!abortSignal.aborted) {\n        inputAbortSignal?.addEventListener(\"abort\", abortListener, {\n          once: true\n        });\n      }\n      let response;\n      try {\n        response = await client\n          .pathUnchecked(path ?? initialResponse.request.url)\n          .get({ abortSignal });\n      } finally {\n        inputAbortSignal?.removeEventListener(\"abort\", abortListener);\n      }\n      const lroResponse = getLroResponse(response as TResult);\n      lroResponse.rawResponse.headers[\"x-ms-original-url\"] =\n        initialResponse.request.url;\n      return lroResponse;\n    }\n  };\n\n  options.resolveOnUnsuccessful = options.resolveOnUnsuccessful ?? true;\n  const httpPoller = createHttpPoller(poller, options);\n  const simplePoller: SimplePollerLike<OperationState<TResult>, TResult> = {\n    isDone() {\n      return httpPoller.isDone;\n    },\n    isStopped() {\n      return httpPoller.isStopped;\n    },\n    getOperationState() {\n      if (!httpPoller.operationState) {\n        throw new Error(\n          \"Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState().\"\n        );\n      }\n      return httpPoller.operationState;\n    },\n    getResult() {\n      return httpPoller.result;\n    },\n    toString() {\n      if (!httpPoller.operationState) {\n        throw new Error(\n          \"Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState().\"\n        );\n      }\n      return JSON.stringify({\n        state: httpPoller.operationState\n      });\n    },\n    stopPolling() {\n      abortController.abort();\n    },\n    onProgress: httpPoller.onProgress,\n    poll: httpPoller.poll,\n    pollUntilDone: httpPoller.pollUntilDone,\n    serialize: httpPoller.serialize,\n    submitted: httpPoller.submitted\n  };\n  return simplePoller;\n}\n\n/**\n * Converts a Rest Client response to a response that the LRO implementation understands\n * @param response - a rest client http response\n * @returns - An LRO response that the LRO implementation understands\n */\nfunction getLroResponse<TResult extends HttpResponse>(\n  response: TResult\n): OperationResponse<TResult>  {\n  if (Number.isNaN(response.status)) {\n    throw new TypeError(\n      `Status code of the response is not a number. Value: ${response.status}`\n    );\n  }\n\n  return {\n    flatResponse: response,\n    rawResponse: {\n      ...response,\n      statusCode: Number.parseInt(response.status),\n      body: response.body\n    }\n  };\n}\n";