@qawolf/ci-sdk 1.1.1 → 1.2.0

package/dist/index.js

@@ -36,7 +36,7 @@ var defaultServiceBase = "https://app.qawolf.com/";
 
 // package.json
 var package_default = {
-  version: "1.1.1"};
+  version: "1.2.0"};
 
 // src/lib/sdk/defaults/userAgent.ts
 var defaultUserAgent = `ci-sdk/${package_default.version}`;
@@ -356,6 +356,29 @@ async function generateSignedUrlForTempTeamStorage(deps, apiConfig, config) {
 }
 __name(generateSignedUrlForTempTeamStorage, "generateSignedUrlForTempTeamStorage");
 
+// src/lib/sdk/domain/pollCiGreenlight/buildCompletedRunResult.ts
+function buildCompletedRunResult(status) {
+  if (status.greenlight) return {
+    greenlightStatus: status,
+    outcome: "success"
+  };
+  else return {
+    greenlightStatus: status,
+    outcome: "failed"
+  };
+}
+__name(buildCompletedRunResult, "buildCompletedRunResult");
+
+// src/lib/sdk/domain/pollCiGreenlight/consts.ts
+var pollCiGreenlightDefaults = {
+  abortOnSuperseded: false,
+  maxRetries: 10,
+  pollTimeout: 120 * 60 * 1e3,
+  retryInterval: 10 * 1e3,
+  runInProgressInterval: 30 * 1e3,
+  runUnderReviewInterval: 60 * 1e3
+};
+
 // src/lib/api/ci-greenlight.ts
 async function fetchCiGreenlightStatus({ apiKey, serviceBase, userAgent }, { runId }, { fetch: localFetch, log }) {
   try {
@@ -411,56 +434,61 @@ async function fetchCiGreenlightStatus({ apiKey, serviceBase, userAgent }, { run
 }
 __name(fetchCiGreenlightStatus, "fetchCiGreenlightStatus");
 
-// src/lib/sdk/domain/poll-ci-greenlight.ts
-var safeDefaults = {
-  abortOnSuperseded: false,
-  maxRetries: 10,
-  pollTimeout: 120 * 60 * 1e3,
-  retryInterval: 10 * 1e3,
-  runInProgressInterval: 30 * 1e3,
-  runUnderReviewInterval: 60 * 1e3
-};
-async function pollCiGreenlightStatus(deps, apiConfig, { onRunStageChanged = /* @__PURE__ */ __name(() => void 0, "onRunStageChanged"), runId, ...pollConfig }) {
-  let retries = 0;
+// src/lib/sdk/domain/pollCiGreenlight/iterator.ts
+async function* makePollCiGreenlightStatusIterator(deps, apiConfig, { runId, ...pollConfig }) {
   const { log } = deps;
-  const { abortOnSuperseded = safeDefaults.abortOnSuperseded, maxRetries = safeDefaults.maxRetries, pollTimeout = safeDefaults.pollTimeout, retryInterval = safeDefaults.retryInterval, runInProgressInterval = safeDefaults.runInProgressInterval, runUnderReviewInterval = safeDefaults.runUnderReviewInterval } = pollConfig;
-  let currentStatus = void 0;
+  const { maxRetries = pollCiGreenlightDefaults.maxRetries, pollTimeout = pollCiGreenlightDefaults.pollTimeout, retryInterval = pollCiGreenlightDefaults.retryInterval, runInProgressInterval = pollCiGreenlightDefaults.runInProgressInterval, runUnderReviewInterval = pollCiGreenlightDefaults.runUnderReviewInterval } = pollConfig;
+  let retries = 0;
+  let previousStatus = void 0;
   const startedAt = Date.now();
-  let hasTimedOut = false;
-  while (!(hasTimedOut = Date.now() - startedAt > pollTimeout)) {
+  while (Date.now() - startedAt <= pollTimeout) {
     const responseState = await fetchCiGreenlightStatus(apiConfig, {
       runId
     }, deps);
+    const elapsedMs = Date.now() - startedAt;
     if (!responseState.ok && !responseState.canRetry) {
-      log.error(`\u{1F6AB} Unrecoverable error (status ${responseState.httpStatus}) from CI greenlight, aborting.`);
-      return {
+      yield {
         abortReason: "4XX-client-error",
+        elapsedMs,
         httpStatus: responseState.httpStatus,
-        outcome: "aborted"
+        isAborted: true
       };
+      return;
     }
     if (!responseState.ok) {
       retries += 1;
+      const { errorType, httpStatus } = responseState;
       if (retries > maxRetries) {
-        log.error(`\u{1F6AB} Unrecoverable error${responseState.httpStatus ? ` (status ${responseState.httpStatus})` : ""} from CI greenlight, aborting after ${maxRetries} attempts.`);
-        if (responseState.errorType === "network") {
-          return {
-            abortReason: "network-error",
-            httpStatus: void 0,
-            outcome: "aborted"
-          };
+        switch (errorType) {
+          case "network":
+            yield {
+              abortReason: "network-error",
+              elapsedMs,
+              httpStatus: void 0,
+              isAborted: true
+            };
+            break;
+          case "not-found":
+            yield {
+              abortReason: "404-run-not-found",
+              elapsedMs,
+              httpStatus: httpStatus ?? 404,
+              isAborted: true
+            };
+            break;
+          case "server":
+            yield {
+              abortReason: "5XX-server-error",
+              elapsedMs,
+              httpStatus: httpStatus ?? 500,
+              isAborted: true
+            };
+            break;
+          default:
+            throw Error(`Unexpected error type: ${errorType}`);
         }
-        let abortReason = "XXX-other-http-code";
-        if (responseState.errorType === "not-found") abortReason = "404-run-not-found";
-        else if (responseState.errorType === "server") abortReason = "5XX-server-error";
-        else ;
-        return {
-          abortReason,
-          httpStatus: responseState.httpStatus,
-          outcome: "aborted"
-        };
+        return;
       }
-      const { errorType, httpStatus } = responseState;
       const retryLabel = `${httpStatus ? ` (status ${httpStatus})` : ""}, will try again... (${retries}/${maxRetries})`;
       if (errorType === "network") log.warn(`\u274C Network error${retryLabel}`);
       else if (errorType === "not-found") log.info(`\u23F3 Run not found${retryLabel}`);
@@ -470,89 +498,231 @@ async function pollCiGreenlightStatus(deps, apiConfig, { onRunStageChanged = /*
     }
     retries = 0;
     const { greenlightStatus } = responseState;
-    const previousStatus = currentStatus;
-    currentStatus = greenlightStatus;
-    if (!previousStatus || previousStatus.runStage !== greenlightStatus.runStage) {
-      try {
-        await onRunStageChanged(greenlightStatus, previousStatus);
-      } catch (e) {
-        log.error(`Error in onRunStageChanged callback`, e);
-      }
-    }
-    const urlInfo = `See ${greenlightStatus.relevantRunUrl}`;
-    const { greenlight, relevantRunId, relevantRunUrl, relevantRunWithBugsUrl, rootRunId, rootRunUrl, runStage } = greenlightStatus;
-    if (rootRunId !== relevantRunId) {
-      const supersedingDetails = `
-  - Root: ${rootRunUrl}
-  - Superseding: ${relevantRunUrl}`;
-      if (abortOnSuperseded) {
-        log.warn(`\u274C Aborting due to superseded run (option 'abortOnSuperseded' is enabled).${supersedingDetails}`);
-        return {
-          abortReason: "superseded-run",
+    const stageChanged = !previousStatus || previousStatus.runStage !== greenlightStatus.runStage;
+    const isFailedTerminalStage = greenlightStatus.runStage === "canceled" || greenlightStatus.runStage === "completed" && greenlightStatus.greenlight === false;
+    yield {
+      elapsedMs,
+      isAborted: false,
+      isFailedTerminalStage,
+      previousStatus,
+      stageChanged,
+      status: greenlightStatus
+    };
+    previousStatus = greenlightStatus;
+    switch (greenlightStatus.runStage) {
+      case "canceled": {
+        yield {
+          abortReason: "run-canceled",
+          elapsedMs,
           httpStatus: void 0,
-          outcome: "aborted"
+          isAborted: true
         };
+        return;
       }
-      log.info(`Root run was superseded:${supersedingDetails}`);
+      case "completed":
+        return;
+      case "initializing":
+        await sleep(runInProgressInterval);
+        break;
+      case "underReview":
+        await sleep(runUnderReviewInterval);
+        break;
+      default:
+        throw Error(`Unexpected run stage: ${greenlightStatus}`);
     }
-    if (runStage === "completed") {
-      const { blockingBugsCount, blockingBugUrls = [], nonBlockingBugsCount, nonBlockingBugUrls = [] } = greenlightStatus;
-      const blockingBugList = blockingBugUrls.map((url) => `
+  }
+  yield {
+    abortReason: "poll-timed-out",
+    elapsedMs: Date.now() - startedAt,
+    httpStatus: void 0,
+    isAborted: true
+  };
+  return;
+}
+__name(makePollCiGreenlightStatusIterator, "makePollCiGreenlightStatusIterator");
+
+// src/lib/sdk/domain/pollCiGreenlight/logging.ts
+function buildSuccessLogMessage(status) {
+  const { nonBlockingBugsCount, relevantRunUrl } = status;
+  const urlInfo = `See ${relevantRunUrl}`;
+  return `\u2705 Run passed and no blocking bugs found${nonBlockingBugsCount > 0 ? ` and ${nonBlockingBugsCount} non-blocking bug${pluralize(nonBlockingBugsCount)} found` : ""}.
+${urlInfo}`;
+}
+__name(buildSuccessLogMessage, "buildSuccessLogMessage");
+function buildFailedLogMessage(status) {
+  const { blockingBugsCount, blockingBugUrls = [], nonBlockingBugsCount, nonBlockingBugUrls = [], relevantRunWithBugsUrl } = status;
+  const blockingBugList = blockingBugUrls.map((url) => `
 \u2022 ${url}`).join("");
-      const nonBlockingBugList = nonBlockingBugUrls.map((url) => `
+  const nonBlockingBugList = nonBlockingBugUrls.map((url) => `
 \u2022 ${url}`).join("");
-      const bugsListInText = `${blockingBugUrls.length > 0 ? `
+  const bugsListInText = `${blockingBugUrls.length > 0 ? `
 BLOCKING BUGS:${blockingBugList}` : ""}${nonBlockingBugUrls.length > 0 ? `
 NON BLOCKING BUGS:${nonBlockingBugList}` : ""}`;
-      if (greenlight) {
-        log.info(`\u2705 Run passed and no blocking bugs found${nonBlockingBugsCount > 0 ? ` and ${nonBlockingBugsCount} non-blocking bug${pluralize(nonBlockingBugsCount)} found` : ""}.
-${urlInfo}`);
-        return {
-          greenlightStatus,
-          outcome: "success"
-        };
-      } else {
-        log.warn(`\u274C Run failed and ${blockingBugsCount} blocking bug${pluralize(blockingBugsCount)} found${nonBlockingBugsCount ? ` and ${nonBlockingBugsCount} non-blocking bug${pluralize(nonBlockingBugsCount)}` : ""}.
+  return `\u274C Run failed and ${blockingBugsCount} blocking bug${pluralize(blockingBugsCount)} found${nonBlockingBugsCount ? ` and ${nonBlockingBugsCount} non-blocking bug${pluralize(nonBlockingBugsCount)}` : ""}.
 See ${relevantRunWithBugsUrl}
 You may review the priority of certain bugs to mark these non-blocking and retry the job.
-` + bugsListInText);
-        return {
-          greenlightStatus,
-          outcome: "failed"
-        };
-      }
-    }
-    if (runStage === "canceled") {
-      log.info(`\u{1F6AB} Run was canceled. Aborting... Please contact support.
-${urlInfo}`);
+` + bugsListInText;
+}
+__name(buildFailedLogMessage, "buildFailedLogMessage");
+function buildSupersededAbortLogMessage(rootRunUrl, relevantRunUrl) {
+  const supersedingDetails = `
+  - Root: ${rootRunUrl}
+  - Superseding: ${relevantRunUrl}`;
+  return `\u274C Aborting due to superseded run (option 'abortOnSuperseded' is enabled).${supersedingDetails}`;
+}
+__name(buildSupersededAbortLogMessage, "buildSupersededAbortLogMessage");
+function buildSupersededContinueLogMessage(rootRunUrl, relevantRunUrl) {
+  const supersedingDetails = `
+  - Root: ${rootRunUrl}
+  - Superseding: ${relevantRunUrl}`;
+  return `Root run was superseded:${supersedingDetails}`;
+}
+__name(buildSupersededContinueLogMessage, "buildSupersededContinueLogMessage");
+function buildRunStageLogMessage(runStage, relevantRunUrl) {
+  const urlInfo = `See ${relevantRunUrl}`;
+  switch (runStage) {
+    case "canceled":
+      return `\u{1F6AB} Run was canceled. Aborting... Please contact support.
+${urlInfo}`;
+    case "initializing":
+      return `\u23F3 Run is in progress... ${urlInfo}`;
+    case "underReview":
+      return `\u{1F575}\uFE0F  Run is under review... ${urlInfo}`;
+    case "completed":
+      throw Error("buildRunStageLogMessage should not be called for completed stage");
+    default:
+      throw Error(`Unexpected run stage: ${runStage}`);
+  }
+}
+__name(buildRunStageLogMessage, "buildRunStageLogMessage");
+
+// src/lib/sdk/domain/pollCiGreenlight/mapIteratorAbortToGreenlightStatus.ts
+function mapIteratorAbortToGreenlightStatus(iteration, pollTimeout, deps) {
+  const { log } = deps;
+  const { abortReason, httpStatus } = iteration;
+  switch (abortReason) {
+    case "4XX-client-error":
+      log.error(`\u{1F6AB} Unrecoverable error (status ${httpStatus}) from CI greenlight, aborting.`);
+      return {
+        abortReason,
+        httpStatus,
+        outcome: "aborted"
+      };
+    case "5XX-server-error":
+      log.error(`\u{1F6AB} Unrecoverable error (status ${httpStatus}) from CI greenlight, aborting.`);
+      return {
+        abortReason,
+        httpStatus,
+        outcome: "aborted"
+      };
+    case "404-run-not-found":
+      log.error(`\u{1F6AB} Unrecoverable error (status ${httpStatus}) from CI greenlight, aborting.`);
+      return {
+        abortReason,
+        httpStatus,
+        outcome: "aborted"
+      };
+    case "network-error":
+      log.error(`\u{1F6AB} Unrecoverable network error from CI greenlight, aborting.`);
+      return {
+        abortReason,
+        httpStatus: void 0,
+        outcome: "aborted"
+      };
+    case "poll-timed-out":
+      log.warn(`\u274C Poll timed out after ${pollTimeout / 1e3}s`);
+      return {
+        abortReason,
+        httpStatus: void 0,
+        outcome: "aborted"
+      };
+    case "run-canceled":
+      log.info(`Run was canceled`);
       return {
-        abortReason: "run-canceled",
+        abortReason,
         httpStatus: void 0,
         outcome: "aborted"
       };
+    case "XXX-other-http-code":
+      log.error(`\u{1F6AB} Unrecoverable error (status ${httpStatus}) from CI greenlight, aborting.`);
+      return {
+        abortReason,
+        httpStatus,
+        outcome: "aborted"
+      };
+    default:
+      throw Error(`Unexpected abort reason: ${abortReason}`);
+  }
+}
+__name(mapIteratorAbortToGreenlightStatus, "mapIteratorAbortToGreenlightStatus");
+
+// src/lib/sdk/domain/pollCiGreenlight/index.ts
+async function pollCiGreenlightStatus(deps, apiConfig, { onRunStageChanged = /* @__PURE__ */ __name(() => void 0, "onRunStageChanged"), runId, ...pollConfig }) {
+  const { log } = deps;
+  const { abortOnSuperseded = pollCiGreenlightDefaults.abortOnSuperseded, pollTimeout = pollCiGreenlightDefaults.pollTimeout } = pollConfig;
+  const iterator = makePollCiGreenlightStatusIterator(deps, apiConfig, {
+    runId,
+    ...pollConfig
+  });
+  for await (const lastPoll of iterator) {
+    if (lastPoll.isAborted) return mapIteratorAbortToGreenlightStatus(lastPoll, pollTimeout, deps);
+    const { previousStatus, stageChanged, status } = lastPoll;
+    if (stageChanged) {
+      try {
+        await onRunStageChanged(status, previousStatus);
+      } catch (e) {
+        log.error(`Error in onRunStageChanged callback`, e);
+      }
     }
-    if (hasTimedOut) {
-      log.warn(`\u274C Poll timed out after ${pollTimeout / 1e3}s. Aborting...`);
+    const { relevantRunId, relevantRunUrl, rootRunId, rootRunUrl, runStage } = status;
+    const isSuperseded = rootRunId !== relevantRunId;
+    const shouldAbortOnSuperseded = isSuperseded && abortOnSuperseded;
+    if (shouldAbortOnSuperseded) {
+      const message = buildSupersededAbortLogMessage(rootRunUrl, relevantRunUrl);
+      log.warn(message);
       return {
-        abortReason: "poll-timed-out",
+        abortReason: "superseded-run",
         httpStatus: void 0,
         outcome: "aborted"
       };
     }
-    if (runStage === "initializing") {
-      log.info(`\u23F3 Run is in progress... ${urlInfo}`);
-      await sleep(runInProgressInterval);
-    } else if (runStage === "underReview") {
-      log.info(`\u{1F575}\uFE0F  Run is under review... ${urlInfo}`);
-      await sleep(runUnderReviewInterval);
-    } else throw Error(`Unexpected run stage: ${runStage}`);
+    if (isSuperseded) {
+      const message = buildSupersededContinueLogMessage(rootRunUrl, relevantRunUrl);
+      log.info(message);
+    }
+    switch (runStage) {
+      case "canceled":
+      case "initializing":
+      case "underReview": {
+        log.info(buildRunStageLogMessage(runStage, relevantRunUrl));
+        break;
+      }
+      case "completed": {
+        const result = buildCompletedRunResult(status);
+        switch (result.outcome) {
+          case "aborted": {
+            break;
+          }
+          case "failed": {
+            const message = buildFailedLogMessage(status);
+            log.warn(message);
+            break;
+          }
+          case "success": {
+            const message = buildSuccessLogMessage(status);
+            log.info(message);
+            break;
+          }
+          default:
+            throw Error(`Unexpected outcome: ${result}`);
+        }
+        return result;
+      }
+      default:
+        throw Error(`Unexpected run stage: ${runStage}`);
+    }
   }
-  log.warn(`\u274C Poll timed out after ${pollTimeout / 1e3}s. Aborting...`);
-  return {
-    abortReason: "poll-timed-out",
-    httpStatus: void 0,
-    outcome: "aborted"
-  };
+  throw Error("Iterator ended unexpectedly");
 }
 __name(pollCiGreenlightStatus, "pollCiGreenlightStatus");
 
@@ -578,6 +748,7 @@ We recommend 'undici' package for that purpose. See the Requirement section of o
     attemptNotifyDeploy: attemptNotifyDeploy.bind(null, deps, apiConfig),
     generateSignedUrlForRunInputsExecutablesStorage: generateSignedUrlForRunInputsExecutablesStorage.bind(null, deps, apiConfig),
     generateSignedUrlForTempTeamStorage: generateSignedUrlForTempTeamStorage.bind(null, deps, apiConfig),
+    makePollCiGreenlightStatusIterator: makePollCiGreenlightStatusIterator.bind(null, deps, apiConfig),
     pollCiGreenlightStatus: pollCiGreenlightStatus.bind(null, deps, apiConfig)
   };
 }