create-blitzpack 0.1.0

package/dist/index.js

@@ -0,0 +1,452 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/create.ts
+import chalk2 from "chalk";
+import { spawn } from "child_process";
+import fs3 from "fs-extra";
+import ora from "ora";
+import path3 from "path";
+import { fileURLToPath } from "url";
+
+// src/git.ts
+import { execSync } from "child_process";
+function isGitInstalled() {
+  try {
+    execSync("git --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function initGit(targetDir) {
+  try {
+    execSync("git init", { cwd: targetDir, stdio: "ignore" });
+    execSync("git add -A", { cwd: targetDir, stdio: "ignore" });
+    execSync('git commit -m "Initial commit from create-blitzpack"', {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/prompts.ts
+import prompts from "prompts";
+
+// src/constants.ts
+var TEMPLATE_EXCLUDES = [
+  "node_modules",
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  "coverage",
+  ".git",
+  "pnpm-lock.yaml",
+  "*.tsbuildinfo",
+  "tsconfig.tsbuildinfo",
+  ".env.local",
+  ".env.*.local",
+  ".DS_Store",
+  ".temp",
+  ".claude",
+  ".cursor",
+  "create-blitzpack",
+  "apps/api/src/generated",
+  "apps/api/public/uploads",
+  "scripts/setup.js"
+];
+var REPLACEABLE_FILES = [
+  "package.json",
+  "apps/web/src/config/site.ts",
+  "apps/web/src/app/layout.tsx",
+  "apps/api/src/plugins/swagger.ts",
+  "README.md"
+];
+var DEFAULT_DESCRIPTION = "A full-stack TypeScript monorepo built with Blitzpack";
+
+// src/utils.ts
+import chalk from "chalk";
+import validatePackageName from "validate-npm-package-name";
+function toSlug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function validateProjectName(name) {
+  const result = validatePackageName(name);
+  if (result.validForNewPackages) {
+    return { valid: true };
+  }
+  const problems = [...result.errors || [], ...result.warnings || []];
+  return { valid: false, problems };
+}
+function printHeader() {
+  console.log();
+  console.log(chalk.bold.cyan("  Create Blitzpack"));
+  console.log(chalk.dim("  Full-stack TypeScript monorepo"));
+  console.log();
+}
+function printSuccess(projectName, targetDir) {
+  console.log();
+  console.log(chalk.green("\u2714"), chalk.bold(`Created ${projectName}`));
+  console.log();
+  console.log(chalk.bold("  Next steps:"));
+  console.log();
+  console.log(chalk.cyan("  1."), `cd ${targetDir}`);
+  console.log(
+    chalk.cyan("  2."),
+    "docker compose up -d",
+    chalk.dim("  # Start PostgreSQL")
+  );
+  console.log(
+    chalk.cyan("  3."),
+    "pnpm db:migrate",
+    chalk.dim("       # Run database migrations")
+  );
+  console.log(
+    chalk.cyan("  4."),
+    "pnpm dev",
+    chalk.dim("              # Start dev servers")
+  );
+  console.log();
+  console.log(
+    chalk.dim("  Optional: pnpm db:seed to add test data like admin accounts")
+  );
+  console.log();
+  console.log(
+    chalk.dim("  Web: http://localhost:3000 | API: http://localhost:8080")
+  );
+  console.log();
+}
+function printError(message) {
+  console.log();
+  console.log(chalk.red("\u2716"), message);
+  console.log();
+}
+
+// src/prompts.ts
+async function getProjectOptions(providedName, flags = {}) {
+  const questions = [];
+  if (!providedName) {
+    questions.push({
+      type: "text",
+      name: "projectName",
+      message: "Project name:",
+      initial: "my-app",
+      validate: (value) => {
+        const result = validateProjectName(value);
+        if (!result.valid) {
+          return result.problems?.[0] || "Invalid project name";
+        }
+        return true;
+      }
+    });
+  }
+  questions.push({
+    type: "text",
+    name: "projectDescription",
+    message: "Project description:",
+    initial: DEFAULT_DESCRIPTION
+  });
+  let cancelled = false;
+  const response = await prompts(questions, {
+    onCancel: () => {
+      cancelled = true;
+    }
+  });
+  if (cancelled) {
+    return null;
+  }
+  const projectName = providedName || response.projectName;
+  const validation = validateProjectName(projectName);
+  if (!validation.valid) {
+    console.log(`Invalid project name: ${validation.problems?.[0]}`);
+    return null;
+  }
+  return {
+    projectName,
+    projectSlug: toSlug(projectName),
+    projectDescription: response.projectDescription || DEFAULT_DESCRIPTION,
+    skipGit: flags.skipGit || false,
+    skipInstall: flags.skipInstall || false
+  };
+}
+
+// src/template.ts
+import fs from "fs-extra";
+import path from "path";
+function shouldExclude(relativePath) {
+  const normalizedPath = relativePath.replace(/\\/g, "/");
+  for (const pattern of TEMPLATE_EXCLUDES) {
+    if (pattern.startsWith("*")) {
+      const ext = pattern.slice(1);
+      if (normalizedPath.endsWith(ext)) return true;
+    } else if (normalizedPath === pattern || normalizedPath.startsWith(pattern + "/")) {
+      return true;
+    } else {
+      const parts = normalizedPath.split("/");
+      if (parts.includes(pattern)) return true;
+    }
+  }
+  return false;
+}
+async function copyDir(src, dest, baseDir) {
+  await fs.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);
+    const relativePath = path.relative(baseDir, srcPath);
+    if (shouldExclude(relativePath)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath, baseDir);
+    } else {
+      await fs.copy(srcPath, destPath);
+    }
+  }
+}
+async function copyTemplate(templateDir, targetDir) {
+  if (await fs.pathExists(targetDir)) {
+    const files = await fs.readdir(targetDir);
+    if (files.length > 0) {
+      throw new Error(`Directory ${targetDir} is not empty`);
+    }
+  }
+  await copyDir(templateDir, targetDir, templateDir);
+}
+
+// src/transform.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+function transformPackageJson(content, vars, filePath) {
+  const pkg = JSON.parse(content);
+  if (filePath === "package.json") {
+    pkg.name = vars.projectSlug;
+    pkg.description = vars.projectDescription;
+    delete pkg.repository;
+    delete pkg.homepage;
+    delete pkg.scripts?.["init:project"];
+    pkg.version = "0.1.0";
+  }
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function transformSiteConfig(content, vars) {
+  return content.replace(/name: ['"].*['"]/, `name: '${vars.projectName}'`).replace(/description: ['"].*['"]/, `description: '${vars.projectDescription}'`).replace(/github: ['"].*['"]/, `github: ''`);
+}
+function transformLayout(content, vars) {
+  return content.replace(/title: ['"].*['"]/, `title: '${vars.projectName}'`).replace(/description: ['"].*['"]/, `description: '${vars.projectDescription}'`);
+}
+function transformSwagger(content, vars) {
+  return content.replace(/title: ['"].*['"]/, `title: '${vars.projectName} API'`).replace(
+    /description: ['"]Production-ready TypeScript API built with Fastify['"]/,
+    `description: '${vars.projectDescription}'`
+  );
+}
+function generateReadme(vars) {
+  return `# ${vars.projectName}
+
+${vars.projectDescription}
+
+## Quick Start
+
+\`\`\`bash
+pnpm install
+pnpm init:project
+pnpm dev
+\`\`\`
+
+## What's Running
+
+- **Web:** http://localhost:3000
+- **API:** http://localhost:8080
+- **API Docs:** http://localhost:8080/docs
+
+## Project Structure
+
+\`\`\`
+${vars.projectSlug}/
+\u251C\u2500\u2500 apps/
+\u2502   \u251C\u2500\u2500 web/          # Next.js frontend
+\u2502   \u2514\u2500\u2500 api/          # Fastify backend
+\u2514\u2500\u2500 packages/
+    \u251C\u2500\u2500 types/        # Shared Zod schemas
+    \u251C\u2500\u2500 utils/        # Shared utilities
+    \u2514\u2500\u2500 ui/           # Shared UI components
+\`\`\`
+
+## Database
+
+\`\`\`bash
+pnpm db:studio        # Open Prisma Studio
+pnpm db:migrate       # Run migrations
+pnpm db:seed          # Seed database
+\`\`\`
+
+---
+
+Built with [Blitzpack](https://github.com/CarboxyDev/blitzpack)
+`;
+}
+async function transformFiles(targetDir, vars) {
+  for (const relativePath of REPLACEABLE_FILES) {
+    const filePath = path2.join(targetDir, relativePath);
+    if (!await fs2.pathExists(filePath)) {
+      continue;
+    }
+    const content = await fs2.readFile(filePath, "utf-8");
+    let transformed;
+    if (relativePath === "README.md") {
+      transformed = generateReadme(vars);
+    } else if (relativePath.endsWith("package.json")) {
+      transformed = transformPackageJson(content, vars, relativePath);
+    } else if (relativePath.includes("site.ts")) {
+      transformed = transformSiteConfig(content, vars);
+    } else if (relativePath.includes("layout.tsx")) {
+      transformed = transformLayout(content, vars);
+    } else if (relativePath.includes("swagger.ts")) {
+      transformed = transformSwagger(content, vars);
+    } else {
+      transformed = content;
+    }
+    await fs2.writeFile(filePath, transformed, "utf-8");
+  }
+}
+
+// src/commands/create.ts
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var ENV_FILES = [
+  { from: "apps/web/.env.local.example", to: "apps/web/.env.local" },
+  { from: "apps/api/.env.local.example", to: "apps/api/.env.local" }
+];
+async function copyEnvFiles(targetDir) {
+  for (const { from, to } of ENV_FILES) {
+    const source = path3.join(targetDir, from);
+    const dest = path3.join(targetDir, to);
+    if (await fs3.pathExists(source)) {
+      await fs3.copy(source, dest);
+    }
+  }
+}
+function runInstall(cwd) {
+  return new Promise((resolve) => {
+    const isWindows = process.platform === "win32";
+    const child = spawn(isWindows ? "pnpm.cmd" : "pnpm", ["install"], {
+      cwd,
+      stdio: "ignore"
+    });
+    child.on("close", (code) => resolve(code === 0));
+    child.on("error", () => resolve(false));
+  });
+}
+function printDryRun(options) {
+  console.log(chalk2.yellow("  Dry run mode - no changes will be made"));
+  console.log();
+  console.log(chalk2.bold("  Would create:"));
+  console.log();
+  console.log(`    ${chalk2.cyan("Directory:")}    ${options.targetDir}`);
+  console.log(`    ${chalk2.cyan("Name:")}         ${options.projectName}`);
+  console.log(`    ${chalk2.cyan("Slug:")}         ${options.projectSlug}`);
+  console.log(
+    `    ${chalk2.cyan("Description:")}  ${options.projectDescription}`
+  );
+  console.log();
+  console.log(chalk2.bold("  Would run:"));
+  console.log();
+  console.log(`    ${chalk2.dim("\u2022")} Copy template files`);
+  console.log(`    ${chalk2.dim("\u2022")} Transform package.json files`);
+  console.log(`    ${chalk2.dim("\u2022")} Create .env.local files`);
+  if (!options.skipGit) {
+    console.log(`    ${chalk2.dim("\u2022")} Initialize git repository`);
+  }
+  if (!options.skipInstall) {
+    console.log(`    ${chalk2.dim("\u2022")} Install dependencies (pnpm install)`);
+  }
+  console.log();
+}
+async function create(projectName, flags) {
+  printHeader();
+  const options = await getProjectOptions(projectName, flags);
+  if (!options) {
+    return;
+  }
+  const targetDir = path3.resolve(process.cwd(), options.projectName);
+  if (flags.dryRun) {
+    printDryRun({
+      projectName: options.projectName,
+      projectSlug: options.projectSlug,
+      projectDescription: options.projectDescription,
+      targetDir,
+      skipGit: options.skipGit,
+      skipInstall: options.skipInstall
+    });
+    return;
+  }
+  if (await fs3.pathExists(targetDir)) {
+    const files = await fs3.readdir(targetDir);
+    if (files.length > 0) {
+      printError(`Directory "${options.projectName}" is not empty`);
+      return;
+    }
+  }
+  const templateDir = path3.resolve(__dirname, "..", "template");
+  if (!await fs3.pathExists(templateDir)) {
+    printError(
+      "Template directory not found. This is a bug in create-blitzpack."
+    );
+    return;
+  }
+  const spinner = ora();
+  try {
+    spinner.start("Creating project structure...");
+    await copyTemplate(templateDir, targetDir);
+    spinner.succeed("Created project structure");
+    spinner.start("Configuring project...");
+    await transformFiles(targetDir, {
+      projectName: options.projectName,
+      projectSlug: options.projectSlug,
+      projectDescription: options.projectDescription
+    });
+    await copyEnvFiles(targetDir);
+    spinner.succeed("Configured project");
+    if (!options.skipGit && isGitInstalled()) {
+      spinner.start("Initializing git repository...");
+      const gitSuccess = initGit(targetDir);
+      if (gitSuccess) {
+        spinner.succeed("Initialized git repository");
+      } else {
+        spinner.warn("Failed to initialize git repository");
+      }
+    }
+    if (!options.skipInstall) {
+      spinner.start("Installing dependencies...");
+      const success = await runInstall(targetDir);
+      if (success) {
+        spinner.succeed("Installed dependencies");
+      } else {
+        spinner.warn(
+          'Failed to install dependencies. Run "pnpm install" manually.'
+        );
+      }
+    }
+    printSuccess(options.projectName, options.projectName);
+  } catch (error) {
+    spinner.fail();
+    printError(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("create-blitzpack").description("Create a new Blitzpack project").version("0.1.0").argument("[project-name]", "Name of the project").option("--skip-git", "Skip git initialization").option("--skip-install", "Skip dependency installation").option("--dry-run", "Show what would be done without making changes").action(async (projectName, options) => {
+  await create(projectName, options);
+});
+program.parse();

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "create-blitzpack",
+  "version": "0.1.0",
+  "description": "Create a new Blitzpack project - full-stack TypeScript monorepo with Next.js and Fastify",
+  "type": "module",
+  "bin": {
+    "create-blitzpack": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "template"
+  ],
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "pnpm run build:template && tsup",
+    "build:template": "node scripts/copy-template.js",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist template"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "fs-extra": "^11.3.0",
+    "ora": "^8.2.0",
+    "prompts": "^2.4.2",
+    "validate-npm-package-name": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.10.5",
+    "@types/prompts": "^2.4.9",
+    "@types/validate-npm-package-name": "^4.0.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.7.2"
+  },
+  "keywords": [
+    "create",
+    "template",
+    "monorepo",
+    "nextjs",
+    "fastify",
+    "typescript",
+    "full-stack",
+    "prisma",
+    "turborepo"
+  ],
+  "author": "CarboxyDev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CarboxyDev/blitzpack"
+  },
+  "homepage": "https://github.com/CarboxyDev/blitzpack",
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/template/.dockerignore

@@ -0,0 +1,59 @@
+# Dependencies
+node_modules
+npm-debug.log
+pnpm-debug.log
+yarn-error.log
+
+# Build outputs (but keep package dist/ folders for copying built packages)
+# We ignore these initially but packages/*/dist will be built during Docker build
+.next
+.turbo
+*.tsbuildinfo
+apps/*/dist
+
+# Testing
+coverage
+.vitest
+
+# Environment files (never include in image)
+.env
+.env.local
+.env.*.local
+.env.development
+.env.production
+
+# Git
+.git
+.gitignore
+.github
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+logs
+*.log
+
+# Documentation (not needed in production)
+README.md
+DEPLOYMENT.md
+CLAUDE.md
+*.md
+
+# Docker
+Dockerfile
+.dockerignore
+docker-compose.yml
+
+# Misc
+.husky
+scripts
+# Keep config/ for package builds