@checkdigit/eslint-plugin 7.5.0 → 7.6.0-PR.75-5da1

package/dist-mjs/agent/add-assert-import.mjs

@@ -0,0 +1,58 @@
+// src/agent/add-assert-import.ts
+import { strict as assert } from "node:assert";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+var ruleId = "add-assert-import";
+var ASSERT_IMPORT_STATEMENT = "import { strict as assert } from 'node:assert';";
+var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Add import of assert module of node."
+    },
+    messages: {
+      addAssertImport: "Add import of assert module of node."
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    let isAssertImported = false;
+    let isAssertUsed = false;
+    return {
+      ImportDeclaration: (node) => {
+        if (node.source.value === "assert" || node.source.value === "node:assert") {
+          isAssertImported = true;
+        }
+      },
+      CallExpression: (callExpression) => {
+        if (callExpression.callee.type === AST_NODE_TYPES.Identifier && callExpression.callee.name === "assert" || callExpression.callee.type === AST_NODE_TYPES.MemberExpression && callExpression.callee.object.type === AST_NODE_TYPES.Identifier && callExpression.callee.object.name === "assert") {
+          isAssertUsed = true;
+        }
+      },
+      "Program:exit": (program) => {
+        if (isAssertUsed && !isAssertImported) {
+          const firstStatement = program.body[0];
+          assert(firstStatement);
+          context.report({
+            node: program,
+            messageId: "addAssertImport",
+            fix(fixer) {
+              return fixer.insertTextBefore(firstStatement, `${ASSERT_IMPORT_STATEMENT}
+`);
+            }
+          });
+        }
+      }
+    };
+  }
+});
+var add_assert_import_default = rule;
+export {
+  add_assert_import_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L2FkZC1hc3NlcnQtaW1wb3J0LnRzIl0sCiAgIm1hcHBpbmdzIjogIjtBQVFBLFNBQVMsVUFBVSxjQUFjO0FBRWpDLFNBQVMsZ0JBQWdCLG1CQUFtQjtBQUU1QyxPQUFPLHlCQUF5QjtBQUV6QixJQUFNLFNBQVM7QUFFdEIsSUFBTSwwQkFBMEI7QUFFaEMsSUFBTSxhQUFhLFlBQVksWUFBWSxDQUFDLFNBQVMsb0JBQW9CLElBQUksQ0FBQztBQUU5RSxJQUFNLE9BQWtELFdBQVc7QUFBQSxFQUNqRSxNQUFNO0FBQUEsRUFDTixNQUFNO0FBQUEsSUFDSixNQUFNO0FBQUEsSUFDTixNQUFNO0FBQUEsTUFDSixhQUFhO0FBQUEsSUFDZjtBQUFBLElBQ0EsVUFBVTtBQUFBLE1BQ1IsaUJBQWlCO0FBQUEsSUFDbkI7QUFBQSxJQUNBLFNBQVM7QUFBQSxJQUNULFFBQVEsQ0FBQztBQUFBLEVBQ1g7QUFBQSxFQUNBLGdCQUFnQixDQUFDO0FBQUEsRUFDakIsT0FBTyxTQUFTO0FBQ2QsUUFBSSxtQkFBbUI7QUFDdkIsUUFBSSxlQUFlO0FBRW5CLFdBQU87QUFBQSxNQUNMLG1CQUFtQixDQUFDLFNBQVM7QUFDM0IsWUFBSSxLQUFLLE9BQU8sVUFBVSxZQUFZLEtBQUssT0FBTyxVQUFVLGVBQWU7QUFDekUsNkJBQW1CO0FBQUEsUUFDckI7QUFBQSxNQUNGO0FBQUEsTUFDQSxnQkFBZ0IsQ0FBQyxtQkFBbUI7QUFFbEMsWUFDRyxlQUFlLE9BQU8sU0FBUyxlQUFlLGNBQWMsZUFBZSxPQUFPLFNBQVMsWUFDM0YsZUFBZSxPQUFPLFNBQVMsZUFBZSxvQkFDN0MsZUFBZSxPQUFPLE9BQU8sU0FBUyxlQUFlLGNBQ3JELGVBQWUsT0FBTyxPQUFPLFNBQVMsVUFDeEM7QUFDQSx5QkFBZTtBQUFBLFFBQ2pCO0FBQUEsTUFDRjtBQUFBLE1BQ0EsZ0JBQWdCLENBQUMsWUFBWTtBQUUzQixZQUFJLGdCQUFnQixDQUFDLGtCQUFrQjtBQUNyQyxnQkFBTSxpQkFBaUIsUUFBUSxLQUFLLENBQUM7QUFDckMsaUJBQU8sY0FBYztBQUNyQixrQkFBUSxPQUFPO0FBQUEsWUFDYixNQUFNO0FBQUEsWUFDTixXQUFXO0FBQUEsWUFDWCxJQUFJLE9BQU87QUFDVCxxQkFBTyxNQUFNLGlCQUFpQixnQkFBZ0IsR0FBRyx1QkFBdUI7QUFBQSxDQUFJO0FBQUEsWUFDOUU7QUFBQSxVQUNGLENBQUM7QUFBQSxRQUNIO0FBQUEsTUFDRjtBQUFBLElBQ0Y7QUFBQSxFQUNGO0FBQ0YsQ0FBQztBQUVELElBQU8sNEJBQVE7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist-mjs/agent/add-base-path-const.mjs

@@ -0,0 +1,65 @@
+// src/agent/add-base-path-const.ts
+import { strict as assert } from "node:assert";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+import { getProjectRootFolder, getSwaggerPathByIndexFile, isApiIndexFile, loadPackageJson, loadSwagger } from "./file.mjs";
+var ruleId = "add-base-path-const";
+var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Add BASE_PATH const variable."
+    },
+    messages: {
+      addBasePathConst: "Add BASE_PATH const variable."
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    return {
+      Program: (program) => {
+        if (!isApiIndexFile(context.filename)) {
+          return;
+        }
+        const scope = sourceCode.getScope(program).childScopes[0];
+        assert(scope);
+        const foundBasePathConst = scope.variables.find((variable) => variable.name === "BASE_PATH");
+        if (foundBasePathConst) {
+          return;
+        }
+        const swaggerPath = getSwaggerPathByIndexFile(context.filename);
+        const swaggerFileContents = loadSwagger(swaggerPath);
+        const baseUrlLine = swaggerFileContents.split("\n").find((line) => /^\s*-\s*url:\s*\/.*$/u.test(line) || /^basePath:.*/u.test(line));
+        const baseUrl = baseUrlLine?.split(":")[1]?.trim();
+        assert(baseUrl !== void 0);
+        const packageRoot = getProjectRootFolder(context.filename);
+        const packageJson = JSON.parse(loadPackageJson(packageRoot));
+        const serviceName = packageJson.name.split("/")[1];
+        assert(serviceName !== void 0);
+        const domain = `https://${serviceName}.checkdigit${baseUrl}`;
+        const lastImportStatement = program.body.findLast((node) => node.type === AST_NODE_TYPES.ImportDeclaration);
+        assert(lastImportStatement);
+        context.report({
+          messageId: "addBasePathConst",
+          node: program,
+          fix(fixer) {
+            return fixer.insertTextAfter(lastImportStatement, `
+export const BASE_PATH = '${domain}';
+`);
+          }
+        });
+      }
+    };
+  }
+});
+var add_base_path_const_default = rule;
+export {
+  add_base_path_const_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L2FkZC1iYXNlLXBhdGgtY29uc3QudHMiXSwKICAibWFwcGluZ3MiOiAiO0FBUUEsU0FBUyxVQUFVLGNBQWM7QUFFakMsU0FBUyxnQkFBZ0IsbUJBQTZCO0FBRXRELE9BQU8seUJBQXlCO0FBQ2hDLFNBQVMsc0JBQXNCLDJCQUEyQixnQkFBZ0IsaUJBQWlCLG1CQUFtQjtBQUV2RyxJQUFNLFNBQVM7QUFFdEIsSUFBTSxhQUFhLFlBQVksWUFBWSxDQUFDLFNBQVMsb0JBQW9CLElBQUksQ0FBQztBQUU5RSxJQUFNLE9BQW1ELFdBQVc7QUFBQSxFQUNsRSxNQUFNO0FBQUEsRUFDTixNQUFNO0FBQUEsSUFDSixNQUFNO0FBQUEsSUFDTixNQUFNO0FBQUEsTUFDSixhQUFhO0FBQUEsSUFDZjtBQUFBLElBQ0EsVUFBVTtBQUFBLE1BQ1Isa0JBQWtCO0FBQUEsSUFDcEI7QUFBQSxJQUNBLFNBQVM7QUFBQSxJQUNULFFBQVEsQ0FBQztBQUFBLEVBQ1g7QUFBQSxFQUNBLGdCQUFnQixDQUFDO0FBQUEsRUFDakIsT0FBTyxTQUFTO0FBQ2QsVUFBTSxhQUFhLFFBQVE7QUFFM0IsV0FBTztBQUFBLE1BQ0wsU0FBUyxDQUFDLFlBQThCO0FBQ3RDLFlBQUksQ0FBQyxlQUFlLFFBQVEsUUFBUSxHQUFHO0FBQ3JDO0FBQUEsUUFDRjtBQUVBLGNBQU0sUUFBUSxXQUFXLFNBQVMsT0FBTyxFQUFFLFlBQVksQ0FBQztBQUN4RCxlQUFPLEtBQUs7QUFFWixjQUFNLHFCQUFxQixNQUFNLFVBQVUsS0FBSyxDQUFDLGFBQWEsU0FBUyxTQUFTLFdBQVc7QUFDM0YsWUFBSSxvQkFBb0I7QUFDdEI7QUFBQSxRQUNGO0FBRUEsY0FBTSxjQUFjLDBCQUEwQixRQUFRLFFBQVE7QUFDOUQsY0FBTSxzQkFBc0IsWUFBWSxXQUFXO0FBQ25ELGNBQU0sY0FBYyxvQkFDakIsTUFBTSxJQUFJLEVBQ1YsS0FBSyxDQUFDLFNBQVMsd0JBQXdCLEtBQUssSUFBSSxLQUFLLGdCQUFnQixLQUFLLElBQUksQ0FBQztBQUNsRixjQUFNLFVBQVUsYUFBYSxNQUFNLEdBQUcsRUFBRSxDQUFDLEdBQUcsS0FBSztBQUNqRCxlQUFPLFlBQVksTUFBUztBQUU1QixjQUFNLGNBQWMscUJBQXFCLFFBQVEsUUFBUTtBQUN6RCxjQUFNLGNBQWMsS0FBSyxNQUFNLGdCQUFnQixXQUFXLENBQUM7QUFDM0QsY0FBTSxjQUFjLFlBQVksS0FBSyxNQUFNLEdBQUcsRUFBRSxDQUFDO0FBQ2pELGVBQU8sZ0JBQWdCLE1BQVM7QUFFaEMsY0FBTSxTQUFTLFdBQVcsV0FBVyxjQUFjLE9BQU87QUFFMUQsY0FBTSxzQkFBc0IsUUFBUSxLQUFLLFNBQVMsQ0FBQyxTQUFTLEtBQUssU0FBUyxlQUFlLGlCQUFpQjtBQUMxRyxlQUFPLG1CQUFtQjtBQUUxQixnQkFBUSxPQUFPO0FBQUEsVUFDYixXQUFXO0FBQUEsVUFDWCxNQUFNO0FBQUEsVUFDTixJQUFJLE9BQU87QUFDVCxtQkFBTyxNQUFNLGdCQUFnQixxQkFBcUI7QUFBQSw0QkFBK0IsTUFBTTtBQUFBLENBQU07QUFBQSxVQUMvRjtBQUFBLFFBQ0YsQ0FBQztBQUFBLE1BQ0g7QUFBQSxJQUNGO0FBQUEsRUFDRjtBQUNGLENBQUM7QUFFRCxJQUFPLDhCQUFROyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist-mjs/agent/add-base-path-import.mjs

@@ -0,0 +1,60 @@
+// src/agent/add-base-path-import.ts
+import { strict as assert } from "node:assert";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+import { getApiIndexPathByFilename } from "./file.mjs";
+var ruleId = "add-base-path-import";
+var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Add import of BASE_PATH if it is used but not imported."
+    },
+    messages: {
+      addBasePathImport: "Add import of BASE_PATH."
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    return {
+      Program: (program) => {
+        const isBasePathUsed = sourceCode.text.includes(`\${BASE_PATH}`);
+        if (isBasePathUsed) {
+          const topScope = sourceCode.getScope(program).childScopes[0];
+          assert(topScope);
+          if (topScope.variables.some((variable) => variable.name === "BASE_PATH")) {
+            return;
+          }
+          const apiIndexPath = getApiIndexPathByFilename(context.filename);
+          if (apiIndexPath !== void 0) {
+            const lastImportStatement = program.body.findLast(
+              (statement) => statement.type === AST_NODE_TYPES.ImportDeclaration
+            );
+            assert(lastImportStatement);
+            const basePathImportStatement = `
+import { BASE_PATH } from '${apiIndexPath}';
+`;
+            context.report({
+              node: program,
+              messageId: "addBasePathImport",
+              fix(fixer) {
+                return fixer.insertTextAfter(lastImportStatement, basePathImportStatement);
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+var add_base_path_import_default = rule;
+export {
+  add_base_path_import_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L2FkZC1iYXNlLXBhdGgtaW1wb3J0LnRzIl0sCiAgIm1hcHBpbmdzIjogIjtBQVFBLFNBQVMsVUFBVSxjQUFjO0FBRWpDLFNBQVMsZ0JBQWdCLG1CQUFtQjtBQUU1QyxPQUFPLHlCQUF5QjtBQUNoQyxTQUFTLGlDQUFpQztBQUVuQyxJQUFNLFNBQVM7QUFFdEIsSUFBTSxhQUFhLFlBQVksWUFBWSxDQUFDLFNBQVMsb0JBQW9CLElBQUksQ0FBQztBQUU5RSxJQUFNLE9BQW9ELFdBQVc7QUFBQSxFQUNuRSxNQUFNO0FBQUEsRUFDTixNQUFNO0FBQUEsSUFDSixNQUFNO0FBQUEsSUFDTixNQUFNO0FBQUEsTUFDSixhQUFhO0FBQUEsSUFDZjtBQUFBLElBQ0EsVUFBVTtBQUFBLE1BQ1IsbUJBQW1CO0FBQUEsSUFDckI7QUFBQSxJQUNBLFNBQVM7QUFBQSxJQUNULFFBQVEsQ0FBQztBQUFBLEVBQ1g7QUFBQSxFQUNBLGdCQUFnQixDQUFDO0FBQUEsRUFDakIsT0FBTyxTQUFTO0FBQ2QsVUFBTSxhQUFhLFFBQVE7QUFFM0IsV0FBTztBQUFBLE1BQ0wsU0FBUyxDQUFDLFlBQVk7QUFDcEIsY0FBTSxpQkFBaUIsV0FBVyxLQUFLLFNBQVMsZUFBZTtBQUMvRCxZQUFJLGdCQUFnQjtBQUNsQixnQkFBTSxXQUFXLFdBQVcsU0FBUyxPQUFPLEVBQUUsWUFBWSxDQUFDO0FBQzNELGlCQUFPLFFBQVE7QUFDZixjQUFJLFNBQVMsVUFBVSxLQUFLLENBQUMsYUFBYSxTQUFTLFNBQVMsV0FBVyxHQUFHO0FBQ3hFO0FBQUEsVUFDRjtBQUVBLGdCQUFNLGVBQWUsMEJBQTBCLFFBQVEsUUFBUTtBQUMvRCxjQUFJLGlCQUFpQixRQUFXO0FBQzlCLGtCQUFNLHNCQUFzQixRQUFRLEtBQUs7QUFBQSxjQUN2QyxDQUFDLGNBQWMsVUFBVSxTQUFTLGVBQWU7QUFBQSxZQUNuRDtBQUNBLG1CQUFPLG1CQUFtQjtBQUUxQixrQkFBTSwwQkFBMEI7QUFBQSw2QkFBZ0MsWUFBWTtBQUFBO0FBQzVFLG9CQUFRLE9BQU87QUFBQSxjQUNiLE1BQU07QUFBQSxjQUNOLFdBQVc7QUFBQSxjQUNYLElBQUksT0FBTztBQUNULHVCQUFPLE1BQU0sZ0JBQWdCLHFCQUFxQix1QkFBdUI7QUFBQSxjQUMzRTtBQUFBLFlBQ0YsQ0FBQztBQUFBLFVBQ0g7QUFBQSxRQUNGO0FBQUEsTUFDRjtBQUFBLElBQ0Y7QUFBQSxFQUNGO0FBQ0YsQ0FBQztBQUVELElBQU8sK0JBQVE7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist-mjs/agent/add-url-domain.mjs

@@ -0,0 +1,61 @@
+// src/agent/add-url-domain.ts
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+import { addBasePathUrlDomain } from "./url.mjs";
+var ruleId = "add-url-domain";
+var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Add HTTP domain to the BASE_PATH like url constant variable."
+    },
+    messages: {
+      addDomain: "Add HTTP domain to the BASE_PATH like url constant variable.",
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.'
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    return {
+      "VariableDeclarator[id.name=/^([A-Z]+_)*BASE_PATH$/]": (basePathDeclarator) => {
+        try {
+          if (basePathDeclarator.init === null || basePathDeclarator.init.type !== AST_NODE_TYPES.Literal && basePathDeclarator.init.type !== AST_NODE_TYPES.TemplateLiteral) {
+            return;
+          }
+          const urlText = sourceCode.getText(basePathDeclarator.init);
+          const replacement = addBasePathUrlDomain(urlText);
+          if (replacement !== urlText) {
+            context.report({
+              messageId: "addDomain",
+              node: basePathDeclarator.init,
+              fix(fixer) {
+                return fixer.replaceText(basePathDeclarator.init, replacement);
+              }
+            });
+          }
+        } catch (error) {
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: basePathDeclarator,
+            messageId: "unknownError",
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error)
+            }
+          });
+        }
+      }
+    };
+  }
+});
+var add_url_domain_default = rule;
+export {
+  add_url_domain_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L2FkZC11cmwtZG9tYWluLnRzIl0sCiAgIm1hcHBpbmdzIjogIjtBQVFBLFNBQVMsZ0JBQWdCLG1CQUE2QjtBQUV0RCxPQUFPLHlCQUF5QjtBQUNoQyxTQUFTLDRCQUE0QjtBQUU5QixJQUFNLFNBQVM7QUFFdEIsSUFBTSxhQUFhLFlBQVksWUFBWSxDQUFDLFNBQVMsb0JBQW9CLElBQUksQ0FBQztBQUU5RSxJQUFNLE9BQTZELFdBQVc7QUFBQSxFQUM1RSxNQUFNO0FBQUEsRUFDTixNQUFNO0FBQUEsSUFDSixNQUFNO0FBQUEsSUFDTixNQUFNO0FBQUEsTUFDSixhQUFhO0FBQUEsSUFDZjtBQUFBLElBQ0EsVUFBVTtBQUFBLE1BQ1IsV0FBVztBQUFBLE1BQ1gsY0FBYztBQUFBLElBQ2hCO0FBQUEsSUFDQSxTQUFTO0FBQUEsSUFDVCxRQUFRLENBQUM7QUFBQSxFQUNYO0FBQUEsRUFDQSxnQkFBZ0IsQ0FBQztBQUFBLEVBQ2pCLE9BQU8sU0FBUztBQUNkLFVBQU0sYUFBYSxRQUFRO0FBRTNCLFdBQU87QUFBQSxNQUNMLHVEQUF1RCxDQUFDLHVCQUFvRDtBQUMxRyxZQUFJO0FBQ0YsY0FDRSxtQkFBbUIsU0FBUyxRQUMzQixtQkFBbUIsS0FBSyxTQUFTLGVBQWUsV0FDL0MsbUJBQW1CLEtBQUssU0FBUyxlQUFlLGlCQUNsRDtBQUNBO0FBQUEsVUFDRjtBQUVBLGdCQUFNLFVBQVUsV0FBVyxRQUFRLG1CQUFtQixJQUFJO0FBQzFELGdCQUFNLGNBQWMscUJBQXFCLE9BQU87QUFFaEQsY0FBSSxnQkFBZ0IsU0FBUztBQUMzQixvQkFBUSxPQUFPO0FBQUEsY0FDYixXQUFXO0FBQUEsY0FDWCxNQUFNLG1CQUFtQjtBQUFBLGNBQ3pCLElBQUksT0FBTztBQUNULHVCQUFPLE1BQU0sWUFBWSxtQkFBbUIsTUFBdUIsV0FBVztBQUFBLGNBQ2hGO0FBQUEsWUFDRixDQUFDO0FBQUEsVUFDSDtBQUFBLFFBQ0YsU0FBUyxPQUFPO0FBRWQsa0JBQVEsTUFBTSxtQkFBbUIsTUFBTSxtQkFBbUIsUUFBUSxRQUFRLE1BQU0sS0FBSztBQUNyRixrQkFBUSxPQUFPO0FBQUEsWUFDYixNQUFNO0FBQUEsWUFDTixXQUFXO0FBQUEsWUFDWCxNQUFNO0FBQUEsY0FDSixVQUFVLFFBQVE7QUFBQSxjQUNsQixPQUFPLGlCQUFpQixRQUFRLE1BQU0sU0FBUyxJQUFJLEtBQUssVUFBVSxLQUFLO0FBQUEsWUFDekU7QUFBQSxVQUNGLENBQUM7QUFBQSxRQUNIO0FBQUEsTUFDRjtBQUFBLElBQ0Y7QUFBQSxFQUNGO0FBQ0YsQ0FBQztBQUVELElBQU8seUJBQVE7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist-mjs/agent/agent-test-wiring.mjs

@@ -0,0 +1,221 @@
+// src/agent/agent-test-wiring.ts
+import { strict as assert } from "node:assert";
+import { AST_TOKEN_TYPES, ESLintUtils, TSESTree } from "@typescript-eslint/utils";
+import debug from "debug";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+var ruleId = "agent-test-wiring";
+var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+var log = debug("eslint-plugin:agent:agent-test-wiring");
+var STATEMENT_FIXTURE_RESET = "fixture.reset()";
+var STATEMENT_FIXTURE_RESET_AWAITED = `await ${STATEMENT_FIXTURE_RESET};`;
+var STATEMENT_AGENT_DECLARATION = "let agent: Agent;";
+var STATEMENT_AGENT_CREATION = "agent = await createAgent();";
+var STATEMENT_AGENT_REGISTER = "agent.register(await fixturePlugin(fixture));";
+var STATEMENT_AGENT_ENABLE = "agent.enable();";
+var STATEMENT_AGENT_DISPOSE = "await agent[Symbol.asyncDispose]();";
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Update test wiring."
+    },
+    messages: {
+      updateTestWiring: "Updating test wiring.",
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.'
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  // eslint-disable-next-line max-lines-per-function
+  create(context) {
+    log("Processing file:", context.filename);
+    const sourceCode = context.sourceCode;
+    const importDeclarations = /* @__PURE__ */ new Map();
+    let isFixtureUsed = false;
+    let beforeAll;
+    let beforeEach;
+    let afterAll;
+    return {
+      ImportDeclaration(importDeclaration) {
+        const moduleName = importDeclaration.source.value;
+        importDeclarations.set(moduleName, importDeclaration);
+        if (moduleName === "@checkdigit/fixture" && importDeclaration.specifiers.some(
+          (specifier) => specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === TSESTree.AST_NODE_TYPES.Identifier && specifier.imported.name === "createFixture"
+        )) {
+          isFixtureUsed = true;
+        }
+      },
+      'CallExpression[callee.name="beforeAll"]': (callExpression) => {
+        beforeAll = callExpression;
+      },
+      'CallExpression[callee.name="beforeEach"]': (callExpression) => {
+        beforeEach = callExpression;
+      },
+      'CallExpression[callee.name="afterAll"]': (callExpression) => {
+        afterAll = callExpression;
+      },
+      // eslint-disable-next-line sonarjs/cognitive-complexity
+      "Program:exit"(program) {
+        if (!isFixtureUsed || beforeAll === void 0 && beforeEach === void 0) {
+          return;
+        }
+        try {
+          let jestImportFixer;
+          let agentImportFixer;
+          let fixturePluginImportFixer;
+          let agentDeclarationFixer;
+          let beforeAllOrEachFixer;
+          let afterAllFixer;
+          const lastImportDeclaration = [...importDeclarations.values()].at(-1);
+          assert.ok(lastImportDeclaration);
+          const jestImportDeclaration = importDeclarations.get("@jest/globals");
+          assert.ok(jestImportDeclaration);
+          const importsToAdd = ["afterAll", "beforeAll"].filter(
+            (jestHook) => !jestImportDeclaration.specifiers.some(
+              (specifier) => specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === TSESTree.AST_NODE_TYPES.Identifier && specifier.imported.name === jestHook
+            )
+          );
+          if (importsToAdd.length > 0) {
+            const firstImportSpecifier = jestImportDeclaration.specifiers[0];
+            assert.ok(firstImportSpecifier);
+            jestImportFixer = (fixer) => fixer.insertTextBefore(firstImportSpecifier, `${importsToAdd.join(", ")}, `);
+          }
+          const agentImportDeclaration = importDeclarations.get("@checkdigit/agent");
+          if (!agentImportDeclaration) {
+            agentImportFixer = (fixer) => fixer.insertTextAfter(
+              lastImportDeclaration,
+              `
+import createAgent, { type Agent } from '@checkdigit/agent';`
+            );
+          }
+          const pathLets = context.filename.split("/");
+          const currentFileIndex = pathLets.length - 1;
+          const pluginFolderIndex = pathLets.lastIndexOf("src") + 1;
+          const fixturePluginImportPath = `${"../".repeat(currentFileIndex - pluginFolderIndex)}plugin/fixture.test`;
+          if (!importDeclarations.get(fixturePluginImportPath)) {
+            fixturePluginImportFixer = (fixer) => fixer.insertTextAfter(lastImportDeclaration, `
+import fixturePlugin from '${fixturePluginImportPath}';`);
+          }
+          if (beforeAll === void 0) {
+            beforeAllOrEachFixer = (fixer) => fixer.insertTextBefore(
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+              beforeEach,
+              [
+                STATEMENT_AGENT_DECLARATION,
+                `beforeAll(async () => {`,
+                [STATEMENT_AGENT_CREATION, STATEMENT_AGENT_REGISTER, STATEMENT_AGENT_ENABLE].join("\n"),
+                `});
+`
+              ].join("\n")
+            );
+          } else {
+            const beforeAllArgument = beforeAll.arguments[0];
+            assert.ok(beforeAllArgument !== void 0);
+            if (!sourceCode.getText(beforeAllArgument).includes(STATEMENT_AGENT_CREATION)) {
+              if (beforeAllArgument.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression && beforeAllArgument.body.type === TSESTree.AST_NODE_TYPES.BlockStatement) {
+                const fixtureResetStatement = beforeAllArgument.body.body.find(
+                  (statement) => sourceCode.getText(statement) === STATEMENT_FIXTURE_RESET_AWAITED
+                );
+                assert.ok(fixtureResetStatement !== void 0);
+                beforeAllOrEachFixer = (fixer) => fixer.replaceText(
+                  fixtureResetStatement,
+                  [
+                    STATEMENT_AGENT_CREATION,
+                    STATEMENT_AGENT_REGISTER,
+                    STATEMENT_AGENT_ENABLE,
+                    STATEMENT_FIXTURE_RESET_AWAITED
+                  ].join("\n")
+                );
+              } else {
+                beforeAllOrEachFixer = (fixer) => fixer.replaceText(
+                  beforeAllArgument,
+                  [
+                    `async () => {`,
+                    STATEMENT_AGENT_CREATION,
+                    STATEMENT_AGENT_REGISTER,
+                    STATEMENT_AGENT_ENABLE,
+                    STATEMENT_FIXTURE_RESET_AWAITED,
+                    `}`
+                  ].join("\n")
+                );
+              }
+              agentDeclarationFixer = (fixer) => (
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                fixer.insertTextBefore(beforeAll, `${STATEMENT_AGENT_DECLARATION}
+`)
+              );
+            }
+          }
+          if (afterAll !== void 0) {
+            const afterAllArrowFunctionExpression = afterAll.arguments[0];
+            assert.ok(
+              afterAllArrowFunctionExpression !== void 0 && afterAllArrowFunctionExpression.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression
+            );
+            const arrowFunctionBody = afterAllArrowFunctionExpression.body;
+            assert.ok(arrowFunctionBody.type === TSESTree.AST_NODE_TYPES.BlockStatement);
+            const afterAllBodyText = sourceCode.getText(arrowFunctionBody);
+            if (!afterAllBodyText.includes(STATEMENT_AGENT_DISPOSE)) {
+              const lastStatement = arrowFunctionBody.body.at(-1);
+              assert.ok(lastStatement);
+              afterAllFixer = (fixer) => fixer.insertTextAfter(lastStatement, STATEMENT_AGENT_DISPOSE);
+            }
+          } else {
+            const nextToken = sourceCode.getTokenAfter(beforeAll ?? beforeEach);
+            afterAllFixer = (fixer) => fixer.insertTextAfter(
+              nextToken !== null && nextToken.type === AST_TOKEN_TYPES.Punctuator ? nextToken : (
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                beforeAll
+              ),
+              ["", `afterAll(async () => {`, STATEMENT_AGENT_DISPOSE, `});`].join("\n")
+            );
+          }
+          if (jestImportFixer !== void 0 || agentImportFixer !== void 0 || fixturePluginImportFixer !== void 0 || agentDeclarationFixer !== void 0 || beforeAllOrEachFixer !== void 0 || afterAllFixer !== void 0) {
+            context.report({
+              messageId: "updateTestWiring",
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+              node: beforeAll ?? beforeEach,
+              *fix(fixer) {
+                if (jestImportFixer !== void 0) {
+                  yield jestImportFixer(fixer);
+                }
+                if (agentImportFixer !== void 0) {
+                  yield agentImportFixer(fixer);
+                }
+                if (fixturePluginImportFixer !== void 0) {
+                  yield fixturePluginImportFixer(fixer);
+                }
+                if (agentDeclarationFixer !== void 0) {
+                  yield agentDeclarationFixer(fixer);
+                }
+                if (beforeAllOrEachFixer !== void 0) {
+                  yield beforeAllOrEachFixer(fixer);
+                }
+                if (afterAllFixer !== void 0) {
+                  yield afterAllFixer(fixer);
+                }
+              }
+            });
+          }
+        } catch (error) {
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: program,
+            messageId: "unknownError",
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error)
+            }
+          });
+        }
+      }
+    };
+  }
+});
+var agent_test_wiring_default = rule;
+export {
+  agent_test_wiring_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist-mjs/agent/fetch-response-body-json.mjs

@@ -0,0 +1,146 @@
+// src/agent/fetch-response-body-json.ts
+import { strict as assert } from "node:assert";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+import { getAncestor } from "../library/ts-tree.mjs";
+var ruleId = "fetch-response-body-json";
+var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: 'Replace "response.body" with "await response.json()".'
+    },
+    messages: {
+      refactorNeeded: "Please extract the fetch call and check its reponse status code before accessing its response body.",
+      replaceBodyWithJson: 'Replace "response.body" with "await response.json()".',
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.'
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const typeChecker = parserServices.program.getTypeChecker();
+    const allChanges = /* @__PURE__ */ new Map();
+    return {
+      'MemberExpression[property.name="body"]': (responseBodyNode) => {
+        try {
+          const responseNode = parserServices.esTreeNodeToTSNodeMap.get(responseBodyNode.object);
+          const responseType = typeChecker.getTypeAtLocation(responseNode);
+          const shouldReplace = responseType.getProperties().some((symbol) => symbol.name === "body") && responseType.getProperties().some((symbol) => symbol.name === "json");
+          if (shouldReplace) {
+            if (responseBodyNode.object.type !== AST_NODE_TYPES.Identifier) {
+              context.report({
+                node: responseBodyNode,
+                messageId: "refactorNeeded"
+              });
+              return;
+            }
+            const enclosingFunction = getAncestor(
+              responseBodyNode,
+              (node) => node.type === AST_NODE_TYPES.ArrowFunctionExpression || node.type === AST_NODE_TYPES.FunctionExpression || node.type === AST_NODE_TYPES.FunctionDeclaration
+            );
+            const enclosingStatement = getAncestor(
+              responseBodyNode,
+              (node) => (node.type === AST_NODE_TYPES.VariableDeclaration || node.type === AST_NODE_TYPES.ExpressionStatement || node.type === AST_NODE_TYPES.ReturnStatement) && node.parent.type === AST_NODE_TYPES.BlockStatement
+            );
+            const enclosingStatementIndex = enclosingFunction.body.body.indexOf(
+              enclosingStatement
+            );
+            const responseVariableName = responseBodyNode.object.name;
+            const isResponseBodyVariableDeclared = enclosingStatement.type === AST_NODE_TYPES.VariableDeclaration && enclosingStatement.declarations.some(
+              (declaration) => declaration.init === responseBodyNode || declaration.init?.type === AST_NODE_TYPES.TSAsExpression && declaration.init.expression === responseBodyNode
+            );
+            const responseBodyVariableName = isResponseBodyVariableDeclared ? enclosingStatement.declarations.find(
+              (declaration) => declaration.init === responseBodyNode || declaration.init?.type === AST_NODE_TYPES.TSAsExpression && declaration.init.expression === responseBodyNode
+            )?.id : `${responseBodyNode.object.name}Body`;
+            const change = {
+              enclosingFunction,
+              enclosingStatement,
+              enclosingStatementIndex,
+              responseVariableName,
+              responseBodyNode,
+              responseBodyVariableName,
+              isResponseBodyVariableDeclared
+            };
+            const changesByFunction = allChanges.get(enclosingFunction) ?? /* @__PURE__ */ new Map();
+            const changesByResponse = changesByFunction.get(responseVariableName) ?? [];
+            changesByResponse.push(change);
+            changesByFunction.set(responseVariableName, changesByResponse);
+            allChanges.set(enclosingFunction, changesByFunction);
+          }
+        } catch (error) {
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: responseBodyNode,
+            messageId: "unknownError",
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error)
+            }
+          });
+        }
+      },
+      "Program:exit": () => {
+        if (allChanges.size === 0) {
+          return;
+        }
+        const fixes = [];
+        for (const changesByFunction of allChanges.values()) {
+          for (const changesByResponse of changesByFunction.values()) {
+            const orderedChanges = changesByResponse.sort(
+              (changeA, changeB) => changeA.enclosingStatementIndex - changeB.enclosingStatementIndex
+            );
+            const firstChange = orderedChanges[0];
+            assert(firstChange);
+            const {
+              responseBodyNode,
+              responseVariableName,
+              responseBodyVariableName,
+              isResponseBodyVariableDeclared,
+              enclosingStatement
+            } = firstChange;
+            let remainingChanges;
+            if (!isResponseBodyVariableDeclared) {
+              fixes.push({
+                node: context.sourceCode.getTokenBefore(enclosingStatement),
+                text: `
+const ${responseBodyVariableName} = await ${responseVariableName}.json();`,
+                insert: true
+              });
+              remainingChanges = orderedChanges;
+            } else {
+              fixes.push({
+                node: responseBodyNode,
+                text: `await ${responseVariableName}.json()`,
+                insert: false
+              });
+              remainingChanges = orderedChanges.slice(1);
+            }
+            for (const change of remainingChanges) {
+              fixes.push({ node: change.responseBodyNode, text: responseBodyVariableName, insert: false });
+            }
+          }
+        }
+        for (const fix of fixes.reverse()) {
+          context.report({
+            node: fix.node,
+            messageId: "replaceBodyWithJson",
+            fix(fixer) {
+              return fix.insert ? fixer.insertTextAfter(fix.node, fix.text) : fixer.replaceText(fix.node, fix.text);
+            }
+          });
+        }
+      }
+    };
+  }
+});
+var fetch_response_body_json_default = rule;
+export {
+  fetch_response_body_json_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,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