deploy-bbc 0.0.1

package/cli/src/helpers/init-git.ts

@@ -0,0 +1,33 @@
+import { execa } from "execa";
+import chalk from "chalk";
+
+/**
+ * Initializes a Git repository and creates an initial commit.
+ * Does not throw on failure - git is optional.
+ *
+ * @param projectDir - Absolute path to the project directory
+ */
+export async function init_git(projectDir: string): Promise<void> {
+  try {
+    // Initialize git repository
+    await execa("git", ["init"], { cwd: projectDir });
+
+    // Add all files
+    await execa("git", ["add", "."], { cwd: projectDir });
+
+    // Create initial commit
+    await execa(
+      "git",
+      ["commit", "-m", "Initial commit from deploy-bbc"],
+      { cwd: projectDir }
+    );
+
+    console.log(chalk.green("✓") + " Git repository initialized");
+  } catch (error) {
+    // Git initialization is optional, so just warn on failure
+    console.log(
+      chalk.yellow("⚠") +
+        " Git initialization failed (this is optional and can be done manually)"
+    );
+  }
+}

package/cli/src/helpers/install-dependencies.ts

@@ -0,0 +1,28 @@
+import { execa } from "execa";
+import ora from "ora";
+
+/**
+ * Installs project dependencies using Bun package manager.
+ * Runs `bun install` in the project directory.
+ *
+ * @param projectDir - Absolute path to the project directory
+ * @throws Error if installation fails
+ */
+export async function install_dependencies(projectDir: string): Promise<void> {
+  const spinner = ora("Installing dependencies...").start();
+
+  try {
+    await execa("bun", ["install"], {
+      cwd: projectDir,
+      stdio: "inherit",
+    });
+
+    spinner.succeed("Dependencies installed successfully");
+  } catch (error) {
+    spinner.fail("Failed to install dependencies");
+    console.error("\nYou can install dependencies manually by running:");
+    console.error(`  cd ${projectDir}`);
+    console.error(`  bun install\n`);
+    throw error;
+  }
+}

package/cli/src/helpers/log-next-steps.ts

@@ -0,0 +1,84 @@
+import chalk from "chalk";
+import { type InstallerOptions } from "../types/index.js";
+import { type CliResults } from "../types/index.js";
+import { AvailablePackages } from "../types/index.js";
+
+/**
+ * Displays next steps for the user after project creation.
+ * Shows commands for navigation, Docker setup, migrations, and running the dev server.
+ *
+ * @param options - Installer options with project configuration
+ * @param cliResults - CLI results with selected packages and flags
+ */
+export function log_next_steps(
+  options: InstallerOptions,
+  _cliResults: CliResults
+): void {
+  const { appName, packages } = options;
+
+  console.log("\n" + chalk.bold.green("✨ Project created successfully!"));
+  console.log("\n" + chalk.bold("Next steps:"));
+  console.log();
+
+  // Step 1: Navigate to project
+  console.log(chalk.cyan("1.") + " Navigate to your project:");
+  console.log(`   ${chalk.gray("cd")} ${appName}`);
+  console.log();
+
+  // Step 2: Environment variables
+  console.log(chalk.cyan("2.") + " Set up environment variables:");
+  console.log(`   ${chalk.gray("cp")} .env.example .env`);
+  console.log(`   ${chalk.gray("# Edit .env with your configuration")}`);
+  console.log();
+
+  // Step 3: Docker (if database or redis selected)
+  const hasDocker =
+    packages.includes(AvailablePackages.postgres) ||
+    packages.includes(AvailablePackages.mysql) ||
+    packages.includes(AvailablePackages.mongodb) ||
+    packages.includes(AvailablePackages.redis);
+
+  if (hasDocker) {
+    console.log(chalk.cyan("3.") + " Start Docker services:");
+    console.log(`   ${chalk.gray("docker-compose up -d")}`);
+    console.log();
+  }
+
+  // Step 4: Database migrations (if postgres or mysql)
+  const needsMigration =
+    packages.includes(AvailablePackages.postgres) ||
+    packages.includes(AvailablePackages.mysql);
+
+  if (needsMigration) {
+    const stepNum = hasDocker ? "4" : "3";
+    console.log(chalk.cyan(`${stepNum}.`) + " Run database migrations:");
+    console.log(`   ${chalk.gray("bun run db:migrate")}`);
+    console.log();
+  }
+
+  // Step 5: Start development server
+  const lastStepNum = needsMigration
+    ? hasDocker
+      ? "5"
+      : "4"
+    : hasDocker
+    ? "4"
+    : "3";
+  console.log(chalk.cyan(`${lastStepNum}.`) + " Start the development server:");
+  console.log(`   ${chalk.gray("bun run dev")}`);
+  console.log();
+
+  // Additional info for docs
+  if (
+    packages.includes(AvailablePackages.swagger) ||
+    packages.includes(AvailablePackages.scalar)
+  ) {
+    console.log(
+      chalk.bold("📚 API Documentation:") + " http://localhost:3000/docs"
+    );
+    console.log();
+  }
+
+  console.log(chalk.gray("Happy coding! 🚀"));
+  console.log();
+}

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

