deploy-bbc 0.0.1

package/cli/src/cli/index.ts

@@ -0,0 +1,449 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { Command } from "commander";
+import { type CliFlags, type CliResults, AvailablePackages } from "../types/index.js";
+
+const defaultOptions: CliFlags = {
+  noGit: false,
+  noInstall: false,
+  default: false,
+  CI: false,
+};
+
+export const run_cli = async (): Promise<CliResults> => {
+  const program = new Command()
+    .name("deploy-bbc")
+    .description("Bootstrap a production-ready backend with Bun")
+    .argument("[dir]", "The name of the application")
+    .option("--noGit", "Skip git initialization", defaultOptions.noGit)
+    .option("--noInstall", "Skip dependency installation", defaultOptions.noInstall)
+    .option("--default", "Use default options", defaultOptions.default)
+    // CI Mode
+    .option("--CI", "Run in CI mode (non-interactive)", defaultOptions.CI)
+    // Framework options
+    .option("--hono", "Use Hono framework (default)")
+    .option("--express", "Use Express framework")
+    .option("--bun-native", "Use Bun native HTTP server")
+    // Database options
+    .option("--postgres", "Include PostgreSQL")
+    .option("--mysql", "Include MySQL")
+    .option("--mongodb", "Include MongoDB")
+    .option("--redis", "Include Redis")
+    // Auth options
+    .option("--jwt", "Include JWT authentication")
+    .option("--oauth", "Include OAuth 2.0")
+    .option("--session", "Include session-based auth")
+    // AI options
+    .option("--openai", "Include OpenAI SDK")
+    .option("--anthropic", "Include Anthropic Claude SDK")
+    .option("--gemini", "Include Google Gemini SDK")
+    .option("--vercelAI", "Include Vercel AI SDK")
+    // Cloud options
+    .option("--aws", "Include AWS SDK")
+    .option("--gcp", "Include Google Cloud SDK")
+    .option("--azure", "Include Azure SDK")
+    .option("--cloudflareR2", "Include Cloudflare R2")
+    // Communication options
+    .option("--resend", "Include Resend email service")
+    .option("--sendgrid", "Include SendGrid")
+    .option("--nodemailer", "Include NodeMailer")
+    .option("--socketio", "Include Socket.io")
+    .option("--sse", "Include Server-Sent Events")
+    // Infrastructure options
+    .option("--bullmq", "Include BullMQ")
+    .option("--inngest", "Include Inngest")
+    .option("--upstashRateLimit", "Include Upstash Rate Limit")
+    .option("--customRateLimit", "Include custom rate limiting")
+    .option("--sentry", "Include Sentry")
+    .option("--logtail", "Include LogTail")
+    // DevX options
+    .option("--swagger", "Include Swagger/OpenAPI")
+    .option("--scalar", "Include Scalar API docs")
+    .option("--vitest", "Include Vitest testing")
+    // Validation options
+    .option("--zod", "Include Zod validation")
+    .option("--yup", "Include Yup validation")
+    .parse(process.argv);
+
+  const cliProvidedName = program.args[0];
+  const cliOptions = program.opts<CliFlags>();
+
+  // CI Mode - skip interactive prompts
+  if (cliOptions.CI) {
+    return build_from_flags(cliProvidedName, cliOptions);
+  }
+
+  // Interactive Mode
+  const intro = `
+╔═══════════════════════════════════════════════╗
+║                                               ║
+║     🚀  deploy-bbc                            ║
+║         (Best Backend Code)                   ║
+║                                               ║
+║     Bootstrap a production-ready backend      ║
+║     with Bun, TypeScript & Docker             ║
+║                                               ║
+╚═══════════════════════════════════════════════╝
+  `;
+
+  console.log(chalk.cyan(intro));
+
+  p.intro(chalk.bgCyan(chalk.black(" deploy-bbc ")));
+
+  const project = await p.group(
+    {
+      // ──────────────────────────────────────────
+      // 📦 CORE
+      // ──────────────────────────────────────────
+      ...add_cli_header("📦 CORE"),
+
+      projectName: () =>
+        p.text({
+          message: "What will your project be called?",
+          placeholder: "my-awesome-api",
+          defaultValue: cliProvidedName || "my-backend",
+          validate: (value) => {
+            if (!value) return "Please enter a project name";
+            if (!/^[a-z0-9-_]+$/i.test(value))
+              return "Only letters, numbers, dashes and underscores";
+          },
+        }),
+
+      framework: () =>
+        p.select<any, "hono" | "express" | "bun-native">({
+          message: "Which framework would you like to use?",
+          options: [
+            {
+              value: "hono",
+              label: "Hono",
+              hint: "Ultrafast web framework (recommended)",
+            },
+            {
+              value: "express",
+              label: "Express",
+              hint: "Battle-tested Node.js framework",
+            },
+            {
+              value: "bun-native",
+              label: "Bun Native",
+              hint: "Native Bun.serve() API",
+            },
+          ],
+          initialValue: "hono",
+        }),
+
+      databases: () =>
+        p.multiselect({
+          message: "Which database(s) would you like to use?",
+          options: [
+            {
+              value: AvailablePackages.postgres,
+              label: "PostgreSQL",
+              hint: "Dockerized • Drizzle ORM",
+            },
+            {
+              value: AvailablePackages.mysql,
+              label: "MySQL",
+              hint: "Dockerized • Drizzle ORM",
+            },
+            {
+              value: AvailablePackages.mongodb,
+              label: "MongoDB",
+              hint: "Not dockerized • Mongoose",
+            },
+            {
+              value: AvailablePackages.redis,
+              label: "Redis",
+              hint: "Dockerized • Caching & Sessions",
+            },
+          ],
+          required: false,
+        }),
+
+      auth: () =>
+        p.multiselect({
+          message: "Select authentication methods:",
+          options: [
+            {
+              value: AvailablePackages.jwt,
+              label: "JWT Token Auth",
+              hint: "Stateless tokens",
+            },
+            {
+              value: AvailablePackages.oauth,
+              label: "OAuth 2.0",
+              hint: "Google, GitHub, etc.",
+            },
+            {
+              value: AvailablePackages.session,
+              label: "Session-based Auth",
+              hint: "Requires Redis",
+            },
+          ],
+          required: false,
+        }),
+
+      // ──────────────────────────────────────────
+      // 🤖 AI & ML
+      // ──────────────────────────────────────────
+      ...add_cli_header("🤖 AI & ML"),
+
+      aiProviders: () =>
+        p.multiselect({
+          message: "AI Providers: (select all that apply)",
+          options: [
+            {
+              value: AvailablePackages.openai,
+              label: "OpenAI",
+              hint: "GPT-4, DALL-E, Whisper",
+            },
+            {
+              value: AvailablePackages.anthropic,
+              label: "Anthropic Claude",
+              hint: "Claude 3.5 Sonnet",
+            },
+            {
+              value: AvailablePackages.gemini,
+              label: "Google Gemini",
+              hint: "Gemini Pro",
+            },
+            { value: "none", label: "None", hint: "Skip AI integration" },
+          ],
+          required: false,
+        }),
+
+      vercelAI: ({ results }) => {
+        const hasAI =
+          results.aiProviders?.length && results.aiProviders.length > 0 &&
+          !results.aiProviders?.includes("none");
+
+        if (!hasAI) return Promise.resolve(false);
+
+        return p.confirm({
+          message: "Use Vercel AI SDK for unified interface?",
+          initialValue: true,
+        });
+      },
+
+      // ──────────────────────────────────────────
+      // 📧 COMMUNICATIONS
+      // ──────────────────────────────────────────
+      ...add_cli_header("📧 COMMUNICATIONS"),
+
+      emailService: () =>
+        p.select<any, AvailablePackages | "none">({
+          message: "Email service:",
+          options: [
+            {
+              value: AvailablePackages.resend,
+              label: "Resend",
+              hint: "Modern, developer-first",
+            },
+            {
+              value: AvailablePackages.sendgrid,
+              label: "SendGrid",
+              hint: "Enterprise-grade",
+            },
+            {
+              value: AvailablePackages.nodemailer,
+              label: "NodeMailer (SMTP)",
+              hint: "Self-hosted",
+            },
+            { value: "none", label: "None" },
+          ],
+          initialValue: "none",
+        }),
+
+      realtime: () =>
+        p.select<any, AvailablePackages | "none">({
+          message: "Real-time capabilities:",
+          options: [
+            {
+              value: AvailablePackages.socketio,
+              label: "Socket.io",
+              hint: "WebSockets + fallbacks",
+            },
+            {
+              value: AvailablePackages.sse,
+              label: "Server-Sent Events (SSE)",
+              hint: "Native, unidirectional",
+            },
+            { value: "none", label: "None" },
+          ],
+          initialValue: "none",
+        }),
+
+      // ──────────────────────────────────────────
+      // 🔧 INFRASTRUCTURE
+      // ──────────────────────────────────────────
+      ...add_cli_header("🔧 INFRASTRUCTURE"),
+
+      backgroundJobs: () =>
+        p.select<any, AvailablePackages | "none">({
+          message: "Background jobs & queues:",
+          options: [
+            {
+              value: AvailablePackages.bullmq,
+              label: "BullMQ",
+              hint: "Redis-based, feature-rich",
+            },
+            {
+              value: AvailablePackages.inngest,
+              label: "Inngest",
+              hint: "Serverless-first, durable",
+            },
+            { value: "none", label: "None" },
+          ],
+          initialValue: "none",
+        }),
+
+      // ──────────────────────────────────────────
+      // 📚 DEVELOPER EXPERIENCE
+      // ──────────────────────────────────────────
+      ...add_cli_header("📚 DEVELOPER EXPERIENCE"),
+
+      apiDocs: () =>
+        p.select<any, AvailablePackages | "none">({
+          message: "API Documentation:",
+          options: [
+            {
+              value: AvailablePackages.swagger,
+              label: "Swagger/OpenAPI",
+              hint: "Industry standard",
+            },
+            {
+              value: AvailablePackages.scalar,
+              label: "Scalar",
+              hint: "Modern, beautiful UI",
+            },
+            { value: "none", label: "None" },
+          ],
+          initialValue: AvailablePackages.swagger,
+        }),
+
+      testing: () =>
+        p.confirm({
+          message: "Set up testing with Vitest?",
+          initialValue: true,
+        }),
+
+      validation: () =>
+        p.select<any, AvailablePackages | "none">({
+          message: "Request validation library:",
+          options: [
+            {
+              value: AvailablePackages.zod,
+              label: "Zod",
+              hint: "TypeScript-first, lightweight",
+            },
+            {
+              value: AvailablePackages.yup,
+              label: "Yup",
+              hint: "Schema builder, runtime validation",
+            },
+            { value: "none", label: "None" },
+          ],
+          initialValue: AvailablePackages.zod,
+        }),
+
+      installDeps: () =>
+        p.confirm({
+          message: "Install dependencies?",
+          initialValue: !cliOptions.noInstall,
+        }),
+
+      initGit: () =>
+        p.confirm({
+          message: "Initialize git repository?",
+          initialValue: !cliOptions.noGit,
+        }),
+    },
+    {
+      onCancel: () => {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      },
+    }
+  );
+
+  // Build packages array
+  const aiPackages = (project.aiProviders as (AvailablePackages | string)[] | undefined)?.filter(p => p !== "none") as AvailablePackages[] || [];
+  const packages: AvailablePackages[] = [
+    ...(project.databases || []),
+    ...(project.auth || []),
+    ...aiPackages,
+    project.vercelAI ? AvailablePackages.vercelAI : null,
+    typeof project.emailService === "string" && project.emailService !== "none" ? project.emailService as AvailablePackages : null,
+    typeof project.realtime === "string" && project.realtime !== "none" ? project.realtime as AvailablePackages : null,
+    typeof project.backgroundJobs === "string" && project.backgroundJobs !== "none" ? project.backgroundJobs as AvailablePackages : null,
+    typeof project.apiDocs === "string" && project.apiDocs !== "none" ? project.apiDocs as AvailablePackages : null,
+    project.testing ? AvailablePackages.vitest : null,
+    typeof project.validation === "string" && project.validation !== "none" ? project.validation as AvailablePackages : null,
+  ].filter(Boolean) as AvailablePackages[];
+
+  return {
+    appName: project.projectName as string,
+    framework: project.framework as "hono" | "express" | "bun-native",
+    packages,
+    flags: {
+      ...defaultOptions,
+      noInstall: !project.installDeps,
+      noGit: !project.initGit,
+    },
+  };
+};
+
+// Helper to add section headers
+function add_cli_header(title: string) {
+  return {
+    [`_${title.replace(/[^a-zA-Z0-9]/g, "")}`]: () => {
+      console.log(chalk.bold.cyan(`\n${title}`));
+      return Promise.resolve();
+    },
+  };
+}
+
+// Build project from CLI flags (CI mode)
+function build_from_flags(
+  appName: string | undefined,
+  flags: CliFlags & { hono?: boolean; express?: boolean; "bun-native"?: boolean }
+): CliResults {
+  const packages: AvailablePackages[] = [];
+
+  // Determine framework
+  let framework: "hono" | "express" | "bun-native" = "hono";
+  if (flags.express) framework = "express";
+  else if (flags["bun-native"]) framework = "bun-native";
+
+  // Add packages based on flags
+  if (flags.postgres) packages.push(AvailablePackages.postgres);
+  if (flags.mysql) packages.push(AvailablePackages.mysql);
+  if (flags.mongodb) packages.push(AvailablePackages.mongodb);
+  if (flags.redis) packages.push(AvailablePackages.redis);
+  if (flags.jwt) packages.push(AvailablePackages.jwt);
+  if (flags.oauth) packages.push(AvailablePackages.oauth);
+  if (flags.session) packages.push(AvailablePackages.session);
+  if (flags.openai) packages.push(AvailablePackages.openai);
+  if (flags.anthropic) packages.push(AvailablePackages.anthropic);
+  if (flags.gemini) packages.push(AvailablePackages.gemini);
+  if (flags.vercelAI) packages.push(AvailablePackages.vercelAI);
+  if (flags.resend) packages.push(AvailablePackages.resend);
+  if (flags.sendgrid) packages.push(AvailablePackages.sendgrid);
+  if (flags.nodemailer) packages.push(AvailablePackages.nodemailer);
+  if (flags.socketio) packages.push(AvailablePackages.socketio);
+  if (flags.sse) packages.push(AvailablePackages.sse);
+  if (flags.bullmq) packages.push(AvailablePackages.bullmq);
+  if (flags.inngest) packages.push(AvailablePackages.inngest);
+  if (flags.swagger) packages.push(AvailablePackages.swagger);
+  if (flags.scalar) packages.push(AvailablePackages.scalar);
+  if (flags.vitest) packages.push(AvailablePackages.vitest);
+  if (flags.zod) packages.push(AvailablePackages.zod);
+  if (flags.yup) packages.push(AvailablePackages.yup);
+
+  return {
+    appName: appName || "my-backend",
+    framework,
+    packages,
+    flags,
+  };
+}

