@mindbase/node-tools 1.1.0 → 1.3.0

package/src/publish/core/dependency.js

@@ -0,0 +1,137 @@
+/**
+ * 依赖关系分析模块
+ * 分析包之间的依赖关系并计算发布顺序（拓扑排序）
+ */
+
+/**
+ * 分析包之间的依赖关系
+ * @param {Array<Object>} packages - 包列表
+ * @returns {Object} 分析结果
+ */
+function analyzeDependencies(packages) {
+  // 构建包名到包的映射
+  const packageMap = new Map();
+  for (const pkg of packages) {
+    packageMap.set(pkg.name, pkg);
+  }
+
+  // 构建依赖图
+  const graph = new Map();
+  const inDegree = new Map();
+
+  for (const pkg of packages) {
+    graph.set(pkg.name, new Set());
+    inDegree.set(pkg.name, 0);
+  }
+
+  // 分析依赖关系
+  for (const pkg of packages) {
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.peerDependencies
+    };
+
+    for (const depName of Object.keys(allDeps)) {
+      // 只关心内部依赖
+      if (packageMap.has(depName)) {
+        const adjList = graph.get(pkg.name);
+        if (!adjList.has(depName)) {
+          adjList.add(depName);
+          inDegree.set(depName, inDegree.get(depName) + 1);
+        }
+      }
+    }
+  }
+
+  // 拓扑排序（Kahn 算法）
+  const order = [];
+  const queue = [];
+
+  // 找出入度为 0 的节点
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(name);
+    }
+  }
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    order.push(current);
+
+    // 移除当前节点的所有出边
+    const neighbors = graph.get(current);
+    for (const neighbor of neighbors) {
+      const newDegree = inDegree.get(neighbor) - 1;
+      inDegree.set(neighbor, newDegree);
+
+      if (newDegree === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+
+  // 检测循环依赖
+  const hasCycle = order.length !== packages.length;
+  const cycles = hasCycle ? findCycles(graph, inDegree) : [];
+
+  // 将包名转换为包对象
+  const orderedPackages = order
+    .map(name => packageMap.get(name))
+    .filter(Boolean);
+
+  return {
+    order: orderedPackages,
+    hasCycle,
+    cycles,
+    graph
+  };
+}
+
+/**
+ * 查找循环依赖
+ * @param {Map} graph - 依赖图
+ * @param {Map} inDegree - 入度表
+ * @returns {Array<Array<string>>} 循环列表
+ */
+function findCycles(graph, inDegree) {
+  const cycles = [];
+  const visited = new Set();
+  const recursionStack = new Set();
+
+  function dfs(node, path) {
+    if (recursionStack.has(node)) {
+      // 找到循环
+      const cycleStart = path.indexOf(node);
+      const cycle = path.slice(cycleStart);
+      cycle.push(node);
+      cycles.push(cycle);
+      return;
+    }
+
+    if (visited.has(node)) {
+      return;
+    }
+
+    visited.add(node);
+    recursionStack.add(node);
+
+    const neighbors = graph.get(node) || new Set();
+    for (const neighbor of neighbors) {
+      dfs(neighbor, [...path, node]);
+    }
+
+    recursionStack.delete(node);
+  }
+
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, []);
+    }
+  }
+
+  return cycles;
+}
+
+module.exports = {
+  analyzeDependencies
+};

package/src/publish/core/detector.js

@@ -0,0 +1,76 @@
+/**
+ * 工作空间检测模块
+ * 检测当前目录是单项目还是工作空间（npm workspace/pnpm/lerna）
+ */
+
+const { existsSync, readFileSync } = require('fs');
+const { join } = require('path');
+
+/**
+ * 检测工作空间类型
+ * @param {string} rootPath - 项目根路径
+ * @returns {Promise<Object>} 检测结果
+ */
+async function detectWorkspace(rootPath) {
+  const packageJsonPath = join(rootPath, 'package.json');
+
+  if (!existsSync(packageJsonPath)) {
+    return {
+      type: 'none',
+      patterns: []
+    };
+  }
+
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+
+  // 1. 检测 npm/yarn workspaces (package.json)
+  if (packageJson.workspaces) {
+    const patterns = Array.isArray(packageJson.workspaces)
+      ? packageJson.workspaces
+      : packageJson.workspaces.packages || [];
+
+    return {
+      type: 'npm',
+      patterns: patterns.length > 0 ? patterns : ['packages/*'],
+      packageJson
+    };
+  }
+
+  // 2. 检测 pnpm workspace
+  const pnpmWorkspacePath = join(rootPath, 'pnpm-workspace.yaml');
+  if (existsSync(pnpmWorkspacePath)) {
+    const yaml = require('js-yaml');
+    const pnpmConfig = yaml.load(readFileSync(pnpmWorkspacePath, 'utf-8'));
+    const patterns = pnpmConfig.packages || ['packages/*'];
+
+    return {
+      type: 'pnpm',
+      patterns,
+      packageJson
+    };
+  }
+
+  // 3. 检测 lerna
+  const lernaJsonPath = join(rootPath, 'lerna.json');
+  if (existsSync(lernaJsonPath)) {
+    const lernaConfig = JSON.parse(readFileSync(lernaJsonPath, 'utf-8'));
+    const patterns = lernaConfig.packages || ['packages/*'];
+
+    return {
+      type: 'lerna',
+      patterns,
+      packageJson
+    };
+  }
+
+  // 4. 单项目模式
+  return {
+    type: 'single',
+    patterns: [],
+    packageJson
+  };
+}
+
+module.exports = {
+  detectWorkspace
+};