@@ -0,0 +1,62 @@
+import path from "path";
+import fs from "fs-extra";
+import ora from "ora";
+import { fileURLToPath } from "url";
+import { type InstallerOptions } from "../types/index.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Scaffolds the base project structure by copying template files.
+ * Creates the project directory and copies all files from templates/base/
+ *
+ * @param options - Installer options containing projectDir and other config
+ * @throws Error if project directory already exists and is not empty
+ */
+export async function scaffold_project(
+  options: InstallerOptions
+): Promise<void> {
+  const { projectDir, appName, framework } = options;
+  const spinner = ora("Scaffolding project...").start();
+
+  try {
+    // Check if directory exists and is not empty
+    if (await fs.pathExists(projectDir)) {
+      const files = await fs.readdir(projectDir);
+      if (files.length > 0) {
+        spinner.fail(`Directory ${projectDir} already exists and is not empty`);
+        throw new Error(
+          `Cannot create project: directory "${appName}" is not empty`
+        );
+      }
+    }
+
+    // Ensure project directory exists
+    await fs.ensureDir(projectDir);
+
+    // Select base template based on framework
+    const templateDirName = framework === "hono"
+      ? "base"
+      : framework === "express"
+        ? "base-express"
+        : "base-bun-native";
+
+    const templateDir = path.resolve(__dirname, `../templates/${templateDirName}`);
+    await fs.copy(templateDir, projectDir, {
+      overwrite: false,
+      errorOnExist: false,
+    });
+
+    // Update package.json with the actual project name
+    const packageJsonPath = path.join(projectDir, "package.json");
+    const packageJson = await fs.readJson(packageJsonPath);
+    packageJson.name = appName;
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+
+    spinner.succeed("Project scaffolded successfully");
+  } catch (error) {
+    spinner.fail("Failed to scaffold project");
+    throw error;
+  }
+}

package/cli/src/index.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import { run_cli } from "./cli/index.js";
+import { create_project } from "./helpers/create-project.js";
+import { logger } from "./utils/logger.js";
+
+async function main() {
+  try {
+    const cliResults = await run_cli();
+    await create_project(cliResults);
+  } catch (error) {
+    logger.error("\n❌ An error occurred:");
+    logger.error(error);
+    process.exit(1);
+  }
+}
+
+main();

package/cli/src/installers/ai.ts

