@azure/core-lro 2.3.2-alpha.20220923.1 → 2.4.0

package/dist/index.js

@@ -44,7 +44,7 @@ function setStateError(inputs) {
     };
 }
 function processOperationStatus(result) {
-    const { state, stateProxy, status } = result;
+    const { state, stateProxy, status, isDone, processResult, response, setErrorAsResult } = result;
     switch (status) {
         case "succeeded": {
             stateProxy.setSucceeded(state);
@@ -60,6 +60,15 @@ function processOperationStatus(result) {
             break;
         }
     }
+    if ((isDone === null || isDone === void 0 ? void 0 : isDone(response, state)) ||
+        (isDone === undefined &&
+            ["succeeded", "canceled"].concat(setErrorAsResult ? [] : ["failed"]).includes(status))) {
+        stateProxy.setResult(state, buildResult({
+            response,
+            state,
+            processResult,
+        }));
+    }
 }
 function buildResult(inputs) {
     const { processResult, response, state } = inputs;
@@ -69,7 +78,7 @@ function buildResult(inputs) {
  * Initiates the long-running operation.
  */
 async function initOperation(inputs) {
-    const { init, stateProxy, processResult, getOperationStatus, withOperationLocation } = inputs;
+    const { init, stateProxy, processResult, getOperationStatus, withOperationLocation, setErrorAsResult, } = inputs;
     const { operationLocation, resourceLocation, metadata, response } = await init();
     if (operationLocation)
         withOperationLocation === null || withOperationLocation === void 0 ? void 0 : withOperationLocation(operationLocation, false);
@@ -81,14 +90,7 @@ async function initOperation(inputs) {
     logger.verbose(`LRO: Operation description:`, config);
     const state = stateProxy.initState(config);
     const status = getOperationStatus({ response, state, operationLocation });
-    processOperationStatus({ state, status, stateProxy });
-    if (status === "succeeded") {
-        stateProxy.setResult(state, buildResult({
-            response,
-            state,
-            processResult,
-        }));
-    }
+    processOperationStatus({ state, status, stateProxy, response, setErrorAsResult, processResult });
     return state;
 }
 async function pollOperationHelper(inputs) {
@@ -99,11 +101,6 @@ async function pollOperationHelper(inputs) {
     }));
     const status = getOperationStatus(response, state);
     logger.verbose(`LRO: Status:\n\tPolling from: ${state.config.operationLocation}\n\tOperation status: ${status}\n\tPolling status: ${terminalStates.includes(status) ? "Stopped" : "Running"}`);
-    processOperationStatus({
-        status,
-        state,
-        stateProxy,
-    });
     if (status === "succeeded") {
         const resourceLocation = getResourceLocation(response, state);
         if (resourceLocation !== undefined) {
@@ -117,7 +114,7 @@ async function pollOperationHelper(inputs) {
 }
 /** Polls the long-running operation. */
 async function pollOperation(inputs) {
-    const { poll, state, stateProxy, options, getOperationStatus, getResourceLocation, getOperationLocation, withOperationLocation, getPollingInterval, processResult, updateState, setDelay, isDone, } = inputs;
+    const { poll, state, stateProxy, options, getOperationStatus, getResourceLocation, getOperationLocation, withOperationLocation, getPollingInterval, processResult, updateState, setDelay, isDone, setErrorAsResult, } = inputs;
     const { operationLocation } = state.config;
     if (operationLocation !== undefined) {
         const { response, status } = await pollOperationHelper({
@@ -129,15 +126,16 @@ async function pollOperation(inputs) {
             getResourceLocation,
             options,
         });
-        if ((isDone === null || isDone === void 0 ? void 0 : isDone(response, state)) ||
-            (isDone === undefined && ["succeeded", "canceled"].includes(status))) {
-            stateProxy.setResult(state, buildResult({
-                response,
-                state,
-                processResult,
-            }));
-        }
-        else {
+        processOperationStatus({
+            status,
+            response,
+            state,
+            stateProxy,
+            isDone,
+            processResult,
+            setErrorAsResult,
+        });
+        if (!terminalStates.includes(status)) {
             const intervalInMs = getPollingInterval === null || getPollingInterval === void 0 ? void 0 : getPollingInterval(response);
             if (intervalInMs)
                 setDelay(intervalInMs);
@@ -317,7 +315,7 @@ function getStatusFromInitialResponse(inputs) {
  * Initiates the long-running operation.
  */
 async function initHttpOperation(inputs) {
-    const { stateProxy, resourceLocationConfig, processResult, lro } = inputs;
+    const { stateProxy, resourceLocationConfig, processResult, lro, setErrorAsResult } = inputs;
     return initOperation({
         init: async () => {
             const response = await lro.sendInitialRequest();
@@ -334,6 +332,7 @@ async function initHttpOperation(inputs) {
             ? ({ flatResponse }, state) => processResult(flatResponse, state)
             : ({ flatResponse }) => flatResponse,
         getOperationStatus: getStatusFromInitialResponse,
+        setErrorAsResult,
     });
 }
 function getOperationLocation({ rawResponse }, state) {
@@ -383,7 +382,7 @@ function getResourceLocation({ flatResponse }, state) {
 }
 /** Polls the long-running operation. */
 async function pollHttpOperation(inputs) {
-    const { lro, stateProxy, options, processResult, updateState, setDelay, state } = inputs;
+    const { lro, stateProxy, options, processResult, updateState, setDelay, state, setErrorAsResult, } = inputs;
     return pollOperation({
         state,
         stateProxy,
@@ -402,6 +401,7 @@ async function pollHttpOperation(inputs) {
          * references an inner this, so we need to preserve a reference to it.
          */
         poll: async (location, inputOptions) => lro.sendPollRequest(location, inputOptions),
+        setErrorAsResult,
     });
 }
 
@@ -482,7 +482,7 @@ const createStateProxy$1 = () => ({
  * Returns a poller factory.
  */
 function buildCreatePoller(inputs) {
-    const { getOperationLocation, getStatusFromInitialResponse, getStatusFromPollResponse, getResourceLocation, getPollingInterval, } = inputs;
+    const { getOperationLocation, getStatusFromInitialResponse, getStatusFromPollResponse, getResourceLocation, getPollingInterval, resolveOnUnsuccessful, } = inputs;
     return async ({ init, poll }, options) => {
         const { processResult, updateState, withOperationLocation: withOperationLocationCallback, intervalInMs = POLL_INTERVAL_IN_MS, restoreFrom, } = options || {};
         const stateProxy = createStateProxy$1();
@@ -506,6 +506,7 @@ function buildCreatePoller(inputs) {
                 processResult,
                 getOperationStatus: getStatusFromInitialResponse,
                 withOperationLocation,
+                setErrorAsResult: !resolveOnUnsuccessful,
             });
         let resultPromise;
         let cancelJob;
@@ -549,10 +550,14 @@ function buildCreatePoller(inputs) {
                         return poller.getResult();
                     }
                     case "canceled": {
-                        throw new Error("Operation was canceled");
+                        if (!resolveOnUnsuccessful)
+                            throw new Error("Operation was canceled");
+                        return poller.getResult();
                     }
                     case "failed": {
-                        throw state.error;
+                        if (!resolveOnUnsuccessful)
+                            throw state.error;
+                        return poller.getResult();
                     }
                     case "notStarted":
                     case "running": {
@@ -579,12 +584,13 @@ function buildCreatePoller(inputs) {
                     setDelay: (pollIntervalInMs) => {
                         currentPollIntervalInMs = pollIntervalInMs;
                     },
+                    setErrorAsResult: !resolveOnUnsuccessful,
                 });
                 await handleProgressEvents();
-                if (state.status === "canceled") {
+                if (state.status === "canceled" && !resolveOnUnsuccessful) {
                     throw new Error("Operation was canceled");
                 }
-                if (state.status === "failed") {
+                if (state.status === "failed" && !resolveOnUnsuccessful) {
                     throw state.error;
                 }
             },
@@ -601,13 +607,14 @@ function buildCreatePoller(inputs) {
  * @returns an initialized poller
  */
 async function createHttpPoller(lro, options) {
-    const { resourceLocationConfig, intervalInMs, processResult, restoreFrom, updateState, withOperationLocation, } = options || {};
+    const { resourceLocationConfig, intervalInMs, processResult, restoreFrom, updateState, withOperationLocation, resolveOnUnsuccessful = false, } = options || {};
     return buildCreatePoller({
         getStatusFromInitialResponse,
         getStatusFromPollResponse: getOperationStatus,
         getOperationLocation,
         getResourceLocation,
         getPollingInterval: parseRetryAfter,
+        resolveOnUnsuccessful,
     })({
         init: async () => {
             const response = await lro.sendInitialRequest();
@@ -650,9 +657,10 @@ const createStateProxy = () => ({
     isSucceeded: (state) => Boolean(state.isCompleted && !state.isCancelled && !state.error),
 });
 class GenericPollOperation {
-    constructor(state, lro, lroResourceLocationConfig, processResult, updateState, isDone) {
+    constructor(state, lro, setErrorAsResult, lroResourceLocationConfig, processResult, updateState, isDone) {
         this.state = state;
         this.lro = lro;
+        this.setErrorAsResult = setErrorAsResult;
         this.lroResourceLocationConfig = lroResourceLocationConfig;
         this.processResult = processResult;
         this.updateState = updateState;
@@ -670,6 +678,7 @@ class GenericPollOperation {
                 stateProxy,
                 resourceLocationConfig: this.lroResourceLocationConfig,
                 processResult: this.processResult,
+                setErrorAsResult: this.setErrorAsResult,
             })));
         }
         const updateState = this.updateState;
@@ -690,6 +699,7 @@ class GenericPollOperation {
                 setDelay: (intervalInMs) => {
                     this.pollerConfig.intervalInMs = intervalInMs;
                 },
+                setErrorAsResult: this.setErrorAsResult,
             });
         }
         (_a = options === null || options === void 0 ? void 0 : options.fireProgress) === null || _a === void 0 ? void 0 : _a.call(options, this.state);
@@ -862,6 +872,8 @@ class Poller {
      * @param operation - Must contain the basic properties of `PollOperation<State, TResult>`.
      */
     constructor(operation) {
+        /** controls whether to throw an error if the operation failed or was canceled. */
+        this.resolveOnUnsuccessful = false;
         this.stopped = true;
         this.pollProgressCallbacks = [];
         this.operation = operation;
@@ -899,15 +911,10 @@ class Poller {
      */
     async pollOnce(options = {}) {
         if (!this.isDone()) {
-            try {
-                this.operation = await this.operation.update({
-                    abortSignal: options.abortSignal,
-                    fireProgress: this.fireProgress.bind(this),
-                });
-            }
-            catch (e) {
-                this.operation.state.error = e;
-            }
+            this.operation = await this.operation.update({
+                abortSignal: options.abortSignal,
+                fireProgress: this.fireProgress.bind(this),
+            });
         }
         this.processUpdatedState();
     }
@@ -951,22 +958,26 @@ class Poller {
     processUpdatedState() {
         if (this.operation.state.error) {
             this.stopped = true;
-            this.reject(this.operation.state.error);
-            throw this.operation.state.error;
+            if (!this.resolveOnUnsuccessful) {
+                this.reject(this.operation.state.error);
+                throw this.operation.state.error;
+            }
         }
         if (this.operation.state.isCancelled) {
             this.stopped = true;
-            const error = new PollerCancelledError("Operation was canceled");
-            this.reject(error);
-            throw error;
+            if (!this.resolveOnUnsuccessful) {
+                const error = new PollerCancelledError("Operation was canceled");
+                this.reject(error);
+                throw error;
+            }
         }
-        else if (this.isDone() && this.resolve) {
+        if (this.isDone() && this.resolve) {
             // If the poller has finished polling, this means we now have a result.
             // However, it can be the case that TResult is instantiated to void, so
             // we are not expecting a result anyway. To assert that we might not
             // have a result eventually after finishing polling, we cast the result
             // to TResult.
-            this.resolve(this.operation.state.result);
+            this.resolve(this.getResult());
         }
     }
     /**
@@ -1111,12 +1122,13 @@ class Poller {
  */
 class LroEngine extends Poller {
     constructor(lro, options) {
-        const { intervalInMs = POLL_INTERVAL_IN_MS, resumeFrom } = options || {};
+        const { intervalInMs = POLL_INTERVAL_IN_MS, resumeFrom, resolveOnUnsuccessful = false, isDone, lroResourceLocationConfig, processResult, updateState, } = options || {};
         const state = resumeFrom
             ? deserializeState(resumeFrom)
             : {};
-        const operation = new GenericPollOperation(state, lro, options === null || options === void 0 ? void 0 : options.lroResourceLocationConfig, options === null || options === void 0 ? void 0 : options.processResult, options === null || options === void 0 ? void 0 : options.updateState, options === null || options === void 0 ? void 0 : options.isDone);
+        const operation = new GenericPollOperation(state, lro, !resolveOnUnsuccessful, lroResourceLocationConfig, processResult, updateState, isDone);
         super(operation);
+        this.resolveOnUnsuccessful = resolveOnUnsuccessful;
         this.config = { intervalInMs: intervalInMs };
         operation.setPollerConfig(this.config);
     }