eslint-plugin-kqinfo 0.1.4

package/README.md

@@ -0,0 +1,116 @@
+# eslint-plugin-kqinfo
+
+KQInfo 通用 ESLint 规则集。
+
+## 已内置规则
+
+- `kqinfo/no-env-hardcoded-redirect`（[文档](docs/rules/no-env-hardcoded-redirect.md)）
+  - 禁止通过 `process.env.REMAX_APP_PLATFORM` 分支，并在分支内直接硬编码 `window.location.href/assign/replace` 跳转 URL；建议统一从 `@/config/env.ts` 读取跳转地址。
+- `kqinfo/no-direct-remax-app-env-check`（[文档](docs/rules/no-direct-remax-app-env-check.md)）
+  - 禁止在业务代码中直接使用 `process.env.REMAX_APP_ENV` 判断环境，应通过 `envService` 导出的函数判断。
+
+## 安装
+
+```bash
+yarn add -D eslint-plugin-kqinfo
+```
+
+## 使用
+
+### 方式一：推荐配置
+
+```js
+// .eslintrc.js
+module.exports = {
+  extends: ['plugin:kqinfo/recommended'],
+};
+```
+
+### 方式二：按规则单独启用
+
+```js
+// .eslintrc.js
+module.exports = {
+  plugins: ['kqinfo'],
+  rules: {
+    'kqinfo/no-env-hardcoded-redirect': 'error',
+    'kqinfo/no-direct-remax-app-env-check': 'error',
+  },
+};
+```
+
+## 第二条规则示例
+
+### 错误示例
+
+```ts
+if (process.env.REMAX_APP_ENV === 'production') {
+  doSomething();
+}
+```
+
+### 正确示例
+
+```ts
+import { isProd } from '@/utils/envService';
+
+if (isProd()) {
+  doSomething();
+}
+```
+
+## 规则示例
+
+### 错误示例
+
+```ts
+if (process.env.REMAX_APP_PLATFORM === 'production') {
+  window.location.href = 'https://wx.cqrenji.cn/hu-patients/p40005/#/pages/onlineQuery/index';
+} else {
+  window.location.href = 'https://wx.cqrenji.cn/hu-patients-dev/p40005/dev/#/pages/onlineQuery/index';
+}
+```
+
+### 正确示例
+
+```ts
+import { onlineQueryUrl } from '@/config/env';
+
+window.location.href = onlineQueryUrl;
+```
+
+## 本地测试
+
+```bash
+npm test
+```
+
+## 发布
+
+```bash
+# 1) 为本次变更新增 changeset 说明（会生成 .changeset/*.md）
+npm run changeset
+
+# 2) 生成版本号与 CHANGELOG.md
+npm run changeset:version
+
+# 3) 提交版本文件后发布到 npm
+npm run changeset:publish
+```
+
+## GitLab CI 自动发布（自部署）
+
+仓库已提供 `.gitlab-ci.yml`，包含 `test`、`release`、`publish` 三个阶段：
+
+- `test`：普通分支提交时执行 `npm test`。
+- `release`：默认分支 push 时，若存在 changeset，则自动执行 `changeset version`、提交版本变更并打 `vX.Y.Z` 标签。
+- `publish`：当推送 `v*` 标签时自动执行 `npm publish`。
+
+在 GitLab 项目变量中至少配置：
+
+- `RELEASE_GITLAB_TOKEN`：用于 push release commit 与 tag，建议使用具备 `write_repository` 权限的 Project Access Token。
+- `NPM_TOKEN`：npm 发布令牌。
+- `GITLAB_RELEASE_USER_NAME`（可选）：发布提交用户名，默认 `release-bot`。
+- `GITLAB_RELEASE_USER_EMAIL`（可选）：发布提交邮箱，默认 `release-bot@local`。
+
+建议将上述变量设置为 `Masked + Protected`，并仅允许受保护分支/标签触发发布。

package/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const noEnvHardcodedRedirect = require('./rules/no-env-hardcoded-redirect');
+const noDirectRemaxAppEnvCheck = require('./rules/no-direct-remax-app-env-check');
+
+module.exports = {
+  rules: {
+    'no-env-hardcoded-redirect': noEnvHardcodedRedirect,
+    'no-direct-remax-app-env-check': noDirectRemaxAppEnvCheck,
+  },
+  configs: {
+    recommended: {
+      plugins: ['kqinfo'],
+      rules: {
+        'kqinfo/no-env-hardcoded-redirect': 'error',
+        'kqinfo/no-direct-remax-app-env-check': 'error',
+      },
+    },
+  },
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "eslint-plugin-kqinfo",
+  "version": "0.1.4",
+  "description": "KQInfo ESLint 规则集",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "rules"
+  ],
+  "scripts": {
+    "test": "node tests/no-env-hardcoded-redirect.test.js && node tests/no-direct-remax-app-env-check.test.js",
+    "changeset": "changeset",
+    "changeset:version": "changeset version",
+    "changeset:publish": "changeset publish"
+  },
+  "peerDependencies": {
+    "eslint": ">=7"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "eslint": "^7.29.0"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "kqinfo",
+    "rules"
+  ],
+  "license": "UNLICENSED"
+}