@@ -0,0 +1,123 @@
+import path from "path";
+import fs from "fs-extra";
+import { fileURLToPath } from "url";
+import { type InstallerOptions, AvailablePackages } from "../types/index.js";
+import { add_package_dependency } from "../utils/add-package-dependency.js";
+import { DEPENDENCY_VERSION_MAP } from "../utils/dependency-version-map.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * AI installer - handles OpenAI, Anthropic, Gemini, and Vercel AI SDK.
+ *
+ * @param options - Installer options with selected packages
+ */
+export async function ai_installer(options: InstallerOptions): Promise<void> {
+  const { projectDir, packages } = options;
+
+  for (const pkg of packages) {
+    switch (pkg) {
+      case AvailablePackages.openai:
+        await install_openai(projectDir);
+        break;
+      case AvailablePackages.anthropic:
+        await install_anthropic(projectDir);
+        break;
+      case AvailablePackages.gemini:
+        await install_gemini(projectDir);
+        break;
+      case AvailablePackages.vercelAI:
+        await install_vercel_ai(projectDir);
+        break;
+    }
+  }
+}
+
+async function install_openai(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(__dirname, "../templates/extras/ai/openai");
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    openai: DEPENDENCY_VERSION_MAP["openai"],
+  });
+
+  await append_env_example(
+    projectDir,
+    "\n# OpenAI Configuration\nOPENAI_API_KEY=your-openai-api-key\n"
+  );
+}
+
+async function install_anthropic(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(
+    __dirname,
+    "../templates/extras/ai/anthropic"
+  );
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    "@anthropic-ai/sdk": DEPENDENCY_VERSION_MAP["@anthropic-ai/sdk"],
+  });
+
+  await append_env_example(
+    projectDir,
+    "\n# Anthropic Configuration\nANTHROPIC_API_KEY=your-anthropic-api-key\n"
+  );
+}
+
+async function install_gemini(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(__dirname, "../templates/extras/ai/gemini");
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    "@google/generative-ai": DEPENDENCY_VERSION_MAP["@google/generative-ai"],
+  });
+
+  await append_env_example(
+    projectDir,
+    "\n# Google Gemini Configuration\nGEMINI_API_KEY=your-gemini-api-key\n"
+  );
+}
+
+async function install_vercel_ai(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(
+    __dirname,
+    "../templates/extras/ai/vercel-ai"
+  );
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    ai: DEPENDENCY_VERSION_MAP["ai"],
+  });
+
+  await append_env_example(
+    projectDir,
+    "\n# Vercel AI SDK Configuration\n# Add API keys for the providers you want to use with Vercel AI\n"
+  );
+}
+
+async function copy_template_files(
+  templateDir: string,
+  projectDir: string
+): Promise<void> {
+  if (!(await fs.pathExists(templateDir))) {
+    return;
+  }
+
+  const srcDir = path.join(templateDir, "src");
+  if (await fs.pathExists(srcDir)) {
+    const targetSrcDir = path.join(projectDir, "src");
+    await fs.copy(srcDir, targetSrcDir, {
+      overwrite: false,
+      errorOnExist: false,
+    });
+  }
+}
+
+async function append_env_example(
+  projectDir: string,
+  content: string
+): Promise<void> {
+  const envPath = path.join(projectDir, ".env.example");
+  await fs.appendFile(envPath, content);
+}

package/cli/src/installers/auth.ts

