@amirulabu/create-recurring-rabbit-app 0.0.0-alpha

package/bin/index.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/index.js

@@ -0,0 +1,592 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import path4 from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync, promises, mkdirSync, readFileSync } from 'fs';
+import ora from 'ora';
+import fs from 'fs/promises';
+import { execSync, spawn } from 'child_process';
+import chalk2 from 'chalk';
+import crypto from 'crypto';
+
+async function copyTemplateFiles(templateDir, targetDir) {
+  const copyRecursive = async (src, dest) => {
+    const stat = await fs.stat(src);
+    if (stat.isDirectory()) {
+      const entries = await fs.readdir(src);
+      await fs.mkdir(dest, { recursive: true });
+      for (const entry of entries) {
+        await copyRecursive(path4.join(src, entry), path4.join(dest, entry));
+      }
+    } else {
+      await fs.mkdir(path4.dirname(dest), { recursive: true });
+      await fs.copyFile(src, dest);
+    }
+  };
+  await copyRecursive(templateDir, targetDir);
+}
+async function copyDirectory(src, dest) {
+  await copyTemplateFiles(src, dest);
+}
+async function generatePackageJson(targetDir, config) {
+  const packageJsonPath = path4.join(targetDir, "package.json");
+  const packageJson = {
+    name: config.name,
+    version: config.version ?? "0.1.0",
+    description: config.description ?? "A micro-SaaS built with TanStack Start, tRPC, and Drizzle",
+    type: "module",
+    scripts: {
+      dev: "vinxi dev",
+      build: "vinxi build",
+      start: "vinxi start",
+      "db:generate": "drizzle-kit generate",
+      "db:migrate": "drizzle-kit migrate",
+      "db:studio": "drizzle-kit studio",
+      "db:seed": "tsx src/server/db/seed.ts",
+      typecheck: "tsc --noEmit",
+      lint: "eslint . --ext .ts,.tsx",
+      "lint:fix": "eslint . --ext .ts,.tsx --fix",
+      format: 'prettier --write "src/**/*.{ts,tsx,json,css}"',
+      clean: "rm -rf .vinxi dist data/*.db data/*.db-shm data/*.db-wal",
+      "build:analyze": "ANALYZE_BUNDLE=true vinxi build",
+      lighthouse: "lhci autorun",
+      ...config.scripts
+    },
+    dependencies: {
+      "@paralleldrive/cuid2": "^2.2.0",
+      "@radix-ui/react-slot": "^1.0.2",
+      "@tanstack/react-query": "^5.0.0",
+      "@tanstack/react-router": "~1.120.0",
+      "@tanstack/react-query-devtools": "^5.0.0",
+      "@tanstack/start": "^1.120.0",
+      "@trpc/client": "^11.0.0",
+      "@trpc/react-query": "^11.0.0",
+      "@trpc/server": "^11.0.0",
+      "@t3-oss/env-core": "^0.10.0",
+      "better-auth": "^1.0.0",
+      "better-sqlite3": "^12.0.0",
+      "class-variance-authority": "^0.7.0",
+      clsx: "^2.1.0",
+      dotenv: "^16.4.0",
+      "drizzle-orm": "^0.41.0",
+      postgres: "^3.4.0",
+      react: "^18.2.0",
+      "react-dom": "^18.2.0",
+      resend: "^3.2.0",
+      "tailwind-merge": "^2.2.0",
+      "tailwindcss-animate": "^1.0.7",
+      zod: "^3.22.0",
+      ...config.dependencies
+    },
+    devDependencies: {
+      "@lhci/cli": "^0.12.0",
+      "@types/better-sqlite3": "^7.6.9",
+      "@types/node": "^20.11.0",
+      "@types/react": "^18.2.0",
+      "@types/react-dom": "^18.2.0",
+      "@typescript-eslint/eslint-plugin": "^6.0.0",
+      "@typescript-eslint/parser": "^6.0.0",
+      eslint: "^8.56.0",
+      "eslint-plugin-react": "^7.32.0",
+      "eslint-plugin-react-hooks": "^4.6.0",
+      "drizzle-kit": "^0.31.0",
+      postcss: "^8.4.0",
+      prettier: "^3.2.5",
+      "rollup-plugin-visualizer": "^5.12.0",
+      tailwindcss: "^3.4.0",
+      tsx: "^4.7.0",
+      typescript: "^5.3.3",
+      vinxi: "^0.4.0",
+      ...config.devDependencies
+    }
+  };
+  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+}
+async function detectPackageManager() {
+  const cwd = process.cwd();
+  const hasLockFile = async (file) => {
+    try {
+      await fs.access(file);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const hasPackageLockJson = await hasLockFile(`${cwd}/package-lock.json`);
+  const hasPnpmLockYaml = await hasLockFile(`${cwd}/pnpm-lock.yaml`);
+  const hasYarnLock = await hasLockFile(`${cwd}/yarn.lock`);
+  if (hasPnpmLockYaml) return "pnpm";
+  if (hasYarnLock) return "yarn";
+  if (hasPackageLockJson) return "npm";
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent?.startsWith("pnpm")) return "pnpm";
+  if (userAgent?.startsWith("yarn")) return "yarn";
+  if (userAgent?.startsWith("npm")) return "npm";
+  try {
+    execSync("pnpm --version", { stdio: "ignore" });
+    return "pnpm";
+  } catch {
+    try {
+      execSync("yarn --version", { stdio: "ignore" });
+      return "yarn";
+    } catch {
+      return "npm";
+    }
+  }
+}
+function getInstallCommand(packageManager) {
+  switch (packageManager) {
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn";
+    case "npm":
+    default:
+      return "npm install";
+  }
+}
+function installDependencies(projectPath, packageManager) {
+  const installCmd = getInstallCommand(packageManager);
+  const spinner = ora(`Installing dependencies with ${packageManager}...`).start();
+  try {
+    execSync(installCmd, {
+      cwd: projectPath,
+      stdio: "inherit"
+    });
+    spinner.succeed(chalk2.green("\u2713 Dependencies installed"));
+    if (packageManager === "pnpm") {
+      const rebuildSpinner = ora("Building native modules...").start();
+      try {
+        execSync("pnpm rebuild better-sqlite3", {
+          cwd: projectPath,
+          stdio: "inherit"
+        });
+        rebuildSpinner.succeed(chalk2.green("\u2713 Native modules built"));
+      } catch {
+        rebuildSpinner.warn(
+          chalk2.yellow("\u26A0 Native module build failed, trying alternative method...")
+        );
+        try {
+          execSync("npx node-gyp rebuild --directory node_modules/better-sqlite3", {
+            cwd: projectPath,
+            stdio: "inherit"
+          });
+          rebuildSpinner.succeed(chalk2.green("\u2713 Native modules built"));
+        } catch {
+          rebuildSpinner.warn(
+            chalk2.yellow("\u26A0 Native module build failed, may affect database functionality")
+          );
+        }
+      }
+    }
+  } catch {
+    spinner.fail(chalk2.red("\u2717 Dependency installation failed"));
+    throw new Error(
+      `Failed to install dependencies. Please run '${installCmd}' manually in project directory.`
+    );
+  }
+}
+function validateNodeVersion() {
+  const nodeVersion = process.version.replace("v", "");
+  const versionParts = nodeVersion.split(".");
+  const majorVersion = parseInt(versionParts[0] ?? "0", 10);
+  const validVersions = [18, 20, 22];
+  if (!validVersions.includes(majorVersion)) {
+    throw new Error(
+      `Node.js v${majorVersion} is not supported. Please use Node.js 18, 20, or 22. Current version: v${nodeVersion}`
+    );
+  }
+}
+function generateSecret(length = 32) {
+  return crypto.randomBytes(length).toString("base64");
+}
+async function generateEnvFile(targetDir, options = {}) {
+  const envPath = path4.join(targetDir, ".env.local");
+  const secret = generateSecret(32);
+  const content = [
+    `# Database`,
+    `DATABASE_URL="${options.databaseUrl ?? ""}"`,
+    ``,
+    `# Auth`,
+    `BETTER_AUTH_SECRET="${secret}"`,
+    `BETTER_AUTH_URL="${options.betterAuthUrl ?? "http://localhost:3000"}"`,
+    ``,
+    `# Email`,
+    `RESEND_API_KEY="${options.resendApiKey ?? "your-resend-api-key"}"`,
+    ``,
+    `# Environment`,
+    `NODE_ENV="${options.nodeEnv ?? "development"}"`,
+    ``,
+    `# Client (public)`,
+    `PUBLIC_APP_URL="${options.betterAuthUrl ?? "http://localhost:3000"}"`,
+    ``
+  ].join("\n");
+  await fs.writeFile(envPath, content);
+}
+function loadEnvFile(projectPath) {
+  const envPath = path4.join(projectPath, ".env.local");
+  const env = {};
+  try {
+    const content = readFileSync(envPath, "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine && !trimmedLine.startsWith("#")) {
+        const [key, ...valueParts] = trimmedLine.split("=");
+        if (key) {
+          const value = valueParts.join("=").replace(/^"|"$/g, "").replace(/^'|'$/g, "");
+          env[key] = value;
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not load .env.local file: ${String(error)}`);
+  }
+  return env;
+}
+async function initializeDatabase(projectPath) {
+  const spinner = ora("Initializing database...").start();
+  try {
+    const dataDir = path4.join(projectPath, "data");
+    if (!existsSync(dataDir)) {
+      mkdirSync(dataDir, { recursive: true });
+      spinner.text = "Data directory created";
+    }
+    const env = loadEnvFile(projectPath);
+    await runNpmScript(
+      projectPath,
+      "./node_modules/.bin/drizzle-kit push",
+      "Creating database schema...",
+      env
+    );
+    spinner.succeed("Database initialized successfully");
+    const seedSpinner = ora("Seeding database with sample data...").start();
+    await runSeedScript(projectPath, env);
+    seedSpinner.succeed("Database seeded successfully");
+  } catch (error) {
+    spinner.fail("Database initialization failed");
+    throw error;
+  }
+}
+async function runNpmScript(projectPath, command, description, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [], {
+      cwd: projectPath,
+      stdio: "pipe",
+      shell: true,
+      env: { ...process.env, ...env }
+    });
+    let errorOutput = "";
+    child.stdout?.on("data", (data) => {
+      console.log(data.toString());
+    });
+    child.stderr?.on("data", (data) => {
+      errorOutput += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`${description} failed with exit code ${code}
+${errorOutput}`));
+      } else {
+        resolve();
+      }
+    });
+    child.on("error", (error) => {
+      reject(new Error(`${description} failed: ${error.message}`));
+    });
+  });
+}
+async function runSeedScript(projectPath, env) {
+  return new Promise((resolve, reject) => {
+    const tsxPath = path4.join(projectPath, "node_modules/.bin/tsx");
+    const seedScriptPath = path4.join(projectPath, "src/server/db/seed.ts");
+    const command = process.platform === "win32" ? "node" : tsxPath;
+    const args = process.platform === "win32" ? [tsxPath, seedScriptPath] : [seedScriptPath];
+    const child = spawn(command, args, {
+      cwd: projectPath,
+      stdio: "inherit",
+      shell: process.platform === "win32",
+      env: { ...process.env, ...env }
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`Seed script failed with exit code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+    child.on("error", (error) => {
+      reject(new Error(`Seed script failed: ${error.message}`));
+    });
+  });
+}
+var CLIError = class extends Error {
+  constructor(message, context) {
+    super(message);
+    this.context = context;
+    this.name = "CLIError";
+  }
+};
+function formatError(error) {
+  if (error instanceof CLIError && error.context) {
+    return formatContextualError(error);
+  }
+  return error.message;
+}
+function formatContextualError(error) {
+  const { error: originalError, step } = error.context;
+  const errorMessage = originalError.message;
+  let formatted = chalk2.red(`Error: ${errorMessage}
+`);
+  if (step) {
+    formatted += chalk2.yellow(`Step: ${step}
+`);
+  }
+  formatted += getErrorSuggestion(originalError.message);
+  return formatted;
+}
+function getErrorSuggestion(errorMessage) {
+  const suggestions = {
+    "Directory already exists": chalk2.cyan(
+      "\u{1F4A1} Suggestion: Choose a different project name or remove the existing directory.\n"
+    ),
+    "Failed to install dependencies": chalk2.cyan(
+      "\u{1F4A1} Suggestion: Try running the install command manually in the project directory.\n"
+    ),
+    "Node.js version is not supported": chalk2.cyan(
+      "\u{1F4A1} Suggestion: Install Node.js 18, 20, or 22 from https://nodejs.org/\n"
+    ),
+    "Failed to create project": chalk2.cyan(
+      "\u{1F4A1} Suggestion: Ensure you have write permissions in the target directory.\n"
+    ),
+    "Invalid project name": chalk2.cyan(
+      "\u{1F4A1} Suggestion: Project name must be lowercase, alphanumeric, with optional hyphens, and cannot start/end with a hyphen.\n"
+    ),
+    "Reserved project name": chalk2.cyan(
+      "\u{1F4A1} Suggestion: This name is reserved by npm. Choose a different project name.\n"
+    )
+  };
+  for (const [key, suggestion] of Object.entries(suggestions)) {
+    if (errorMessage.includes(key)) {
+      return suggestion;
+    }
+  }
+  return chalk2.cyan("\u{1F4A1} Suggestion: Check the error message above and try again.\n");
+}
+function getSuccessMessage(_projectName, _packageManager) {
+  return `
+${chalk2.green("\u2713")} Project created successfully!
+${chalk2.green("\u2713")} Dependencies installed
+${chalk2.green("\u2713")} Database initialized
+${chalk2.green("\u2713")} Environment configured
+
+${chalk2.bold.green("\u{1F680} Your micro-SaaS is ready!")}
+
+${chalk2.cyan("Local:")}    ${chalk2.cyan("http://localhost:3000")}
+${chalk2.cyan("Database:")} ${chalk2.cyan("./data/app.db")}
+
+${chalk2.white("Next steps:")}
+${chalk2.white("  1. Sign up for an account to see the dashboard")}
+${chalk2.white("  2. Check out the tRPC routes in src/server/api/")}
+${chalk2.white("  3. Start building your features!")}
+
+${chalk2.white("Documentation:")} ${chalk2.cyan("README.md")}
+`;
+}
+function getTroubleshootingTips() {
+  return `
+${chalk2.bold.yellow("Common Issues & Solutions:")}
+
+${chalk2.red("\u2717 Directory already exists")}
+  ${chalk2.cyan("Solution:")} Choose a different name or remove the existing directory.
+
+${chalk2.red("\u2717 Dependency installation failed")}
+  ${chalk2.cyan("Solution:")} Run install manually: ${chalk2.white("npm install")} / ${chalk2.white("pnpm install")} / ${chalk2.white("yarn")}
+
+${chalk2.red("\u2717 Node.js version not supported")}
+  ${chalk2.cyan("Solution:")} Install Node.js 18+ from ${chalk2.white("https://nodejs.org/")}
+
+${chalk2.red("\u2717 Permission denied")}
+  ${chalk2.cyan("Solution:")} Ensure you have write permissions in the target directory.
+
+For more help, visit: ${chalk2.white("https://github.com/your-repo/issues")}
+
+`;
+}
+
+// src/utils/validation.ts
+var RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "node_modules",
+  "favicon.ico",
+  ".git",
+  ".env",
+  ".env.local",
+  ".env.production",
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "tsconfig.json"
+]);
+var NPM_RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "http",
+  "https",
+  "ftp",
+  "file",
+  "module",
+  "node",
+  "npm",
+  "package",
+  "system",
+  "os",
+  "fs",
+  "path",
+  "net",
+  "tls",
+  "crypto",
+  "buffer",
+  "stream",
+  "events",
+  "util",
+  "url",
+  "querystring",
+  "zlib"
+]);
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    throw new CLIError("Invalid project name: name cannot be empty");
+  }
+  if (name !== name.trim()) {
+    throw new CLIError("Invalid project name: name cannot start or end with spaces");
+  }
+  if (name.length > 214) {
+    throw new CLIError("Invalid project name: name must be 214 characters or less");
+  }
+  const npmNamePattern = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+  if (!npmNamePattern.test(name)) {
+    throw new CLIError(
+      "Invalid project name: must be lowercase alphanumeric with optional hyphens and underscores"
+    );
+  }
+  if (name.startsWith("-") || name.endsWith("-") || name.startsWith("_") || name.endsWith("_")) {
+    throw new CLIError("Invalid project name: cannot start or end with hyphen or underscore");
+  }
+  if (NPM_RESERVED_NAMES.has(name.toLowerCase())) {
+    throw new CLIError(`Invalid project name: "${name}" is a reserved npm name`);
+  }
+  if (RESERVED_NAMES.has(name)) {
+    throw new CLIError(`Invalid project name: "${name}" is a reserved name`);
+  }
+  const parts = name.split(path4.sep);
+  const baseName = parts[parts.length - 1];
+  if (baseName !== name) {
+    throw new CLIError("Invalid project name: cannot contain path separators");
+  }
+}
+async function cleanupProject(projectPath) {
+  try {
+    if (await promises.access(projectPath).then(() => true).catch(() => false)) {
+      await promises.rm(projectPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not cleanup ${projectPath}: ${error.message}`);
+  }
+}
+
+// src/commands/create.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path4.dirname(__filename2);
+var TEMPLATE_DIR = path4.join(__dirname2, "../../templates/default");
+async function scaffoldProject(projectName, targetPath) {
+  const spinner = ora("Creating project structure...").start();
+  let projectPath = "";
+  let projectCreated = false;
+  try {
+    validateProjectName(projectName);
+    projectPath = path4.join(targetPath, projectName);
+    if (existsSync(projectPath)) {
+      spinner.fail(`Directory ${projectName} already exists. Please choose a different name.`);
+      throw new Error(`Directory ${projectName} already exists`);
+    }
+    spinner.succeed("Project directory will be created");
+    spinner.start("Copying template files...");
+    await copyDirectory(TEMPLATE_DIR, projectPath);
+    projectCreated = true;
+    spinner.succeed("Template files copied");
+    spinner.start("Generating package.json...");
+    await generatePackageJson(projectPath, { name: projectName });
+    spinner.succeed("package.json generated");
+    spinner.start("Configuring environment...");
+    await generateEnvFile(projectPath, {
+      betterAuthUrl: "http://localhost:3000",
+      nodeEnv: "development"
+    });
+    spinner.succeed("Environment configured");
+    const packageManager = await detectPackageManager();
+    return { projectPath, packageManager };
+  } catch (error) {
+    spinner.fail("Failed to create project");
+    if (projectPath && projectCreated) {
+      await cleanupProject(projectPath);
+    }
+    throw error;
+  }
+}
+async function installProjectDependencies(projectPath, packageManager) {
+  const spinner = ora("Installing dependencies...").start();
+  try {
+    validateNodeVersion();
+    installDependencies(projectPath, packageManager);
+    spinner.text = `Dependencies installed with ${packageManager}`;
+    spinner.succeed("All dependencies installed");
+  } catch (error) {
+    spinner.fail("Dependency installation failed");
+    await cleanupProject(projectPath);
+    throw error;
+  }
+}
+async function initProjectDatabase(projectPath) {
+  try {
+    await initializeDatabase(projectPath);
+    return { success: true };
+  } catch (error) {
+    await cleanupProject(projectPath);
+    throw error;
+  }
+}
+function displaySuccess(projectName, packageManager) {
+  console.log(getSuccessMessage());
+}
+function displayError(error) {
+  console.error(formatError(error));
+  if (error instanceof CLIError) {
+    console.log(getTroubleshootingTips());
+  }
+}
+
+// src/index.ts
+program.name("create-recurring-rabbit-app").description(
+  "Scaffold a production-ready micro-SaaS with TanStack Start, tRPC, Drizzle, and Better-auth"
+).version("0.0.0-alpha").argument("[app-name]", "Name of your application", "my-saas-app").action(async (appName) => {
+  let hasError = false;
+  try {
+    const targetPath = process.cwd();
+    const { projectPath, packageManager } = await scaffoldProject(appName, targetPath);
+    await installProjectDependencies(projectPath, packageManager);
+    await initProjectDatabase(projectPath);
+    displaySuccess(appName, packageManager);
+  } catch (error) {
+    hasError = true;
+    if (error instanceof CLIError) {
+      displayError(error);
+    } else {
+      displayError(error);
+    }
+    process.exit(1);
+  } finally {
+    if (hasError) {
+      console.log("\nProject cleanup complete. No files were left behind.");
+    }
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@amirulabu/create-recurring-rabbit-app",
+  "version": "0.0.0-alpha",
+  "description": "CLI tool to scaffold micro-SaaS apps with TanStack Start, tRPC, Drizzle, and Better-auth",
+  "type": "module",
+  "bin": {
+    "create-recurring-rabbit-app": "./bin/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --clean",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --ext .ts,.tsx",
+    "lint:fix": "eslint . --ext .ts,.tsx --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\""
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^20.11.0",
+    "@typescript-eslint/eslint-plugin": "^8.53.1",
+    "@typescript-eslint/parser": "^8.53.1",
+    "eslint": "^9.39.2",
+    "tsup": "^8.0.1",
+    "tsx": "^4.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/default/.editorconfig

@@ -0,0 +1,21 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.ts]
+indent_size = 2
+
+[*.tsx]
+indent_size = 2
+
+[*.json]
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false

package/templates/default/.env.example

@@ -0,0 +1,15 @@
+# Database
+DATABASE_URL=""
+
+# Auth
+BETTER_AUTH_SECRET="your-secret-key-min-32-characters"
+BETTER_AUTH_URL="http://localhost:3000"
+
+# Email
+RESEND_API_KEY="your-resend-api-key"
+
+# Environment
+NODE_ENV="development"
+
+# Client (public)
+PUBLIC_APP_URL="http://localhost:3000"