package/src/publish/core/scanner.js

@@ -0,0 +1,91 @@
+/**
+ * 子项目扫描模块
+ * 扫描工作空间下的所有子项目
+ */
+
+const { readFileSync, existsSync } = require('fs');
+const { join } = require('path');
+const { globSync } = require('glob');
+
+/**
+ * 扫描工作空间中的所有包
+ * @param {string} rootPath - 工作空间根路径
+ * @param {Array<string>} patterns - glob 模式数组
+ * @returns {Array<Object>} 包列表
+ */
+async function scanPackages(rootPath, patterns) {
+  if (patterns.length === 0) {
+    // 单项目模式
+    return [scanSinglePackage(rootPath)];
+  }
+
+  const packages = [];
+  const seen = new Set(); // 避免重复
+
+  for (const pattern of patterns) {
+    const matches = globSync(pattern, {
+      cwd: rootPath,
+      absolute: true,
+      onlyDirectories: true
+    });
+
+    for (const match of matches) {
+      const packageJsonPath = join(match, 'package.json');
+
+      if (!existsSync(packageJsonPath)) {
+        continue;
+      }
+
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+
+      // 跳过 private 包
+      if (packageJson.private) {
+        continue;
+      }
+
+      // 避免重复
+      const key = `${packageJson.name}@${match}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+
+      packages.push({
+        name: packageJson.name,
+        version: packageJson.version,
+        path: match,
+        packageJson,
+        scripts: packageJson.scripts || {},
+        dependencies: packageJson.dependencies || {},
+        peerDependencies: packageJson.peerDependencies || {}
+      });
+    }
+  }
+
+  return packages;
+}
+
+/**
+ * 扫描单个项目
+ * @param {string} rootPath - 项目路径
+ * @returns {Object} 包信息
+ */
+function scanSinglePackage(rootPath) {
+  const packageJsonPath = join(rootPath, 'package.json');
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+
+  return {
+    name: packageJson.name,
+    version: packageJson.version,
+    path: rootPath,
+    packageJson,
+    scripts: packageJson.scripts || {},
+    dependencies: packageJson.dependencies || {},
+    peerDependencies: packageJson.peerDependencies || {}
+  };
+}
+
+module.exports = {
+  scanPackages,
+  scanSinglePackage
+};

package/src/publish/core/version.js

@@ -0,0 +1,80 @@
+/**
+ * 版本号管理模块
+ * 处理版本号升级和 package.json 更新
+ */
+
+const semver = require('semver');
+const { readFileSync, writeFileSync } = require('fs');
+const { join } = require('path');
+
+/**
+ * 升级版本号
+ * @param {string} version - 当前版本号
+ * @param {string} increment - 升级类型 (major/minor/patch/prerelease)
+ * @param {string} customVersion - 自定义版本号（当 increment 为 'custom' 时使用）
+ * @returns {string} 新版本号
+ */
+function bumpVersion(version, increment, customVersion = null) {
+  if (increment === 'custom') {
+    if (!customVersion) {
+      throw new Error('自定义版本号不能为空');
+    }
+    // 验证版本号格式
+    if (!semver.valid(customVersion)) {
+      throw new Error(`无效的版本号: ${customVersion}`);
+    }
+    return customVersion;
+  }
+
+  const newVersion = semver.inc(version, increment);
+  if (!newVersion) {
+    throw new Error(`无法升级版本号: ${version} + ${increment}`);
+  }
+
+  return newVersion;
+}
+
+/**
+ * 更新 package.json 的版本号
+ * @param {string} pkgPath - 包路径
+ * @param {string} newVersion - 新版本号
+ * @returns {Promise<void>}
+ */
+async function updatePackageJson(pkgPath, newVersion) {
+  const packageJsonPath = join(pkgPath, 'package.json');
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+
+  packageJson.version = newVersion;
+
+  writeFileSync(
+    packageJsonPath,
+    JSON.stringify(packageJson, null, 2) + '\n',
+    'utf-8'
+  );
+}
+
+/**
+ * 验证版本号是否有效
+ * @param {string} version - 版本号
+ * @returns {boolean} 是否有效
+ */
+function isValidVersion(version) {
+  return semver.valid(version) !== null;
+}
+
+/**
+ * 比较两个版本号
+ * @param {string} v1 - 版本号1
+ * @param {string} v2 - 版本号2
+ * @returns {number} 1(v1>v2), 0(v1=v2), -1(v1<v2)
+ */
+function compareVersions(v1, v2) {
+  return semver.compare(v1, v2);
+}
+
+module.exports = {
+  bumpVersion,
+  updatePackageJson,
+  isValidVersion,
+  compareVersions
+};

package/src/publish/publisher.js

@@ -0,0 +1,157 @@
+/**
+ * 发布编排器
+ * 协调构建、版本更新和多源发布
+ */
+
+const prompts = require('prompts');
+const chalk = require('chalk');
+const { detectBuildScripts, runBuild } = require('./core/builder.js');
+const { updatePackageJson } = require('./core/version.js');
+
+/**
+ * 发布编排器类
+ */
+class Publisher {
+  constructor(registryManager) {
+    this.registryManager = registryManager;
+  }
+
+  /**
+   * 多源发布（串行）
+   */
+  async publishToRegistries(pkg, registries, options) {
+    const results = [];
+
+    for (const { registry, token } of registries) {
+      const adapter = this.registryManager.createAdapter(registry, token);
+      const result = await adapter.publish(pkg, options);
+
+      results.push({
+        registry: registry.name,
+        success: result.success,
+        error: result.error
+      });
+
+      // 失败时询问是否继续
+      if (!result.success) {
+        const shouldContinue = await this.askPublishFailed(registry.name, result.error);
+        if (!shouldContinue) {
+          break;
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 单包发布流程
+   */
+  async publishPackage(pkg, registries, options) {
+    // 1. 检测构建脚本
+    const buildScript = detectBuildScripts(pkg.scripts);
+
+    // 2. 执行构建
+    if (buildScript) {
+      console.log(chalk.cyan(`\n执行构建: npm run ${buildScript}`));
+
+      const buildResult = await runBuild(pkg.path, buildScript);
+
+      if (!buildResult.success) {
+        const shouldContinue = await this.askBuildFailed(pkg.name, buildResult.error);
+        if (!shouldContinue) {
+          return { skipped: true, reason: '构建失败' };
+        }
+      }
+    }
+
+    // 3. 更新版本号
+    if (pkg.newVersion) {
+      console.log(chalk.cyan(`\n更新版本号: ${pkg.version} → ${pkg.newVersion}`));
+      await updatePackageJson(pkg.path, pkg.newVersion);
+    }
+
+    // 4. 多源发布
+    const publishResults = await this.publishToRegistries(pkg, registries, options);
+
+    return {
+      package: pkg.name,
+      buildSuccess: true,
+      publishResults
+    };
+  }
+
+  /**
+   * 批量发布（工作空间模式）
+   */
+  async publishPackages(packages, registries, options) {
+    const results = [];
+
+    for (const pkg of packages) {
+      console.log(chalk.bold(`\n[${results.length + 1}/${packages.length}] 发布: ${pkg.name}`));
+
+      const result = await this.publishPackage(pkg, registries, options);
+      results.push(result);
+
+      if (result.skipped) {
+        console.log(chalk.yellow(`跳过: ${result.reason}`));
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 构建失败询问
+   */
+  async askBuildFailed(packageName, error) {
+    console.log(chalk.red(`\n构建失败: ${packageName}`));
+    console.log(chalk.red(`错误: ${error}`));
+
+    const { choice } = await prompts({
+      type: 'select',
+      name: 'choice',
+      message: '是否继续发布？',
+      choices: [
+        { title: '重试构建', value: 'retry' },
+        { title: '跳过构建，继续发布', value: 'continue' },
+        { title: '取消', value: 'cancel' }
+      ],
+      initial: 1
+    });
+
+    if (choice === 'cancel') {
+      return false;
+    } else if (choice === 'retry') {
+      // TODO: 实现重试逻辑
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * 发布失败询问
+   */
+  async askPublishFailed(registryName, error) {
+    console.log(chalk.red(`\n发布到 ${registryName} 失败`));
+    console.log(chalk.red(`错误: ${error}`));
+
+    const { choice } = await prompts({
+      type: 'select',
+      name: 'choice',
+      message: '是否继续？',
+      choices: [
+        { title: '继续发布到其他源', value: 'continue' },
+        { title: '取消', value: 'cancel' }
+      ],
+      initial: 0
+    });
+
+    return choice === 'continue';
+  }
+}
+
+module.exports = {
+  Publisher
+};

package/src/publish/registry/adapters/base.js

@@ -0,0 +1,51 @@
+/**
+ * 基础适配器类
+ * 所有发布源适配器的基类
+ */
+
+class BaseAdapter {
+  /**
+   * @param {Object} config - 注册源配置
+   * @param {string} token - 认证 token
+   */
+  constructor(config, token) {
+    this.registry = config.url;
+    this.token = token;
+    this.type = config.type;
+    this.name = config.name;
+    this.id = config.id;
+  }
+
+  /**
+   * 发布包（必须实现）
+   * @param {Object} pkg - 包信息
+   * @param {Object} options - 发布选项
+   * @returns {Promise<Object>} 发布结果
+   */
+  async publish(pkg, options) {
+    throw new Error('publish() must be implemented by subclass');
+  }
+
+  /**
+   * 验证 token 有效性（必须实现）
+   * @returns {Promise<Object>} 验证结果
+   */
+  async validateToken() {
+    throw new Error('validateToken() must be implemented by subclass');
+  }
+
+  /**
+   * 检查包是否存在（可选）
+   * @param {string} name - 包名
+   * @param {string} version - 版本号
+   * @returns {Promise<Object>} 检查结果
+   */
+  async checkPackage(name, version) {
+    // 默认实现：不支持检查
+    return { supported: false };
+  }
+}
+
+module.exports = {
+  BaseAdapter
+};

package/src/publish/registry/adapters/codeup.js

@@ -0,0 +1,97 @@
+/**
+ * Codeup 适配器
+ * 支持发布到 Codeup 内部 npm 源
+ *
+ * 注意：这是一个示例实现，实际使用时需要根据 Codeup 的具体 API 调整
+ */
+
+const { BaseAdapter } = require('./base.js');
+
+class CodeupAdapter extends BaseAdapter {
+  /**
+   * 发布包到 Codeup
+   */
+  async publish(pkg, options) {
+    const { tag = 'latest', dryRun = false } = options;
+
+    if (dryRun) {
+      return { success: true, message: 'Dry run mode' };
+    }
+
+    try {
+      // TODO: 根据 Codeup 的实际 API 实现
+      // 这里提供一个示例实现框架
+
+      // 方式 1: 使用 npm CLI（如果 Codeup 兼容 npm registry）
+      // const { execaCommand } = require('execa');
+      // await execaCommand('npm publish --registry ' + this.registry, {
+      //   cwd: pkg.path,
+      //   env: { NPM_TOKEN: this.token }
+      // });
+
+      // 方式 2: 使用 Codeup 专用 API
+      // const response = await fetch(`${this.registry}/api/publish`, {
+      //   method: 'POST',
+      //   headers: {
+      //     'Authorization': `Bearer ${this.token}`,
+      //     'Content-Type': 'application/json'
+      //   },
+      //   body: JSON.stringify({
+      //     name: pkg.name,
+      //     version: pkg.version,
+      //     tag
+      //   })
+      // });
+
+      // 如果需要 fetch，请确保 Node 版本 >= 18 或安装 node-fetch
+      throw new Error('Codeup 适配器需要根据实际 API 实现发布逻辑');
+
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * 验证 token 有效性
+   */
+  async validateToken() {
+    try {
+      // TODO: 根据 Codeup 的实际 API 实现
+      // 示例：
+      // const response = await fetch(`${this.registry}/api/user/me`, {
+      //   headers: { 'Authorization': `Bearer ${this.token}` }
+      // });
+      // return response.ok
+      //   ? { valid: true }
+      //   : { valid: false, error: 'Invalid token' };
+
+      throw new Error('Codeup 适配器需要根据实际 API 实现 token 验证逻辑');
+
+    } catch (error) {
+      return {
+        valid: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * 检查包是否存在
+   */
+  async checkPackage(name, version) {
+    try {
+      // TODO: 根据 Codeup 的实际 API 实现
+      throw new Error('Codeup 适配器需要根据实际 API 实现包检查逻辑');
+
+    } catch (error) {
+      return { exists: false, error: error.message };
+    }
+  }
+}
+
+module.exports = {
+  CodeupAdapter
+};