@@ -0,0 +1,132 @@
+import path from "path";
+import fs from "fs-extra";
+import { fileURLToPath } from "url";
+import { type InstallerOptions, AvailablePackages } from "../types/index.js";
+import { add_package_dependency } from "../utils/add-package-dependency.js";
+import { DEPENDENCY_VERSION_MAP } from "../utils/dependency-version-map.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Auth installer - handles JWT, OAuth, and session authentication.
+ *
+ * @param options - Installer options with selected packages
+ */
+export async function auth_installer(
+  options: InstallerOptions
+): Promise<void> {
+  const { projectDir, packages } = options;
+
+  for (const pkg of packages) {
+    switch (pkg) {
+      case AvailablePackages.jwt:
+        await install_jwt(projectDir);
+        break;
+      case AvailablePackages.oauth:
+        await install_oauth(projectDir);
+        break;
+      case AvailablePackages.session:
+        await install_session(projectDir);
+        break;
+    }
+  }
+}
+
+async function install_jwt(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(__dirname, "../templates/extras/auth/jwt");
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    jsonwebtoken: DEPENDENCY_VERSION_MAP["jsonwebtoken"],
+    bcryptjs: DEPENDENCY_VERSION_MAP["bcryptjs"],
+  });
+
+  await add_package_dependency(
+    projectDir,
+    {},
+    {
+      "@types/jsonwebtoken": DEPENDENCY_VERSION_MAP["@types/jsonwebtoken"],
+      "@types/bcryptjs": DEPENDENCY_VERSION_MAP["@types/bcryptjs"],
+    }
+  );
+
+  await append_env_example(
+    projectDir,
+    "\n# JWT Authentication\nJWT_SECRET=your-super-secret-jwt-key-change-this\nJWT_EXPIRES_IN=7d\n"
+  );
+}
+
+async function install_oauth(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(__dirname, "../templates/extras/auth/oauth");
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    passport: DEPENDENCY_VERSION_MAP["passport"],
+    "passport-oauth2": DEPENDENCY_VERSION_MAP["passport-oauth2"],
+  });
+
+  await add_package_dependency(
+    projectDir,
+    {},
+    {
+      "@types/passport": DEPENDENCY_VERSION_MAP["@types/passport"],
+    }
+  );
+
+  await append_env_example(
+    projectDir,
+    "\n# OAuth Configuration\nOAUTH_CLIENT_ID=your-client-id\nOAUTH_CLIENT_SECRET=your-client-secret\nOAUTH_CALLBACK_URL=http://localhost:3000/auth/callback\n"
+  );
+}
+
+async function install_session(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(
+    __dirname,
+    "../templates/extras/auth/session"
+  );
+  await copy_template_files(templateDir, projectDir);
+
+  await append_env_example(
+    projectDir,
+    "\n# Session Configuration\nSESSION_SECRET=your-super-secret-session-key-change-this\n"
+  );
+}
+
+async function copy_template_files(
+  templateDir: string,
+  projectDir: string
+): Promise<void> {
+  if (!(await fs.pathExists(templateDir))) {
+    return;
+  }
+
+  const srcDir = path.join(templateDir, "src");
+  if (await fs.pathExists(srcDir)) {
+    const targetSrcDir = path.join(projectDir, "src");
+    await fs.copy(srcDir, targetSrcDir, {
+      overwrite: false,
+      errorOnExist: false,
+    });
+  }
+
+  const templateFiles = await fs.readdir(templateDir);
+  for (const file of templateFiles) {
+    if (file !== "src" && (file.endsWith(".ts") || file.endsWith(".json"))) {
+      const srcFile = path.join(templateDir, file);
+      const destFile = path.join(projectDir, file);
+
+      if (!(await fs.pathExists(destFile))) {
+        await fs.copy(srcFile, destFile);
+      }
+    }
+  }
+}
+
+async function append_env_example(
+  projectDir: string,
+  content: string
+): Promise<void> {
+  const envPath = path.join(projectDir, ".env.example");
+  await fs.appendFile(envPath, content);
+}

package/cli/src/installers/base.ts

@@ -0,0 +1,16 @@
+import { type InstallerOptions } from "../types/index.js";
+
+/**
+ * Base installer - handles any base setup that's not covered by scaffold_project.
+ * Currently minimal since scaffold_project handles most base template copying.
+ *
+ * @param options - Installer options
+ */
+export async function base_installer(
+  _options: InstallerOptions
+): Promise<void> {
+  // Base setup is handled by scaffold_project
+  // This installer exists for any additional base configuration
+  // that might be needed in the future
+  return Promise.resolve();
+}

package/cli/src/installers/cloud.ts

