@yoms/create-monorepo 1.0.2

package/dist/index.js

@@ -0,0 +1,649 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { cac } from "cac";
+
+// src/commands/create.ts
+import path7 from "path";
+import ora from "ora";
+import { execa as execa2 } from "execa";
+
+// src/utils/file-ops.ts
+import fs from "fs-extra";
+import path from "path";
+async function isDirEmpty(dirPath) {
+  if (!await fs.pathExists(dirPath)) return true;
+  const files = await fs.readdir(dirPath);
+  return files.length === 0;
+}
+async function ensureDir(dirPath) {
+  await fs.ensureDir(dirPath);
+}
+async function writeFile(filePath, content) {
+  await fs.outputFile(filePath, content);
+}
+async function readFile(filePath) {
+  return fs.readFile(filePath, "utf-8");
+}
+function replaceTokens(content, tokens) {
+  let result = content;
+  for (const [token, value] of Object.entries(tokens)) {
+    result = result.replaceAll(token, value);
+  }
+  return result;
+}
+async function copyDirRecursive(src, dest, tokens) {
+  await ensureDir(dest);
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirRecursive(srcPath, destPath, tokens);
+    } else {
+      let content = await readFile(srcPath);
+      if (tokens) {
+        content = replaceTokens(content, tokens);
+      }
+      await writeFile(destPath, content);
+    }
+  }
+}
+
+// src/utils/logger.ts
+import picocolors from "picocolors";
+var logger = {
+  info: (message) => {
+    console.log(picocolors.blue("\u2139"), message);
+  },
+  success: (message) => {
+    console.log(picocolors.green("\u2714"), message);
+  },
+  error: (message) => {
+    console.log(picocolors.red("\u2716"), message);
+  },
+  warn: (message) => {
+    console.log(picocolors.yellow("\u26A0"), message);
+  },
+  debug: (...args) => {
+    if (process.env.DEBUG) {
+      console.log(picocolors.gray("[debug]"), ...args);
+    }
+  }
+};
+
+// src/utils/package-manager.ts
+import { execa } from "execa";
+async function installDependencies(cwd, pm) {
+  await execa(pm, ["install"], { cwd, stdio: "inherit" });
+}
+
+// src/prompts/project.prompts.ts
+import enquirer from "enquirer";
+async function promptProjectName(defaultName = "my-monorepo") {
+  const { projectName } = await enquirer.prompt({
+    type: "input",
+    name: "projectName",
+    message: "Project name:",
+    initial: defaultName,
+    validate: (input) => {
+      if (!input.trim()) return "Project name is required";
+      if (!/^[a-z0-9-]+$/.test(input)) {
+        return "Project name must be lowercase alphanumeric with hyphens only";
+      }
+      return true;
+    }
+  });
+  return projectName;
+}
+async function promptPackageManager() {
+  const { packageManager } = await enquirer.prompt({
+    type: "select",
+    name: "packageManager",
+    message: "Select package manager:",
+    choices: ["pnpm", "npm", "yarn", "bun"],
+    initial: 0
+    // Default to pnpm
+  });
+  return packageManager;
+}
+async function promptIncludeBackend() {
+  const { includeBackend } = await enquirer.prompt({
+    type: "confirm",
+    name: "includeBackend",
+    message: "Include backend package?",
+    initial: true
+  });
+  return includeBackend;
+}
+async function promptIncludeFrontend() {
+  const { includeFrontend } = await enquirer.prompt({
+    type: "confirm",
+    name: "includeFrontend",
+    message: "Include frontend package?",
+    initial: true
+  });
+  return includeFrontend;
+}
+
+// src/prompts/backend.prompts.ts
+import enquirer2 from "enquirer";
+async function promptBackendConfig() {
+  const { backendType } = await enquirer2.prompt({
+    type: "select",
+    name: "backendType",
+    message: "Backend type:",
+    choices: [
+      { name: "web", message: "Web API (REST/HTTP)" },
+      { name: "worker", message: "Background Worker" },
+      { name: "cli", message: "CLI Tool" }
+    ],
+    initial: 0
+  });
+  let framework = "hono";
+  if (backendType === "web") {
+    const { selectedFramework } = await enquirer2.prompt({
+      type: "select",
+      name: "selectedFramework",
+      message: "Backend framework:",
+      choices: [
+        { name: "hono", message: "Hono (Recommended - Best TypeScript inference)" },
+        { name: "tsoa", message: "TSOA (OpenAPI-first with code generation)" }
+      ],
+      initial: 0
+    });
+    framework = selectedFramework;
+  }
+  const { database } = await enquirer2.prompt({
+    type: "select",
+    name: "database",
+    message: "Database:",
+    choices: [
+      { name: "postgres", message: "PostgreSQL with Prisma" },
+      { name: "mongodb", message: "MongoDB with Prisma" },
+      { name: "none", message: "None" }
+    ],
+    initial: 0
+  });
+  const { includeRedis } = await enquirer2.prompt({
+    type: "confirm",
+    name: "includeRedis",
+    message: "Include Redis caching?",
+    initial: false
+  });
+  const { includeSmtp } = await enquirer2.prompt({
+    type: "confirm",
+    name: "includeSmtp",
+    message: "Include SMTP email service?",
+    initial: false
+  });
+  let includeSwagger = false;
+  if (backendType === "web" && framework === "hono") {
+    const { swagger } = await enquirer2.prompt({
+      type: "confirm",
+      name: "swagger",
+      message: "Include Swagger/OpenAPI documentation?",
+      initial: false
+    });
+    includeSwagger = swagger;
+  }
+  return {
+    type: backendType,
+    framework,
+    database: database === "none" ? void 0 : database,
+    includeRedis,
+    includeSmtp,
+    includeSwagger
+  };
+}
+
+// src/prompts/frontend.prompts.ts
+import enquirer3 from "enquirer";
+async function promptFrontendConfig() {
+  const { includeShadcn } = await enquirer3.prompt({
+    type: "confirm",
+    name: "includeShadcn",
+    message: "Include shadcn/ui components?",
+    initial: true
+  });
+  const { apiUrl } = await enquirer3.prompt({
+    type: "input",
+    name: "apiUrl",
+    message: "API URL for development:",
+    initial: "http://localhost:3001",
+    validate: (input) => {
+      if (!input.trim()) return "API URL is required";
+      try {
+        new URL(input);
+        return true;
+      } catch {
+        return "Must be a valid URL";
+      }
+    }
+  });
+  return {
+    framework: "nextjs",
+    includeShadcn,
+    apiUrl
+  };
+}
+
+// src/generators/monorepo.generator.ts
+import path2 from "path";
+
+// src/generators/base.generator.ts
+var BaseGenerator = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  getTokens(additionalTokens) {
+    const defaultTokens = {
+      __PROJECT_NAME__: this.options.projectName,
+      __PACKAGE_SCOPE__: `@${this.options.projectName}`,
+      __DATABASE_PROVIDER__: "none",
+      __HAS_REDIS__: "false",
+      __HAS_SMTP__: "false",
+      __API_PORT__: "3001",
+      __WEB_PORT__: "3000",
+      __BACKEND_FRAMEWORK__: "hono",
+      __API_URL__: "http://localhost:3001"
+    };
+    return { ...defaultTokens, ...additionalTokens };
+  }
+};
+
+// src/generators/monorepo.generator.ts
+var MonorepoGenerator = class extends BaseGenerator {
+  async generate(config) {
+    await ensureDir(this.options.projectDir);
+    await this.createRootFiles(config);
+    await this.createPackagesDirectory();
+  }
+  async createRootFiles(config) {
+    const workspaceContent = `packages:
+  - 'packages/*'
+`;
+    await writeFile(path2.join(this.options.projectDir, "pnpm-workspace.yaml"), workspaceContent);
+    const packageJson = {
+      name: this.options.projectName,
+      version: "0.1.0",
+      private: true,
+      scripts: {
+        dev: `${this.options.packageManager} --parallel -r dev`,
+        build: `${this.options.packageManager} --parallel -r build`,
+        typecheck: `${this.options.packageManager} --parallel -r typecheck`,
+        lint: `${this.options.packageManager} --parallel -r lint`,
+        format: `${this.options.packageManager} --parallel -r format`
+      },
+      devDependencies: {
+        typescript: "^5.7.2",
+        prettier: "^3.4.2"
+      }
+    };
+    await writeFile(
+      path2.join(this.options.projectDir, "package.json"),
+      JSON.stringify(packageJson, null, 2)
+    );
+    const gitignoreContent = `# Dependencies
+node_modules/
+pnpm-lock.yaml
+yarn.lock
+package-lock.json
+
+# Build outputs
+dist/
+.next/
+*.tsbuildinfo
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+logs/
+*.log
+
+# Testing
+coverage/
+
+# Misc
+.cache/
+temp/
+tmp/
+`;
+    await writeFile(path2.join(this.options.projectDir, ".gitignore"), gitignoreContent);
+    const tokens = this.getTokens();
+    const readmeContent = `# ${tokens.__PROJECT_NAME__}
+
+Generated with create-monorepo.
+
+## Getting Started
+
+Install dependencies:
+
+\`\`\`bash
+${this.options.packageManager} install
+\`\`\`
+
+Run in development mode:
+
+\`\`\`bash
+${this.options.packageManager} dev
+\`\`\`
+
+Build for production:
+
+\`\`\`bash
+${this.options.packageManager} build
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${tokens.__PROJECT_NAME__}/
+\u251C\u2500\u2500 packages/
+${config.includeBackend ? "\u2502   \u251C\u2500\u2500 api/         # Backend API\n" : ""}${config.includeFrontend ? "\u2502   \u251C\u2500\u2500 web/         # Frontend application\n" : ""}${config.includeBackend && config.includeFrontend ? "\u2502   \u2514\u2500\u2500 shared/      # Shared types and utilities\n" : ""}\u2514\u2500\u2500 ...
+\`\`\`
+
+## Available Scripts
+
+- \`${this.options.packageManager} dev\` - Start all packages in development mode
+- \`${this.options.packageManager} build\` - Build all packages
+- \`${this.options.packageManager} typecheck\` - Type-check all packages
+- \`${this.options.packageManager} lint\` - Lint all packages
+- \`${this.options.packageManager} format\` - Format all packages with Prettier
+`;
+    await writeFile(path2.join(this.options.projectDir, "README.md"), readmeContent);
+    const tsconfigBase = {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        lib: ["ES2022"],
+        moduleResolution: "bundler",
+        resolveJsonModule: true,
+        allowJs: true,
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        noUnusedLocals: true,
+        noUnusedParameters: true,
+        noImplicitReturns: true,
+        noFallthroughCasesInSwitch: true
+      }
+    };
+    await writeFile(
+      path2.join(this.options.projectDir, "tsconfig.base.json"),
+      JSON.stringify(tsconfigBase, null, 2)
+    );
+  }
+  async createPackagesDirectory() {
+    await ensureDir(path2.join(this.options.projectDir, "packages"));
+  }
+};
+
+// src/generators/backend.generator.ts
+import path4 from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/template-merger.ts
+import fs2 from "fs-extra";
+import path3 from "path";
+async function mergeFeature(baseDir, featurePath, tokens) {
+  const featureSrcPath = path3.join(featurePath, "src");
+  const featurePrismaPath = path3.join(featurePath, "prisma");
+  if (await fs2.pathExists(featureSrcPath)) {
+    await copyDirRecursive(featureSrcPath, path3.join(baseDir, "src"), tokens);
+  }
+  if (await fs2.pathExists(featurePrismaPath)) {
+    await copyDirRecursive(featurePrismaPath, path3.join(baseDir, "prisma"), tokens);
+  }
+  const packageAdditionsPath = path3.join(featurePath, "package-additions.json");
+  if (await fs2.pathExists(packageAdditionsPath)) {
+    await mergePackageJson(baseDir, packageAdditionsPath);
+  }
+  const envAdditionsPath = path3.join(featurePath, "env-additions.txt");
+  if (await fs2.pathExists(envAdditionsPath)) {
+    await mergeEnvFile(baseDir, envAdditionsPath);
+  }
+}
+async function mergePackageJson(baseDir, additionsPath) {
+  const packageJsonPath = path3.join(baseDir, "package.json");
+  const packageJson = JSON.parse(await readFile(packageJsonPath));
+  const additions = JSON.parse(await readFile(additionsPath));
+  if (additions.dependencies) {
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      ...additions.dependencies
+    };
+  }
+  if (additions.devDependencies) {
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies,
+      ...additions.devDependencies
+    };
+  }
+  if (additions.scripts) {
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      ...additions.scripts
+    };
+  }
+  await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+async function mergeEnvFile(baseDir, additionsPath) {
+  const envPath = path3.join(baseDir, ".env.example");
+  let envContent = "";
+  if (await fs2.pathExists(envPath)) {
+    envContent = await readFile(envPath);
+    if (!envContent.endsWith("\n")) {
+      envContent += "\n";
+    }
+  }
+  const additions = await readFile(additionsPath);
+  envContent += "\n" + additions;
+  await writeFile(envPath, envContent);
+}
+
+// src/generators/backend.generator.ts
+var __dirname = path4.dirname(fileURLToPath(import.meta.url));
+var BackendGenerator = class extends BaseGenerator {
+  config;
+  constructor(options) {
+    super(options);
+    this.config = options.config;
+  }
+  async generate() {
+    const backendDir = path4.join(this.options.projectDir, "packages", "api");
+    await ensureDir(backendDir);
+    const tokens = this.getTokens({
+      __BACKEND_FRAMEWORK__: this.config.framework,
+      __DATABASE_PROVIDER__: this.config.database || "none",
+      __HAS_REDIS__: String(this.config.includeRedis),
+      __HAS_SMTP__: String(this.config.includeSmtp)
+    });
+    let templatePath;
+    if (this.config.type === "web") {
+      templatePath = path4.join(__dirname, "../../templates", `backend-${this.config.framework}`, "base");
+    } else if (this.config.type === "worker") {
+      templatePath = path4.join(__dirname, "../../templates", "backend-worker", "base");
+    } else {
+      templatePath = path4.join(__dirname, "../../templates", "backend-cli", "base");
+    }
+    await copyDirRecursive(templatePath, backendDir, tokens);
+    if (this.config.type === "web") {
+      const featuresPath = path4.join(__dirname, "../../templates", `backend-${this.config.framework}`, "features");
+      if (this.config.database) {
+        const dbFeaturePath = path4.join(featuresPath, `${this.config.database}-prisma`);
+        await mergeFeature(backendDir, dbFeaturePath, tokens);
+      }
+      if (this.config.includeRedis) {
+        const redisFeaturePath = path4.join(featuresPath, "redis");
+        await mergeFeature(backendDir, redisFeaturePath, tokens);
+      }
+      if (this.config.includeSmtp) {
+        const smtpFeaturePath = path4.join(featuresPath, "smtp");
+        await mergeFeature(backendDir, smtpFeaturePath, tokens);
+      }
+      if (this.config.includeSwagger) {
+        const swaggerFeaturePath = path4.join(featuresPath, "swagger");
+        await mergeFeature(backendDir, swaggerFeaturePath, tokens);
+      }
+    }
+  }
+};
+
+// src/generators/frontend.generator.ts
+import path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+var FrontendGenerator = class extends BaseGenerator {
+  config;
+  constructor(options) {
+    super(options);
+    this.config = options.config;
+  }
+  async generate() {
+    const frontendDir = path5.join(this.options.projectDir, "packages", "web");
+    await ensureDir(frontendDir);
+    const tokens = this.getTokens({
+      __API_URL__: this.config.apiUrl
+    });
+    const templatePath = path5.join(__dirname2, "../../templates", "frontend-nextjs", "base");
+    await copyDirRecursive(templatePath, frontendDir, tokens);
+  }
+};
+
+// src/generators/shared.generator.ts
+import path6 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = path6.dirname(fileURLToPath3(import.meta.url));
+var SharedGenerator = class extends BaseGenerator {
+  async generate() {
+    const sharedDir = path6.join(this.options.projectDir, "packages", "shared");
+    await ensureDir(sharedDir);
+    const tokens = this.getTokens();
+    const templatePath = path6.join(__dirname3, "../../templates", "shared", "base");
+    await copyDirRecursive(templatePath, sharedDir, tokens);
+  }
+};
+
+// src/commands/create.ts
+async function createMonorepo(targetDir) {
+  console.log("");
+  logger.info("Welcome to create-monorepo!");
+  console.log("");
+  const projectName = await promptProjectName(targetDir ? path7.basename(targetDir) : void 0);
+  const projectDir = path7.resolve(process.cwd(), targetDir || projectName);
+  if (!await isDirEmpty(projectDir)) {
+    logger.error(`Directory "${projectDir}" is not empty. Please choose an empty directory.`);
+    process.exit(1);
+  }
+  const packageManager = await promptPackageManager();
+  const includeBackend = await promptIncludeBackend();
+  const includeFrontend = await promptIncludeFrontend();
+  if (!includeBackend && !includeFrontend) {
+    logger.error("You must include at least one package (backend or frontend).");
+    process.exit(1);
+  }
+  const config = {
+    projectName,
+    packageManager,
+    includeBackend,
+    includeFrontend
+  };
+  if (includeBackend) {
+    console.log("");
+    logger.info("Configure backend package:");
+    config.backend = await promptBackendConfig();
+  }
+  if (includeFrontend) {
+    console.log("");
+    logger.info("Configure frontend package:");
+    config.frontend = await promptFrontendConfig();
+  }
+  console.log("");
+  logger.info("Generating project...");
+  try {
+    const monorepoGenerator = new MonorepoGenerator({
+      projectName,
+      projectDir,
+      packageManager
+    });
+    const spinner = ora("Creating monorepo structure...").start();
+    await monorepoGenerator.generate(config);
+    spinner.succeed("Monorepo structure created");
+    if (includeBackend && includeFrontend) {
+      spinner.start("Generating shared package...");
+      const sharedGenerator = new SharedGenerator({
+        projectName,
+        projectDir,
+        packageManager
+      });
+      await sharedGenerator.generate();
+      spinner.succeed("Shared package generated");
+    }
+    if (includeBackend && config.backend) {
+      spinner.start("Generating backend package...");
+      const backendGenerator = new BackendGenerator({
+        projectName,
+        projectDir,
+        packageManager,
+        config: config.backend
+      });
+      await backendGenerator.generate();
+      spinner.succeed("Backend package generated");
+    }
+    if (includeFrontend && config.frontend) {
+      spinner.start("Generating frontend package...");
+      const frontendGenerator = new FrontendGenerator({
+        projectName,
+        projectDir,
+        packageManager,
+        config: config.frontend
+      });
+      await frontendGenerator.generate();
+      spinner.succeed("Frontend package generated");
+    }
+    spinner.start("Installing dependencies...");
+    await installDependencies(projectDir, packageManager);
+    spinner.succeed("Dependencies installed");
+    spinner.start("Initializing git repository...");
+    await execa2("git", ["init"], { cwd: projectDir });
+    await execa2("git", ["add", "."], { cwd: projectDir });
+    await execa2("git", ["commit", "-m", "Initial commit from create-monorepo"], { cwd: projectDir });
+    spinner.succeed("Git repository initialized");
+    console.log("");
+    logger.success(`Project "${projectName}" created successfully!`);
+    console.log("");
+    logger.info("Next steps:");
+    console.log(`  cd ${targetDir || projectName}`);
+    console.log(`  ${packageManager} dev`);
+    console.log("");
+  } catch (error) {
+    logger.error(`Failed to create project: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var cli = cac("create-monorepo");
+cli.command("[dir]", "Create a new monorepo project").action(async (dir) => {
+  await createMonorepo(dir);
+});
+cli.help();
+cli.version("0.1.0");
+cli.parse();