stop lintgpt spinners on error (#2553)

Author: Alexandre-Herve

package.json

@@ -2,7 +2,7 @@
   "name": "openapi-workspaces",
   "license": "MIT",
   "private": true,
-  "version": "0.53.2",
+  "version": "0.53.3",
   "workspaces": [
     "projects/json-pointer-helpers",
     "projects/openapi-io",

projects/fastify-capture/package.json

@@ -2,7 +2,7 @@
   "name": "@useoptic/fastify-capture",
   "license": "MIT",
   "packageManager": "[email protected]",
-  "version": "0.53.2",
+  "version": "0.53.3",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

projects/json-pointer-helpers/package.json

@@ -2,7 +2,7 @@
   "name": "@useoptic/json-pointer-helpers",
   "license": "MIT",
   "packageManager": "[email protected]",
-  "version": "0.53.2",
+  "version": "0.53.3",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

projects/openapi-io/package.json

@@ -2,7 +2,7 @@
   "name": "@useoptic/openapi-io",
   "license": "MIT",
   "packageManager": "[email protected]",
-  "version": "0.53.2",
+  "version": "0.53.3",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

projects/openapi-utilities/package.json

@@ -2,7 +2,7 @@
   "name": "@useoptic/openapi-utilities",
   "license": "MIT",
   "packageManager": "[email protected]",
-  "version": "0.53.2",
+  "version": "0.53.3",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

projects/optic/package.json

@@ -2,7 +2,7 @@
   "name": "@useoptic/optic",
   "license": "MIT",
   "packageManager": "[email protected]",
-  "version": "0.53.2",
+  "version": "0.53.3",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

projects/rulesets-base/package.json

@@ -2,7 +2,7 @@
   "name": "@useoptic/rulesets-base",
   "license": "MIT",
   "packageManager": "[email protected]",
-  "version": "0.53.2",
+  "version": "0.53.3",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

projects/standard-rulesets/package.json

@@ -2,7 +2,7 @@
   "name": "@useoptic/standard-rulesets",
   "license": "MIT",
   "packageManager": "[email protected]",
-  "version": "0.53.2",
+  "version": "0.53.3",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

projects/standard-rulesets/src/lintgpt/rules-helper.ts

@@ -82,11 +82,6 @@ export class LintgptRulesHelper {
 
     const ora = (await import('ora')).default;
 
-    for (const rule of rules) {
-      const rule_checksum = computeRuleChecksum(rule);
-      preparedRulesMap.set(rule_checksum, { rule, rule_checksum });
-    }
-
     let spinner = ora({
       text: this.getPrepSpinnerText({
         total: rules.length,
@@ -96,61 +91,71 @@ export class LintgptRulesHelper {
 
     spinner.start();
 
-    const getRulesWithoutPrep = () =>
-      [...preparedRulesMap.values()].filter(
-        ({ prep }) => !prep || prep.status === 'requested'
-      );
-
-    const maxTime = Date.now() + 3 * 60 * 1000;
+    try {
+      for (const rule of rules) {
+        const rule_checksum = computeRuleChecksum(rule);
+        preparedRulesMap.set(rule_checksum, { rule, rule_checksum });
+      }
 
-    let rulesWithoutPreps = getRulesWithoutPrep();
-    let firstRun = true;
-    const pollInterval = 2000;
+      const getRulesWithoutPrep = () =>
+        [...preparedRulesMap.values()].filter(
+          ({ prep }) => !prep || prep.status === 'requested'
+        );
 
-    while (rulesWithoutPreps.length && maxTime > Date.now()) {
-      if (!firstRun)
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      const maxTime = Date.now() + 3 * 60 * 1000;
 
-      const results = await this.client.getLintgptPreps(
-        rulesWithoutPreps.map((r) => r.rule_checksum)
-      );
+      let rulesWithoutPreps = getRulesWithoutPrep();
+      let firstRun = true;
+      const pollInterval = 2000;
 
-      for (const result of results.lintgpt_preps) {
-        preparedRulesMap.set(result.rule_checksum, {
-          ...preparedRulesMap.get(result.rule_checksum)!,
-          prep: result,
-        });
-      }
+      while (rulesWithoutPreps.length && maxTime > Date.now()) {
+        if (!firstRun)
+          await new Promise((resolve) => setTimeout(resolve, pollInterval));
 
-      rulesWithoutPreps = getRulesWithoutPrep();
+        const results = await this.client.getLintgptPreps(
+          rulesWithoutPreps.map((r) => r.rule_checksum)
+        );
 
-      if (firstRun && rulesWithoutPreps.length) {
-        const rulesToPrep = rulesWithoutPreps.map((r) => r.rule);
-        await this.client.requestLintgptPreps(rulesToPrep);
-      }
+        for (const result of results.lintgpt_preps) {
+          preparedRulesMap.set(result.rule_checksum, {
+            ...preparedRulesMap.get(result.rule_checksum)!,
+            prep: result,
+          });
+        }
 
-      spinner.text = this.getPrepSpinnerText({
-        total: rules.length,
-        evaluated: rules.length - rulesWithoutPreps.length,
-      });
+        rulesWithoutPreps = getRulesWithoutPrep();
 
-      firstRun = false;
-    }
+        if (firstRun && rulesWithoutPreps.length) {
+          const rulesToPrep = rulesWithoutPreps.map((r) => r.rule);
+          await this.client.requestLintgptPreps(rulesToPrep);
+        }
 
-    if (rulesWithoutPreps.length) {
-      spinner.warn(
-        `LintGPT: ${rulesWithoutPreps.length}/${rules.length} rules timed out`
-      );
-    } else {
-      spinner.succeed(
-        this.getPrepSpinnerText({
+        spinner.text = this.getPrepSpinnerText({
           total: rules.length,
           evaluated: rules.length - rulesWithoutPreps.length,
-        })
-      );
-    }
+        });
+
+        firstRun = false;
+      }
 
-    return preparedRulesMap;
+      if (rulesWithoutPreps.length) {
+        spinner.warn(
+          `LintGPT: ${rulesWithoutPreps.length}/${rules.length} rules timed out`
+        );
+      } else {
+        spinner.succeed(
+          this.getPrepSpinnerText({
+            total: rules.length,
+            evaluated: rules.length - rulesWithoutPreps.length,
+          })
+        );
+      }
+
+      return preparedRulesMap;
+    } catch (e) {
+      spinner.fail(`LintGPT: an error occured while preparing rules`);
+      throw e;
+    }
   }
 
   private getEvalSpinnerText = ({
@@ -174,17 +179,6 @@ export class LintgptRulesHelper {
 
     const ora = (await import('ora')).default;
 
-    for (const eval_request of eval_requests) {
-      const rule_checksum = eval_request.rule_checksum;
-      const node_checksum = computeNodeChecksum(eval_request);
-      const key = getEvalKey(rule_checksum, node_checksum);
-      evalsMap.set(key, {
-        eval_request,
-        rule_checksum,
-        node_checksum,
-      });
-    }
-
     let spinner = ora({
       text: this.getEvalSpinnerText({
         total: eval_requests.length,
@@ -194,84 +188,102 @@ export class LintgptRulesHelper {
 
     spinner.start();
 
-    const getRequestsWithoutEvals = () =>
-      [...evalsMap.values()].filter(
-        ({ rule_eval }) => !rule_eval || rule_eval.status === 'requested'
-      );
+    try {
+      for (const eval_request of eval_requests) {
+        const rule_checksum = eval_request.rule_checksum;
+        const node_checksum = computeNodeChecksum(eval_request);
+        const key = getEvalKey(rule_checksum, node_checksum);
+        evalsMap.set(key, {
+          eval_request,
+          rule_checksum,
+          node_checksum,
+        });
+      }
 
-    const maxTime = Date.now() + 5 * 60 * 1000;
+      const getRequestsWithoutEvals = () =>
+        [...evalsMap.values()].filter(
+          ({ rule_eval }) => !rule_eval || rule_eval.status === 'requested'
+        );
 
-    let requestsWithoutEvals = getRequestsWithoutEvals();
-    let firstRun = true;
-    let pollInterval0 = 0;
-    let pollInterval1 = 1000;
+      const maxTime = Date.now() + 5 * 60 * 1000;
 
-    while (requestsWithoutEvals.length && maxTime > Date.now()) {
-      if (!firstRun) {
-        pollInterval1 = pollInterval0 + pollInterval1;
-        pollInterval0 = pollInterval1 - pollInterval0;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval1));
-      }
+      let requestsWithoutEvals = getRequestsWithoutEvals();
+      let firstRun = true;
+      let pollInterval0 = 0;
+      let pollInterval1 = 1000;
 
-      const queryChunks = chunk(
-        requestsWithoutEvals.map((r) => ({
-          rule_checksum: r.rule_checksum,
-          node_checksum: r.node_checksum,
-        })),
-        20
-      );
-
-      const resultChunks = await Promise.all(
-        queryChunks.map((c) => this.client.getLintgptEvals(c))
-      );
-
-      const results = resultChunks.reduce(
-        (acc, val) => ({
-          lintgpt_evals: [...acc.lintgpt_evals, ...val.lintgpt_evals],
-        }),
-        { lintgpt_evals: [] }
-      );
-
-      for (const result of results.lintgpt_evals) {
-        const key = getEvalKey(result.rule_checksum, result.node_checksum);
-        if (!evalsMap.has(key)) {
-          continue;
+      while (requestsWithoutEvals.length && maxTime > Date.now()) {
+        if (!firstRun) {
+          pollInterval1 = pollInterval0 + pollInterval1;
+          pollInterval0 = pollInterval1 - pollInterval0;
+          await new Promise((resolve) => setTimeout(resolve, pollInterval1));
         }
-        evalsMap.set(key, {
-          ...evalsMap.get(key)!,
-          rule_eval: result,
-        });
-      }
 
-      requestsWithoutEvals = getRequestsWithoutEvals();
+        const queryChunks = chunk(
+          requestsWithoutEvals.map((r) => ({
+            rule_checksum: r.rule_checksum,
+            node_checksum: r.node_checksum,
+          })),
+          20
+        );
+
+        const resultChunks = await Promise.all(
+          queryChunks.map((c) => this.client.getLintgptEvals(c))
+        );
+
+        const results = resultChunks.reduce(
+          (acc, val) => ({
+            lintgpt_evals: [...acc.lintgpt_evals, ...val.lintgpt_evals],
+          }),
+          { lintgpt_evals: [] }
+        );
+
+        for (const result of results.lintgpt_evals) {
+          const key = getEvalKey(result.rule_checksum, result.node_checksum);
+          if (!evalsMap.has(key)) {
+            continue;
+          }
+          evalsMap.set(key, {
+            ...evalsMap.get(key)!,
+            rule_eval: result,
+          });
+        }
 
-      spinner.text = this.getEvalSpinnerText({
-        total: eval_requests.length,
-        evaluated: eval_requests.length - requestsWithoutEvals.length,
-      });
+        requestsWithoutEvals = getRequestsWithoutEvals();
+
+        spinner.text = this.getEvalSpinnerText({
+          total: eval_requests.length,
+          evaluated: eval_requests.length - requestsWithoutEvals.length,
+        });
+
+        if (firstRun && requestsWithoutEvals.length) {
+          const evalsToRequest = requestsWithoutEvals.map(
+            (r) => r.eval_request
+          );
+          await this.client.requestLintgptEvals(evalsToRequest);
+        }
 
-      if (firstRun && requestsWithoutEvals.length) {
-        const evalsToRequest = requestsWithoutEvals.map((r) => r.eval_request);
-        await this.client.requestLintgptEvals(evalsToRequest);
+        firstRun = false;
       }
 
-      firstRun = false;
-    }
+      if (requestsWithoutEvals.length) {
+        spinner.warn(
+          `LintGPT: ${requestsWithoutEvals.length}/${eval_requests.length} checks timed out`
+        );
+      } else {
+        spinner.succeed(
+          this.getEvalSpinnerText({
+            total: eval_requests.length,
+            evaluated: eval_requests.length - requestsWithoutEvals.length,
+          })
+        );
+      }
 
-    if (requestsWithoutEvals.length) {
-      spinner.warn(
-        `LintGPT: ${requestsWithoutEvals.length}/${eval_requests.length} checks timed out`
-      );
-    } else {
-      spinner.succeed(
-        this.getEvalSpinnerText({
-          total: eval_requests.length,
-          evaluated: eval_requests.length - requestsWithoutEvals.length,
-        })
-      );
+      return evalsMap;
+    } catch (e) {
+      spinner.fail('LintGPT: an error occured while running evals');
+      throw e;
     }
-
-    return evalsMap;
   }
 }