@fastcar/cli 0.0.7 → 0.0.8

package/src/pack.js

@@ -0,0 +1,204 @@
+const fs = require("fs");
+const path = require("path");
+const process = require("process");
+const { execSync } = require("child_process");
+const utils = require("./utils");
+
+/**
+ * 检测可用的包管理器
+ * @returns {string} 包管理器名称 (npm/yarn/pnpm)
+ */
+function detectPackageManager() {
+  // 检查是否有 lock 文件来确定使用的包管理器
+  const cwd = process.cwd();
+  
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  // 默认使用 npm
+  return "npm";
+}
+
+/**
+ * 获取包管理器的安装命令
+ * @param {string} pm - 包管理器名称
+ * @returns {string} 安装命令
+ */
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "yarn":
+      return "yarn install --production --frozen-lockfile";
+    case "pnpm":
+      return "pnpm install --prod";
+    case "npm":
+    default:
+      return "npm install --production";
+  }
+}
+
+/**
+ * 检查包管理器是否已安装
+ * @param {string} pm - 包管理器名称
+ * @returns {boolean}
+ */
+function isPackageManagerInstalled(pm) {
+  if (pm === "npm") return true; // npm 随 Node.js 一起安装
+  
+  try {
+    execSync(`${pm} --version`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 打包项目，使用包管理器安装生产依赖
+ * @param {string} projectPath - 项目路径，默认为当前目录
+ * @param {string} outputPath - 输出路径，默认为项目目录下的 dist 文件夹
+ * @param {string} packageManager - 指定包管理器 (npm/yarn/pnpm)，不传则自动检测
+ */
+async function packProject(projectPath, outputPath, packageManager) {
+  const cwd = projectPath || process.cwd();
+
+  // 检查项目目录
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    console.log("❌ 未找到 package.json，请在项目根目录执行此命令");
+    return;
+  }
+
+  // 读取 package.json
+  let packageJson;
+  try {
+    packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  } catch (error) {
+    console.log("❌ 解析 package.json 失败:", error.message);
+    return;
+  }
+
+  // 确定包管理器
+  let pm = packageManager || detectPackageManager();
+  
+  // 检查指定的包管理器是否可用
+  if (!isPackageManagerInstalled(pm)) {
+    console.log(`⚠️  未找到 ${pm}，尝试使用 npm...`);
+    pm = "npm";
+  }
+
+  console.log("📦 开始打包项目...");
+  console.log(`   项目路径: ${cwd}`);
+  console.log(`   包管理器: ${pm}`);
+  
+  const deps = Object.keys(packageJson.dependencies || {});
+  console.log(`   生产依赖: ${deps.length} 个`);
+
+  // 确定输出路径
+  const projectName = packageJson.name || "project";
+  const version = packageJson.version || "0.0.0";
+  const folderName = path.basename(cwd);
+  const defaultOutputDir = outputPath || path.join(cwd, "dist");
+  const zipFileName = `${projectName}-${version}.zip`;
+  const zipFilePath = path.join(defaultOutputDir, zipFileName);
+
+  // 创建临时目录，使用项目文件夹名作为根目录名
+  const tempDir = path.join(cwd, `.pack-temp-${Date.now()}`);
+  const rootDir = path.join(tempDir, folderName);
+  
+  try {
+    fs.mkdirSync(rootDir, { recursive: true });
+    fs.mkdirSync(defaultOutputDir, { recursive: true });
+
+    // 复制项目文件到临时目录（排除 node_modules）
+    console.log("📋 正在复制项目文件...");
+    await copyProjectFiles(cwd, rootDir);
+
+    // 复制 lock 文件（如果存在）
+    const lockFiles = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml"];
+    for (const lockFile of lockFiles) {
+      const lockPath = path.join(cwd, lockFile);
+      if (fs.existsSync(lockPath)) {
+        fs.copyFileSync(lockPath, path.join(rootDir, lockFile));
+      }
+    }
+
+    // 执行安装生产依赖
+    console.log(`🗜️  正在使用 ${pm} 安装生产依赖...`);
+    const installCmd = getInstallCommand(pm);
+    try {
+      execSync(installCmd, { 
+        cwd: rootDir, 
+        stdio: "inherit" 
+      });
+    } catch (error) {
+      console.log(`⚠️  ${pm} 安装失败，尝试使用 npm...`);
+      execSync(getInstallCommand("npm"), { 
+        cwd: rootDir, 
+        stdio: "inherit" 
+      });
+    }
+
+    // 打包
+    console.log("📦 正在生成压缩包...");
+    if (fs.existsSync(zipFilePath)) {
+      fs.rmSync(zipFilePath);
+    }
+    await utils.zipFile(rootDir, zipFilePath);
+
+    console.log("✅ 打包完成!");
+    console.log(`   输出文件: ${zipFilePath}`);
+    console.log(`   解压目录: ${folderName}/`);
+
+    // 计算文件大小
+    const stats = fs.statSync(zipFilePath);
+    const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+    console.log(`   文件大小: ${sizeMB} MB`);
+  } catch (error) {
+    console.log("❌ 打包失败:", error.message);
+  } finally {
+    // 清理临时目录
+    if (fs.existsSync(tempDir)) {
+      utils.delDirEctory(tempDir);
+    }
+  }
+}
+
+/**
+ * 复制项目文件（排除 node_modules、dist、logs 和 .log 文件）
+ */
+async function copyProjectFiles(src, dest) {
+  const items = fs.readdirSync(src);
+
+  for (const item of items) {
+    // 跳过隐藏文件、node_modules、dist、logs 目录
+    if (item.startsWith(".") || item === "node_modules" || item === "dist" || item === "logs") {
+      continue;
+    }
+
+    // 跳过 .log 文件
+    if (item.endsWith(".log")) {
+      continue;
+    }
+
+    const srcPath = path.join(src, item);
+    const destPath = path.join(dest, item);
+    const stat = fs.statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      // 递归复制目录
+      fs.mkdirSync(destPath, { recursive: true });
+      await copyProjectFiles(srcPath, destPath);
+    } else {
+      // 复制文件
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+module.exports = {
+  packProject,
+  detectPackageManager,
+};

package/src/reverse.js

@@ -0,0 +1,204 @@
+const path = require("path");
+const fs = require("fs");
+const process = require("process");
+
+// 默认配置文件模板
+const defaultConfig = {
+  tables: ["test"],
+  modelDir: "",
+  mapperDir: "",
+  dbConfig: {
+    host: "localhost",
+    port: 3306,
+    user: "root",
+    password: "password",
+    database: "test_db",
+  },
+  style: {
+    tabWidth: 4,
+    printWidth: 200,
+    trailingComma: "es5",
+    useTabs: true,
+    parser: "typescript",
+    endOfLine: "crlf",
+  },
+  ignoreCamelcase: false,
+};
+
+// 生成默认配置文件
+function initReverseConfig() {
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, "reverse.config.json");
+
+  // 检查是否已存在
+  if (fs.existsSync(configPath)) {
+    console.log("⚠️  reverse.config.json 配置文件已存在");
+    console.log("   如需重新生成，请先删除现有文件");
+    return;
+  }
+
+  // 填充默认路径
+  const config = {
+    ...defaultConfig,
+    modelDir: path.join(cwd, "src", "model").replace(/\\/g, "/"),
+    mapperDir: path.join(cwd, "src", "mapper").replace(/\\/g, "/"),
+  };
+
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log("✅ 已生成 reverse.config.json 配置文件");
+    console.log("📁 文件路径:", configPath);
+    console.log("\n💡 请根据需要修改以下配置:");
+    console.log("   • tables: 要逆向生成的表名数组");
+    console.log("   • modelDir: Model 文件输出目录");
+    console.log("   • mapperDir: Mapper 文件输出目录");
+    console.log("   • dbConfig: 数据库连接配置");
+  } catch (error) {
+    console.log("❌ 生成配置文件失败:", error.message);
+  }
+}
+
+// 数据库表逆向生成
+async function reverseGenerate(args = []) {
+  const cwd = process.cwd();
+
+  // 检查是否在项目目录下（通过检查 package.json）
+  const packagePath = path.join(cwd, "package.json");
+  const nodeModulesPath = path.join(cwd, "node_modules");
+
+  if (!fs.existsSync(packagePath)) {
+    console.log("❌ 请在项目根目录下执行此命令");
+    return;
+  }
+
+  // 读取配置文件
+  const configPath = path.join(cwd, "reverse.config.json");
+  if (!fs.existsSync(configPath)) {
+    console.log("❌ 未找到 reverse.config.json 配置文件");
+    console.log("   请在项目根目录创建该文件，格式如下：");
+    console.log(`
+{
+  "tables": ["test"],
+  "modelDir": "${cwd.replace(/\\/g, "/")}/src/models",
+  "mapperDir": "${cwd.replace(/\\/g, "/")}/src/mappers",
+  "dbConfig": {
+    "host": "localhost",
+    "port": 3306,
+    "user": "root",
+    "password": "password",
+    "database": "test_db"
+  },
+  "style": {
+    "tabWidth": 4,
+    "printWidth": 200,
+    "trailingComma": "es5",
+    "useTabs": true,
+    "parser": "typescript",
+    "endOfLine": "crlf"
+  },
+  "ignoreCamelcase": false
+}
+    `);
+    return;
+  }
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  } catch (error) {
+    console.log("❌ 配置文件解析失败:", error.message);
+    return;
+  }
+
+  // 校验必填参数
+  const requiredFields = ["tables", "modelDir", "mapperDir", "dbConfig"];
+  const missingFields = requiredFields.filter((field) => !config[field]);
+  if (missingFields.length > 0) {
+    console.log("❌ 配置文件缺少必填字段:", missingFields.join(", "));
+    return;
+  }
+
+  // 尝试加载 @fastcar/mysql-tool 包
+  let mysqlTool;
+  try {
+    // 先尝试从项目本地加载
+    mysqlTool = require(path.join(nodeModulesPath, "@fastcar/mysql-tool"));
+  } catch (e) {
+    // 检查错误类型：是 @fastcar/mysql-tool 本身缺失，还是其依赖 @fastcar/mysql 缺失
+    if (e.code === "MODULE_NOT_FOUND") {
+      // 如果错误消息中包含 @fastcar/mysql-tool，说明是包本身未安装
+      if (e.message.includes("@fastcar/mysql-tool")) {
+        console.log("❌ 未找到 @fastcar/mysql-tool 包，请先安装:");
+        return;
+      }
+      // 如果 Require stack 中有 mysql-tool，说明是 @fastcar/mysql 依赖缺失
+      if (
+        e.requireStack &&
+        e.requireStack.some((s) => s.includes("@fastcar/mysql-tool"))
+      ) {
+        console.log("❌ 缺少依赖包 @fastcar/mysql，请先安装:");
+        return;
+      }
+    }
+
+    try {
+      // 如果本地没有，尝试全局加载
+      mysqlTool = require("@fastcar/mysql-tool");
+    } catch (e2) {
+      if (e2.code === "MODULE_NOT_FOUND") {
+        // 同样区分是包本身缺失还是依赖缺失
+        if (e2.message.includes("@fastcar/mysql-tool")) {
+          console.log("❌ 未找到 @fastcar/mysql-tool 包，请先安装:");
+          console.log("   npm install @fastcar/mysql-tool");
+          console.log("   或: yarn add @fastcar/mysql-tool");
+          return;
+        }
+        if (e2.message.includes("@fastcar/mysql")) {
+          console.log("❌ 缺少依赖包 @fastcar/mysql，请先安装:");
+          console.log("   npm install @fastcar/mysql");
+          console.log("   或: yarn add @fastcar/mysql");
+          return;
+        }
+      }
+
+      console.log("❌ 加载 @fastcar/mysql-tool 失败:", e2.message);
+      return;
+    }
+  }
+
+  // 检查 ReverseGenerate.generator 方法是否存在
+  if (
+    !mysqlTool.ReverseGenerate ||
+    typeof mysqlTool.ReverseGenerate.generator !== "function"
+  ) {
+    console.log(
+      "❌ @fastcar/mysql-tool 包中未找到 ReverseGenerate.generator 方法",
+    );
+    return;
+  }
+
+  try {
+    console.log("🔄 开始执行数据库表逆向生成...");
+    console.log("📋 目标表:", config.tables.join(", "));
+    console.log("📁 Model 输出目录:", config.modelDir);
+    console.log("📁 Mapper 输出目录:", config.mapperDir);
+    await mysqlTool.ReverseGenerate.generator(config);
+    console.log("✅ 逆向生成完成");
+  } catch (error) {
+    // 检查是否是 @fastcar/mysql 依赖缺失
+    if (
+      error.code === "MODULE_NOT_FOUND" &&
+      error.message.includes("@fastcar/mysql")
+    ) {
+      console.log("❌ 缺少依赖包 @fastcar/mysql，请先安装:");
+      return;
+    }
+    console.log("❌ 逆向生成失败:", error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  reverseGenerate,
+  initReverseConfig,
+};

package/src/templates.json

@@ -0,0 +1,32 @@
+{
+  "web": {
+    "name": "web",
+    "description": "Web 应用模板 - 适用于构建 Web 服务端应用",
+    "package": "@fastcar/template-web",
+    "tags": ["web", "server", "http"]
+  },
+  "rpc": {
+    "name": "rpc",
+    "description": "RPC 服务模板 - 适用于构建微服务 RPC 节点",
+    "package": "@fastcar/template-rpc",
+    "tags": ["rpc", "microservice"]
+  },
+  "cos": {
+    "name": "cos",
+    "description": "COS 存储模板 - 适用于对象存储服务",
+    "package": "@fastcar/template-cos",
+    "tags": ["cos", "storage"]
+  },
+  "micro": {
+    "name": "micro",
+    "description": "微服务模板 - 适用于构建完整的微服务架构",
+    "package": "@fastcar/template-microservices",
+    "tags": ["microservices", "fullstack"]
+  },
+  "static": {
+    "name": "static",
+    "description": "静态资源模板 - 适用于静态网站或资源服务",
+    "package": "@fastcar/template-static",
+    "tags": ["static", "assets"]
+  }
+}

package/src/utils.js

@@ -1,96 +1,81 @@
 const fs = require("fs");
 const path = require("path");
 const compressing = require("compressing");
-const util = require("util");
 const yaml = require("yaml");
 
 //复制文件
 function copyDirectory(src, dest) {
-
-    if (!fs.existsSync(dest)) {
-
-        fs.mkdirSync(dest);
-    }
-    if (!fs.existsSync(src)) {
-
-        return false;
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  if (!fs.existsSync(src)) {
+    return false;
+  }
+
+  let dirs = fs.readdirSync(src);
+  dirs.forEach((item) => {
+    let item_path = path.join(src, item);
+    let temp = fs.statSync(item_path);
+
+    if (temp.isFile()) {
+      fs.copyFileSync(item_path, path.join(dest, item));
+    } else if (temp.isDirectory()) {
+      copyDirectory(item_path, path.join(dest, item));
     }
+  });
 
-    let dirs = fs.readdirSync(src);
-    dirs.forEach((item) => {
-
-        let item_path = path.join(src, item);
-        let temp = fs.statSync(item_path);
-
-        if (temp.isFile()) {
-
-            fs.copyFileSync(item_path, path.join(dest, item));
-        } else if (temp.isDirectory()) {
-
-            copyDirectory(item_path, path.join(dest, item));
-        }
-    });
+  return true;
 }
 
 //递归删除文件夹
 function delDirEctory(src) {
-
-    if (!fs.existsSync(src)) {
-
-        return false;
+  if (!fs.existsSync(src)) {
+    return false;
+  }
+
+  let srcstats = fs.statSync(src);
+  if (srcstats.isFile()) {
+    fs.rmSync(src);
+    return;
+  }
+
+  let dirs = fs.readdirSync(src);
+  dirs.forEach((item) => {
+    let item_path = path.join(src, item);
+    let temp = fs.statSync(item_path);
+
+    if (temp.isFile()) {
+      fs.rmSync(item_path);
+    } else if (temp.isDirectory()) {
+      delDirEctory(item_path);
     }
+  });
 
-    let srcstats = fs.statSync(src);
-    if (srcstats.isFile()) {
-
-        fs.rmSync(src);
-        return;
-    }
-
-    let dirs = fs.readdirSync(src);
-    dirs.forEach((item) => {
-
-        let item_path = path.join(src, item);
-        let temp = fs.statSync(item_path);
-
-        if (temp.isFile()) {
-
-            fs.rmSync(item_path);
-        } else if (temp.isDirectory()) {
-
-            delDirEctory(item_path);
-        }
-    });
-
-    fs.rmdirSync(src);
+  fs.rmdirSync(src);
 }
 
 async function unzipFile(src, dest) {
-
-    await compressing.zip.uncompress(src, dest);
+  await compressing.zip.uncompress(src, dest);
 }
 
 async function zipFile(src, dest) {
-
-    await compressing.zip.compressDir(src, dest);
+  await compressing.zip.compressDir(src, dest);
 }
 
 function readYaml(fp) {
-
-    let content = fs.readFileSync(fp, "utf-8");
-    return yaml.parse(content);
+  let content = fs.readFileSync(fp, "utf-8");
+  return yaml.parse(content);
 }
 
 function writeYaml(fp, obj) {
-
-    fs.writeFileSync(fp, yaml.stringify(obj));
+  fs.writeFileSync(fp, yaml.stringify(obj));
 }
 
 module.exports = {
-    copyDirectory,
-    delDirEctory,
-    unzipFile,
-    zipFile,
-    readYaml,
-    writeYaml
-}
+  copyDirectory,
+  delDirEctory,
+  unzipFile,
+  zipFile,
+  readYaml,
+  writeYaml,
+};