package/rules/no-direct-remax-app-env-check.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const DEFAULT_ALLOW_FILE_PATTERNS = ['[/\\\\]envService\\.(js|jsx|ts|tsx)$'];
+
+function isIdentifier(node, name) {
+  return node && node.type === 'Identifier' && node.name === name;
+}
+
+function isStringLiteralNode(node, value) {
+  return node && node.type === 'Literal' && node.value === value;
+}
+
+function isRmaxAppEnvMember(node) {
+  if (!node || node.type !== 'MemberExpression') {
+    return false;
+  }
+
+  const objectNode = node.object;
+  const propertyNode = node.property;
+
+  if (
+    !objectNode ||
+    objectNode.type !== 'MemberExpression' ||
+    objectNode.computed ||
+    !isIdentifier(objectNode.object, 'process') ||
+    !isIdentifier(objectNode.property, 'env')
+  ) {
+    return false;
+  }
+
+  if (node.computed) {
+    return isStringLiteralNode(propertyNode, 'REMAX_APP_ENV');
+  }
+
+  return isIdentifier(propertyNode, 'REMAX_APP_ENV');
+}
+
+function isAllowedFile(filename, allowFileRegexList) {
+  if (!filename || filename === '<input>') {
+    return false;
+  }
+
+  for (let index = 0; index < allowFileRegexList.length; index += 1) {
+    if (allowFileRegexList[index].test(filename)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        '禁止在业务代码中直接使用 process.env.REMAX_APP_ENV 判断环境，应通过 envService 导出的函数判断。',
+      category: 'Best Practices',
+      recommended: false,
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allowFilePatterns: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      forbidden:
+        '禁止直接使用 process.env.REMAX_APP_ENV，请改为使用 envService 导出的环境判断函数。',
+    },
+  },
+  create(context) {
+    const option = context.options[0] || {};
+    const allowFilePatterns =
+      option.allowFilePatterns || DEFAULT_ALLOW_FILE_PATTERNS;
+    const allowFileRegexList = allowFilePatterns.map(
+      (pattern) => new RegExp(pattern),
+    );
+
+    const filename = context.getFilename();
+    if (isAllowedFile(filename, allowFileRegexList)) {
+      return {};
+    }
+
+    return {
+      MemberExpression(node) {
+        if (isRmaxAppEnvMember(node)) {
+          context.report({
+            node,
+            messageId: 'forbidden',
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-env-hardcoded-redirect.js

@@ -0,0 +1,243 @@
+'use strict';
+
+const URL_PREFIX_REGEXP = /^https?:\/\//i;
+
+function isIdentifier(node, name) {
+  return node && node.type === 'Identifier' && node.name === name;
+}
+
+function isStringLiteralNode(node, value) {
+  if (!node) {
+    return false;
+  }
+  if (node.type === 'Literal') {
+    return node.value === value;
+  }
+  return false;
+}
+
+function isEnvMember(node) {
+  if (!node || node.type !== 'MemberExpression') {
+    return false;
+  }
+
+  const objectNode = node.object;
+  const propertyNode = node.property;
+
+  return (
+    objectNode &&
+    objectNode.type === 'MemberExpression' &&
+    !objectNode.computed &&
+    isIdentifier(objectNode.object, 'process') &&
+    isIdentifier(objectNode.property, 'env') &&
+    ((node.computed &&
+      isStringLiteralNode(propertyNode, 'REMAX_APP_PLATFORM')) ||
+      (!node.computed && isIdentifier(propertyNode, 'REMAX_APP_PLATFORM')))
+  );
+}
+
+function walkAstNode(node, matcher) {
+  if (!node || typeof node !== 'object') {
+    return false;
+  }
+
+  if (matcher(node)) {
+    return true;
+  }
+
+  const keys = Object.keys(node);
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    if (key === 'parent') {
+      continue;
+    }
+
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (let itemIndex = 0; itemIndex < value.length; itemIndex += 1) {
+        const item = value[itemIndex];
+        if (
+          item &&
+          typeof item.type === 'string' &&
+          walkAstNode(item, matcher)
+        ) {
+          return true;
+        }
+      }
+      continue;
+    }
+
+    if (
+      value &&
+      typeof value.type === 'string' &&
+      walkAstNode(value, matcher)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function containsEnvPlatformCheck(node) {
+  return walkAstNode(node, isEnvMember);
+}
+
+function isWindowLocationMember(node) {
+  if (!node || node.type !== 'MemberExpression' || node.computed) {
+    return false;
+  }
+
+  const objectNode = node.object;
+  const propertyNode = node.property;
+
+  return (
+    objectNode &&
+    objectNode.type === 'MemberExpression' &&
+    !objectNode.computed &&
+    isIdentifier(objectNode.object, 'window') &&
+    isIdentifier(objectNode.property, 'location') &&
+    isIdentifier(propertyNode, 'href')
+  );
+}
+
+function isWindowLocationMethodCall(node) {
+  if (!node || node.type !== 'CallExpression') {
+    return false;
+  }
+
+  const calleeNode = node.callee;
+  if (
+    !calleeNode ||
+    calleeNode.type !== 'MemberExpression' ||
+    calleeNode.computed
+  ) {
+    return false;
+  }
+
+  return (
+    calleeNode.object &&
+    calleeNode.object.type === 'MemberExpression' &&
+    !calleeNode.object.computed &&
+    isIdentifier(calleeNode.object.object, 'window') &&
+    isIdentifier(calleeNode.object.property, 'location') &&
+    (isIdentifier(calleeNode.property, 'assign') ||
+      isIdentifier(calleeNode.property, 'replace'))
+  );
+}
+
+function isHardcodedUrlExpression(node) {
+  if (!node) {
+    return false;
+  }
+
+  if (node.type === 'Literal' && typeof node.value === 'string') {
+    return URL_PREFIX_REGEXP.test(node.value.trim());
+  }
+
+  if (node.type === 'TemplateLiteral') {
+    return node.quasis.some((quasiNode) =>
+      URL_PREFIX_REGEXP.test((quasiNode.value.cooked || '').trim()),
+    );
+  }
+
+  if (node.type === 'BinaryExpression' && node.operator === '+') {
+    return (
+      isHardcodedUrlExpression(node.left) ||
+      isHardcodedUrlExpression(node.right)
+    );
+  }
+
+  return false;
+}
+
+function containsHardcodedRedirectInBranch(node) {
+  return walkAstNode(node, (currentNode) => {
+    if (
+      currentNode.type === 'AssignmentExpression' &&
+      currentNode.operator === '=' &&
+      isWindowLocationMember(currentNode.left)
+    ) {
+      return isHardcodedUrlExpression(currentNode.right);
+    }
+
+    if (isWindowLocationMethodCall(currentNode)) {
+      return isHardcodedUrlExpression(currentNode.arguments[0]);
+    }
+
+    return false;
+  });
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: '禁止基于 REMAX_APP_PLATFORM 分支并硬编码跳转 URL',
+      category: 'Best Practices',
+      recommended: false,
+    },
+    schema: [],
+    messages: {
+      forbidden:
+        '禁止使用 process.env.REMAX_APP_PLATFORM 做分支并直接硬编码跳转 URL，请改为统一配置映射。',
+    },
+  },
+  create(context) {
+    return {
+      IfStatement(node) {
+        if (!containsEnvPlatformCheck(node.test)) {
+          return;
+        }
+
+        const hasRedirectInConsequent = containsHardcodedRedirectInBranch(
+          node.consequent,
+        );
+        const hasRedirectInAlternate = containsHardcodedRedirectInBranch(
+          node.alternate,
+        );
+
+        if (hasRedirectInConsequent && hasRedirectInAlternate) {
+          context.report({
+            node: node.test,
+            messageId: 'forbidden',
+          });
+        }
+      },
+      ConditionalExpression(node) {
+        if (!containsEnvPlatformCheck(node.test)) {
+          return;
+        }
+
+        const parentNode = node.parent;
+        if (
+          parentNode &&
+          parentNode.type === 'AssignmentExpression' &&
+          parentNode.right === node &&
+          isWindowLocationMember(parentNode.left) &&
+          (isHardcodedUrlExpression(node.consequent) ||
+            isHardcodedUrlExpression(node.alternate))
+        ) {
+          context.report({
+            node: node.test,
+            messageId: 'forbidden',
+          });
+          return;
+        }
+
+        if (
+          parentNode &&
+          isWindowLocationMethodCall(parentNode) &&
+          parentNode.arguments[0] === node &&
+          (isHardcodedUrlExpression(node.consequent) ||
+            isHardcodedUrlExpression(node.alternate))
+        ) {
+          context.report({
+            node: node.test,
+            messageId: 'forbidden',
+          });
+        }
+      },
+    };
+  },
+};