package/cli/src/helpers/create-project.ts

@@ -0,0 +1,66 @@
+import { type CliResults, type InstallerOptions } from "../types/index.js";
+import { parse_name_and_path } from "../utils/parse-name-and-path.js";
+import { scaffold_project } from "./scaffold-project.js";
+import { build_installer_map, run_installers } from "../installers/index.js";
+import { generate_dockerfile } from "./generate-dockerfile.js";
+import { generate_docker_compose } from "./generate-docker-compose.js";
+import { install_dependencies } from "./install-dependencies.js";
+import { init_git } from "./init-git.js";
+import { log_next_steps } from "./log-next-steps.js";
+import { render_title } from "../utils/render-title.js";
+
+/**
+ * Main orchestration function for project creation.
+ * Coordinates all steps: parsing, scaffolding, installing packages, and setup.
+ *
+ * @param cliResults - Results from CLI argument parsing
+ */
+export async function create_project(cliResults: CliResults): Promise<void> {
+  try {
+    // Step 1: Parse and validate project name and path
+    render_title("Validating project name");
+    const { projectName, projectDir } = parse_name_and_path(cliResults.appName);
+
+    // Step 2: Create installer options
+    const installerOptions: InstallerOptions = {
+      projectDir,
+      appName: projectName,
+      framework: cliResults.framework,
+      packages: cliResults.packages,
+      noInstall: cliResults.flags.noInstall,
+    };
+
+    // Step 3: Scaffold base project structure
+    render_title("Creating project structure");
+    await scaffold_project(installerOptions);
+
+    // Step 4: Build installer map and run installers
+    render_title("Installing selected packages");
+    const installerMap = build_installer_map(installerOptions);
+    await run_installers(installerMap, installerOptions);
+
+    // Step 5: Generate Docker files
+    render_title("Generating Docker configuration");
+    await generate_dockerfile(installerOptions);
+    await generate_docker_compose(installerOptions);
+
+    // Step 6: Install dependencies (unless --noInstall flag)
+    if (!cliResults.flags.noInstall) {
+      render_title("Installing dependencies");
+      await install_dependencies(projectDir);
+    }
+
+    // Step 7: Initialize Git (unless --noGit flag)
+    if (!cliResults.flags.noGit) {
+      render_title("Initializing Git repository");
+      await init_git(projectDir);
+    }
+
+    // Step 8: Display next steps
+    log_next_steps(installerOptions, cliResults);
+  } catch (error) {
+    console.error("\n❌ Project creation failed:");
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/cli/src/helpers/generate-docker-compose.ts

@@ -0,0 +1,133 @@
+import path from "path";
+import fs from "fs-extra";
+import { type InstallerOptions, AvailablePackages } from "../types/index.js";
+
+/**
+ * Generates a docker-compose.yml file based on selected packages.
+ * Includes services for databases, redis, and the main application.
+ *
+ * @param options - Installer options with selected packages
+ */
+export async function generate_docker_compose(
+  options: InstallerOptions
+): Promise<void> {
+  const { projectDir, packages, appName } = options;
+
+  // Check which services are needed
+  const hasPostgres = packages.includes(AvailablePackages.postgres);
+  const hasMysql = packages.includes(AvailablePackages.mysql);
+  const hasMongodb = packages.includes(AvailablePackages.mongodb);
+  const hasRedis = packages.includes(AvailablePackages.redis);
+
+  // Only generate docker-compose if we have any services to include
+  if (!hasPostgres && !hasMysql && !hasMongodb && !hasRedis) {
+    return;
+  }
+
+  let composeContent = `version: '3.8'
+
+services:
+`;
+
+  // Add app service
+  composeContent += `  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+    env_file:
+      - .env
+`;
+
+  // Add depends_on for databases
+  const dependencies: string[] = [];
+  if (hasPostgres) dependencies.push("postgres");
+  if (hasMysql) dependencies.push("mysql");
+  if (hasMongodb) dependencies.push("mongodb");
+  if (hasRedis) dependencies.push("redis");
+
+  if (dependencies.length > 0) {
+    composeContent += `    depends_on:
+`;
+    dependencies.forEach((dep) => {
+      composeContent += `      - ${dep}\n`;
+    });
+  }
+
+  // Add PostgreSQL service
+  if (hasPostgres) {
+    composeContent += `
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: \${POSTGRES_USER:-user}
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-password}
+      POSTGRES_DB: \${POSTGRES_DB:-${appName}}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+`;
+  }
+
+  // Add MySQL service
+  if (hasMysql) {
+    composeContent += `
+  mysql:
+    image: mysql:8.0
+    environment:
+      MYSQL_ROOT_PASSWORD: \${MYSQL_ROOT_PASSWORD:-rootpassword}
+      MYSQL_DATABASE: \${MYSQL_DATABASE:-${appName}}
+      MYSQL_USER: \${MYSQL_USER:-user}
+      MYSQL_PASSWORD: \${MYSQL_PASSWORD:-password}
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql_data:/var/lib/mysql
+`;
+  }
+
+  // Add MongoDB service
+  if (hasMongodb) {
+    composeContent += `
+  mongodb:
+    image: mongo:7.0
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: \${MONGO_ROOT_USER:-root}
+      MONGO_INITDB_ROOT_PASSWORD: \${MONGO_ROOT_PASSWORD:-password}
+      MONGO_INITDB_DATABASE: \${MONGO_DATABASE:-${appName}}
+    ports:
+      - "27017:27017"
+    volumes:
+      - mongodb_data:/data/db
+`;
+  }
+
+  // Add Redis service
+  if (hasRedis) {
+    composeContent += `
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    command: redis-server --appendonly yes
+`;
+  }
+
+  // Add volumes section
+  composeContent += `
+volumes:
+`;
+
+  if (hasPostgres) composeContent += `  postgres_data:\n`;
+  if (hasMysql) composeContent += `  mysql_data:\n`;
+  if (hasMongodb) composeContent += `  mongodb_data:\n`;
+  if (hasRedis) composeContent += `  redis_data:\n`;
+
+  // Write docker-compose.yml
+  const dockerComposePath = path.join(projectDir, "docker-compose.yml");
+  await fs.writeFile(dockerComposePath, composeContent);
+}

package/cli/src/helpers/generate-dockerfile.ts

@@ -0,0 +1,45 @@
+import path from "path";
+import fs from "fs-extra";
+import { type InstallerOptions } from "../types/index.js";
+
+/**
+ * Generates a Dockerfile for the project.
+ * Uses Bun's official image with multi-stage build for production optimization.
+ *
+ * @param options - Installer options
+ */
+export async function generate_dockerfile(
+  options: InstallerOptions
+): Promise<void> {
+  const { projectDir } = options;
+
+  const dockerfileContent = `# Use Bun's official image
+FROM oven/bun:1 as base
+WORKDIR /app
+
+# Install dependencies
+FROM base AS dependencies
+COPY package.json bun.lockb ./
+RUN bun install --frozen-lockfile
+
+# Copy source code
+FROM base AS build
+COPY --from=dependencies /app/node_modules ./node_modules
+COPY . .
+
+# Production image
+FROM base AS production
+ENV NODE_ENV=production
+COPY --from=dependencies /app/node_modules ./node_modules
+COPY --from=build /app .
+
+# Expose port
+EXPOSE 3000
+
+# Run the application
+CMD ["bun", "run", "src/index.ts"]
+`;
+
+  const dockerfilePath = path.join(projectDir, "Dockerfile");
+  await fs.writeFile(dockerfilePath, dockerfileContent);
+}