@@ -0,0 +1,127 @@
+import path from "path";
+import fs from "fs-extra";
+import { fileURLToPath } from "url";
+import { type InstallerOptions, AvailablePackages } from "../types/index.js";
+import { add_package_dependency } from "../utils/add-package-dependency.js";
+import { DEPENDENCY_VERSION_MAP } from "../utils/dependency-version-map.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Cloud installer - handles AWS, GCP, Azure, and Cloudflare R2.
+ *
+ * @param options - Installer options with selected packages
+ */
+export async function cloud_installer(
+  options: InstallerOptions
+): Promise<void> {
+  const { projectDir, packages } = options;
+
+  for (const pkg of packages) {
+    switch (pkg) {
+      case AvailablePackages.aws:
+        await install_aws(projectDir);
+        break;
+      case AvailablePackages.gcp:
+        await install_gcp(projectDir);
+        break;
+      case AvailablePackages.azure:
+        await install_azure(projectDir);
+        break;
+      case AvailablePackages.cloudflareR2:
+        await install_cloudflare_r2(projectDir);
+        break;
+    }
+  }
+}
+
+async function install_aws(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(__dirname, "../templates/extras/cloud/aws");
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    "@aws-sdk/client-s3": DEPENDENCY_VERSION_MAP["@aws-sdk/client-s3"],
+    "@aws-sdk/s3-request-presigner":
+      DEPENDENCY_VERSION_MAP["@aws-sdk/s3-request-presigner"],
+  });
+
+  await append_env_example(
+    projectDir,
+    "\n# AWS Configuration\nAWS_ACCESS_KEY_ID=your-aws-access-key\nAWS_SECRET_ACCESS_KEY=your-aws-secret-key\nAWS_REGION=us-east-1\nAWS_S3_BUCKET=your-bucket-name\n"
+  );
+}
+
+async function install_gcp(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(__dirname, "../templates/extras/cloud/gcp");
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    "@google-cloud/storage": DEPENDENCY_VERSION_MAP["@google-cloud/storage"],
+  });
+
+  await append_env_example(
+    projectDir,
+    "\n# Google Cloud Platform Configuration\nGCP_PROJECT_ID=your-project-id\nGCP_BUCKET_NAME=your-bucket-name\n# GCP_KEY_FILE=path/to/service-account-key.json\n"
+  );
+}
+
+async function install_azure(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(
+    __dirname,
+    "../templates/extras/cloud/azure"
+  );
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    "@azure/storage-blob": DEPENDENCY_VERSION_MAP["@azure/storage-blob"],
+  });
+
+  await append_env_example(
+    projectDir,
+    "\n# Azure Configuration\nAZURE_STORAGE_CONNECTION_STRING=your-connection-string\nAZURE_STORAGE_CONTAINER=your-container-name\n"
+  );
+}
+
+async function install_cloudflare_r2(projectDir: string): Promise<void> {
+  const templateDir = path.resolve(
+    __dirname,
+    "../templates/extras/cloud/cloudflare-r2"
+  );
+  await copy_template_files(templateDir, projectDir);
+
+  await add_package_dependency(projectDir, {
+    "@aws-sdk/client-s3": DEPENDENCY_VERSION_MAP["@aws-sdk/client-s3"],
+  });
+
+  await append_env_example(
+    projectDir,
+    "\n# Cloudflare R2 Configuration\nCLOUDFLARE_ACCOUNT_ID=your-account-id\nCLOUDFLARE_ACCESS_KEY_ID=your-access-key\nCLOUDFLARE_SECRET_ACCESS_KEY=your-secret-key\nCLOUDFLARE_R2_BUCKET=your-bucket-name\n"
+  );
+}
+
+async function copy_template_files(
+  templateDir: string,
+  projectDir: string
+): Promise<void> {
+  if (!(await fs.pathExists(templateDir))) {
+    return;
+  }
+
+  const srcDir = path.join(templateDir, "src");
+  if (await fs.pathExists(srcDir)) {
+    const targetSrcDir = path.join(projectDir, "src");
+    await fs.copy(srcDir, targetSrcDir, {
+      overwrite: false,
+      errorOnExist: false,
+    });
+  }
+}
+
+async function append_env_example(
+  projectDir: string,
+  content: string
+): Promise<void> {
+  const envPath = path.join(projectDir, ".env.example");
+  await fs.appendFile(envPath, content);
+}