deploy-bbc 0.0.1

package/cli/src/templates/extras/validation/zod/src/middleware/validate.ts

@@ -0,0 +1,80 @@
+import { Context, Next } from "hono";
+import { z, ZodSchema } from "zod";
+
+/**
+ * Validation middleware for Hono using Zod schemas
+ * Validates request body, query parameters, or route params
+ */
+
+export type ValidateTarget = "body" | "query" | "param";
+
+interface ValidationOptions {
+  target: ValidateTarget;
+  schema: ZodSchema;
+}
+
+/**
+ * Create a validation middleware
+ * @param options - Validation configuration
+ * @returns Hono middleware function
+ */
+export function validate(options: ValidationOptions) {
+  return async (c: Context, next: Next) => {
+    try {
+      let data: unknown;
+
+      switch (options.target) {
+        case "body":
+          data = await c.req.json();
+          break;
+        case "query":
+          data = c.req.query();
+          break;
+        case "param":
+          data = c.req.param();
+          break;
+        default:
+          return c.json(
+            { error: "Invalid validation target" },
+            400
+          );
+      }
+
+      // Validate data against schema
+      const validated = options.schema.parse(data);
+
+      // Store validated data in context for route handlers
+      c.set(`validated_${options.target}`, validated);
+
+      await next();
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return c.json(
+          {
+            error: "Validation failed",
+            details: error.errors.map((err) => ({
+              path: err.path.join("."),
+              message: err.message,
+            })),
+          },
+          400
+        );
+      }
+
+      return c.json(
+        { error: "Invalid request data" },
+        400
+      );
+    }
+  };
+}
+
+/**
+ * Helper to get validated data from context
+ * @param c - Hono context
+ * @param target - Validation target (body/query/param)
+ * @returns Validated data
+ */
+export function get_validated<T>(c: Context, target: ValidateTarget): T {
+  return c.get(`validated_${target}`) as T;
+}

package/cli/src/templates/extras/validation/zod/src/routes/users.ts

@@ -0,0 +1,128 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { validate, get_validated } from "../middleware/validate.js";
+
+const users = new Hono();
+
+/**
+ * Zod Schemas for validation
+ */
+
+// Schema for creating a new user
+const create_user_schema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+  email: z.string().email("Invalid email format"),
+  age: z.number().int().min(18, "Must be at least 18 years old").optional(),
+});
+
+// Schema for updating a user
+const update_user_schema = z.object({
+  name: z.string().min(2).optional(),
+  email: z.string().email().optional(),
+  age: z.number().int().min(18).optional(),
+});
+
+// Schema for query parameters
+const list_users_query_schema = z.object({
+  page: z.string().regex(/^\d+$/).transform(Number).optional(),
+  limit: z.string().regex(/^\d+$/).transform(Number).optional(),
+  search: z.string().optional(),
+});
+
+// Schema for route params
+const user_id_param_schema = z.object({
+  id: z.string().uuid("Invalid user ID format"),
+});
+
+/**
+ * Routes with validation
+ */
+
+// GET /users - List users with query validation
+users.get(
+  "/",
+  validate({ target: "query", schema: list_users_query_schema }),
+  (c) => {
+    const query = get_validated<z.infer<typeof list_users_query_schema>>(c, "query");
+
+    return c.json({
+      users: [],
+      pagination: {
+        page: query.page || 1,
+        limit: query.limit || 10,
+        search: query.search,
+      },
+    });
+  }
+);
+
+// POST /users - Create user with body validation
+users.post(
+  "/",
+  validate({ target: "body", schema: create_user_schema }),
+  (c) => {
+    const body = get_validated<z.infer<typeof create_user_schema>>(c, "body");
+
+    // Your database logic here
+    const new_user = {
+      id: crypto.randomUUID(),
+      ...body,
+      created_at: new Date().toISOString(),
+    };
+
+    return c.json(new_user, 201);
+  }
+);
+
+// GET /users/:id - Get user by ID with param validation
+users.get(
+  "/:id",
+  validate({ target: "param", schema: user_id_param_schema }),
+  (c) => {
+    const params = get_validated<z.infer<typeof user_id_param_schema>>(c, "param");
+
+    // Your database logic here
+    const user = {
+      id: params.id,
+      name: "John Doe",
+      email: "john@example.com",
+    };
+
+    return c.json(user);
+  }
+);
+
+// PATCH /users/:id - Update user with param + body validation
+users.patch(
+  "/:id",
+  validate({ target: "param", schema: user_id_param_schema }),
+  validate({ target: "body", schema: update_user_schema }),
+  (c) => {
+    const params = get_validated<z.infer<typeof user_id_param_schema>>(c, "param");
+    const body = get_validated<z.infer<typeof update_user_schema>>(c, "body");
+
+    // Your database logic here
+    const updated_user = {
+      id: params.id,
+      ...body,
+      updated_at: new Date().toISOString(),
+    };
+
+    return c.json(updated_user);
+  }
+);
+
+// DELETE /users/:id
+users.delete(
+  "/:id",
+  validate({ target: "param", schema: user_id_param_schema }),
+  (c) => {
+    const params = get_validated<z.infer<typeof user_id_param_schema>>(c, "param");
+
+    return c.json({
+      message: `User ${params.id} deleted successfully`,
+    });
+  }
+);
+
+export default users;

package/cli/src/types/index.ts

@@ -0,0 +1,126 @@
+export interface CliFlags {
+  noGit: boolean;
+  noInstall: boolean;
+  default: boolean;
+  CI: boolean;
+  
+  // Database flags
+  postgres?: boolean;
+  mysql?: boolean;
+  mongodb?: boolean;
+  redis?: boolean;
+  
+  // Auth flags
+  jwt?: boolean;
+  oauth?: boolean;
+  session?: boolean;
+  
+  // AI flags
+  openai?: boolean;
+  anthropic?: boolean;
+  gemini?: boolean;
+  vercelAI?: boolean;
+  
+  // Cloud flags
+  aws?: boolean;
+  gcp?: boolean;
+  azure?: boolean;
+  cloudflareR2?: boolean;
+  
+  // Communication flags
+  resend?: boolean;
+  sendgrid?: boolean;
+  nodemailer?: boolean;
+  socketio?: boolean;
+  sse?: boolean;
+  
+  // Infrastructure flags
+  bullmq?: boolean;
+  inngest?: boolean;
+  upstashRateLimit?: boolean;
+  customRateLimit?: boolean;
+  sentry?: boolean;
+  logtail?: boolean;
+  
+  // DevX flags
+  swagger?: boolean;
+  scalar?: boolean;
+  vitest?: boolean;
+
+  // Validation flags
+  zod?: boolean;
+  yup?: boolean;
+}
+
+export type Framework = "hono" | "express" | "bun-native";
+
+export interface CliResults {
+  appName: string;
+  framework: Framework;
+  packages: AvailablePackages[];
+  flags: CliFlags;
+}
+
+export enum AvailablePackages {
+  // Core
+  postgres = "postgres",
+  mysql = "mysql",
+  mongodb = "mongodb",
+  redis = "redis",
+  jwt = "jwt",
+  oauth = "oauth",
+  session = "session",
+  
+  // AI & ML
+  openai = "openai",
+  anthropic = "anthropic",
+  gemini = "gemini",
+  vercelAI = "vercel-ai",
+  
+  // Cloud & Storage
+  aws = "aws",
+  gcp = "gcp",
+  azure = "azure",
+  cloudflareR2 = "cloudflare-r2",
+  
+  // Communications
+  resend = "resend",
+  sendgrid = "sendgrid",
+  nodemailer = "nodemailer",
+  socketio = "socketio",
+  sse = "sse",
+  
+  // Infrastructure
+  bullmq = "bullmq",
+  inngest = "inngest",
+  upstashRateLimit = "upstash-ratelimit",
+  customRateLimit = "custom-ratelimit",
+  sentry = "sentry",
+  logtail = "logtail",
+  
+  // Developer Experience
+  swagger = "swagger",
+  scalar = "scalar",
+  vitest = "vitest",
+
+  // Validation
+  zod = "zod",
+  yup = "yup",
+}
+
+export interface InstallerOptions {
+  projectDir: string;
+  packages: AvailablePackages[];
+  appName: string;
+  framework: Framework;
+  noInstall: boolean;
+}
+
+export type Installer = (opts: InstallerOptions) => Promise<void>;
+
+export interface PkgInstallerMap {
+  [key: string]: {
+    inUse: boolean;
+    installer: Installer;
+  };
+}

package/cli/src/utils/add-package-dependency.ts

@@ -0,0 +1,56 @@
+import path from "path";
+import fs from "fs-extra";
+
+/**
+ * Adds dependencies to a project's package.json file.
+ * Reads the file, merges dependencies, sorts keys alphabetically, and writes back.
+ *
+ * @param projectDir - Absolute path to the project directory
+ * @param dependencies - Dependencies to add to the "dependencies" section
+ * @param devDependencies - Optional dev dependencies to add to "devDependencies" section
+ */
+export async function add_package_dependency(
+  projectDir: string,
+  dependencies: Record<string, string>,
+  devDependencies?: Record<string, string>
+): Promise<void> {
+  const packageJsonPath = path.join(projectDir, "package.json");
+
+  // Read existing package.json
+  const packageJson = await fs.readJson(packageJsonPath);
+
+  // Merge dependencies
+  if (dependencies && Object.keys(dependencies).length > 0) {
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      ...dependencies,
+    };
+
+    // Sort dependencies alphabetically
+    packageJson.dependencies = Object.keys(packageJson.dependencies)
+      .sort()
+      .reduce((acc: Record<string, string>, key: string) => {
+        acc[key] = packageJson.dependencies[key];
+        return acc;
+      }, {});
+  }
+
+  // Merge devDependencies
+  if (devDependencies && Object.keys(devDependencies).length > 0) {
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies,
+      ...devDependencies,
+    };
+
+    // Sort devDependencies alphabetically
+    packageJson.devDependencies = Object.keys(packageJson.devDependencies)
+      .sort()
+      .reduce((acc: Record<string, string>, key: string) => {
+        acc[key] = packageJson.devDependencies[key];
+        return acc;
+      }, {});
+  }
+
+  // Write back to package.json with proper formatting
+  await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}

package/cli/src/utils/dependency-version-map.ts

@@ -0,0 +1,85 @@
+/**
+ * Central registry mapping package names to their versions.
+ * Single source of truth for all dependency versions used in generated projects.
+ */
+export const DEPENDENCY_VERSION_MAP: Record<string, string> = {
+  // Core Framework
+  "hono": "^4.0.0",
+  "express": "^4.18.2",
+  "@types/express": "^4.17.21",
+
+  // Database Drivers
+  "postgres": "^3.4.4",
+  "mysql2": "^3.9.0",
+  "mongoose": "^8.1.0",
+  "redis": "^4.6.12",
+
+  // ORM & Query Builders
+  "drizzle-orm": "^0.29.3",
+  "drizzle-kit": "^0.20.10",
+  "kysely": "^0.27.2",
+
+  // Authentication
+  "jsonwebtoken": "^9.0.2",
+  "@types/jsonwebtoken": "^9.0.5",
+  "bcryptjs": "^2.4.3",
+  "@types/bcryptjs": "^2.4.6",
+  "passport": "^0.7.0",
+  "passport-oauth2": "^1.8.0",
+  "@types/passport": "^1.0.16",
+
+  // AI Providers
+  "openai": "^4.26.0",
+  "@anthropic-ai/sdk": "^0.12.0",
+  "@google/generative-ai": "^0.1.3",
+  "ai": "^3.0.0",
+
+  // Cloud Storage
+  "@aws-sdk/client-s3": "^3.490.0",
+  "@aws-sdk/s3-request-presigner": "^3.490.0",
+  "@google-cloud/storage": "^7.7.0",
+  "@azure/storage-blob": "^12.17.0",
+  "@cloudflare/workers-types": "^4.20240117.0",
+
+  // Email Services
+  "resend": "^3.0.0",
+  "@sendgrid/mail": "^8.1.0",
+  "nodemailer": "^6.9.8",
+  "@types/nodemailer": "^6.4.14",
+
+  // Real-time Communication
+  "socket.io": "^4.6.1",
+  "@types/socket.io": "^3.0.0",
+
+  // Queue Systems
+  "bullmq": "^5.1.5",
+  "inngest": "^3.12.0",
+
+  // Rate Limiting
+  "@upstash/ratelimit": "^1.0.0",
+  "@upstash/redis": "^1.27.1",
+
+  // Observability
+  "@sentry/node": "^7.99.0",
+  "@logtail/node": "^0.4.13",
+
+  // API Documentation
+  "@hono/swagger": "^0.1.0",
+  "@scalar/hono-api-reference": "^0.5.0",
+
+  // Testing
+  "vitest": "^1.2.0",
+  "@vitest/ui": "^1.2.0",
+  "supertest": "^6.3.4",
+  "@types/supertest": "^6.0.2",
+
+  // Utilities
+  "zod": "^3.22.4",
+  "yup": "^1.3.3",
+  "dotenv": "^16.3.1",
+  "cors": "^2.8.5",
+  "@types/cors": "^2.8.17",
+  "helmet": "^7.1.0",
+  "compression": "^1.7.4",
+  "@types/compression": "^1.7.5",
+};

package/cli/src/utils/logger.ts

@@ -0,0 +1,19 @@
+import chalk from "chalk";
+
+export const logger = {
+  error: (...args: unknown[]) => {
+    console.log(chalk.red(...args));
+  },
+  warn: (...args: unknown[]) => {
+    console.log(chalk.yellow(...args));
+  },
+  info: (...args: unknown[]) => {
+    console.log(chalk.cyan(...args));
+  },
+  success: (...args: unknown[]) => {
+    console.log(chalk.green(...args));
+  },
+  debug: (...args: unknown[]) => {
+    console.log(chalk.gray(...args));
+  },
+};

package/cli/src/utils/parse-name-and-path.ts

@@ -0,0 +1,55 @@
+import path from "path";
+
+export interface ParsedNameAndPath {
+  projectName: string;
+  projectDir: string;
+}
+
+/**
+ * Parses the app name input to extract project name and directory path.
+ * Handles relative paths (./my-app), absolute paths, and simple names.
+ *
+ * @param appName - The app name or path provided by the user
+ * @returns Object containing projectName (kebab-case) and projectDir (absolute path)
+ * @throws Error if the name contains invalid characters (spaces, special chars except - and _)
+ */
+export function parse_name_and_path(appName: string): ParsedNameAndPath {
+  // Validate app name - no spaces or invalid characters
+  // Allow only alphanumeric, hyphens, underscores, slashes, and dots (for paths)
+  const pathRegex = /^[a-zA-Z0-9\-_/.]+$/;
+  if (!pathRegex.test(appName)) {
+    throw new Error(
+      `Invalid app name: "${appName}". Use only letters, numbers, hyphens, and underscores.`
+    );
+  }
+
+  let projectDir: string;
+  let projectName: string;
+
+  // Check if it's a path (contains / or starts with . or ~)
+  if (appName.includes("/") || appName.startsWith(".") || appName.startsWith("~")) {
+    // It's a path - resolve it to absolute
+    projectDir = path.resolve(process.cwd(), appName);
+    // Extract the last segment as the project name
+    projectName = path.basename(projectDir);
+  } else {
+    // It's just a name - create in current directory
+    projectName = appName;
+    projectDir = path.resolve(process.cwd(), appName);
+  }
+
+  // Ensure project name is kebab-case (convert underscores to hyphens)
+  projectName = projectName.replace(/_/g, "-").toLowerCase();
+
+  // Additional validation - ensure name doesn't start/end with hyphen
+  if (projectName.startsWith("-") || projectName.endsWith("-")) {
+    throw new Error(
+      `Invalid app name: "${projectName}". Name cannot start or end with a hyphen.`
+    );
+  }
+
+  return {
+    projectName,
+    projectDir,
+  };
+}

package/cli/src/utils/render-title.ts

@@ -0,0 +1,11 @@
+import chalk from "chalk";
+
+/**
+ * Displays a styled section header in the terminal.
+ * Used to visually separate different stages of the CLI execution.
+ *
+ * @param title - The title text to display
+ */
+export function render_title(title: string): void {
+  console.log("\n" + chalk.bold.cyan(`▸ ${title}`));
+}

package/cli/tsconfig.json

@@ -0,0 +1,35 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "lib": [
+            "ES2022"
+        ],
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "noEmit": true,
+        "composite": false,
+        "strict": true,
+        "downlevelIteration": true,
+        "skipLibCheck": true,
+        "jsx": "preserve",
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true,
+        "allowJs": true,
+        "types": [
+            "bun-types"
+        ],
+        "esModuleInterop": true,
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "outDir": "dist",
+        "rootDir": "src"
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "deploy-bbc",
+    "version": "0.0.1",
+    "description": "CLI to bootstrap production-ready backends with Bun (Best Backend Code)",
+    "workspaces": [
+        "cli"
+    ],
+    "scripts": {
+        "dev": "bun --watch cli/src/index.ts",
+        "build": "cd cli && bun run build",
+        "lint": "eslint . --ext .ts",
+        "format": "prettier --write \"**/*.{ts,json,md}\""
+    },
+    "devDependencies": {
+        "@types/bun": "latest",
+        "bun-types": "^1.3.7",
+        "prettier": "^3.1.1",
+        "typescript": "^5.3.3"
+    }
+}

package/test-cli.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+# Test script for deploy-bbc CLI
+
+echo "🧪 Testing deploy-bbc CLI..."
+echo ""
+
+# Test 1: Minimal setup
+echo "Test 1: Minimal setup (postgres + jwt)"
+cd /tmp
+bun ~/Documents/cli/cli/src/index.ts test-minimal --CI --postgres --jwt --noInstall --noGit
+echo "✅ Test 1 passed"
+echo ""
+
+# Test 2: Full stack with AI
+echo "Test 2: Full stack (postgres, redis, jwt, openai, vercel-ai)"
+cd /tmp
+bun ~/Documents/cli/cli/src/index.ts test-fullstack --CI \
+  --postgres --redis \
+  --jwt --session \
+  --openai --anthropic --vercelAI \
+  --resend \
+  --bullmq \
+  --swagger --vitest \
+  --noInstall --noGit
+echo "✅ Test 2 passed"
+echo ""
+
+# Test 3: MongoDB + OAuth
+echo "Test 3: MongoDB + OAuth setup"
+cd /tmp
+bun ~/Documents/cli/cli/src/index.ts test-mongo --CI \
+  --mongodb \
+  --oauth \
+  --socketio \
+  --scalar \
+  --noInstall --noGit
+echo "✅ Test 3 passed"
+echo ""
+
+# Test 4: Cloud services
+echo "Test 4: Cloud services (AWS, GCP, Azure)"
+cd /tmp
+bun ~/Documents/cli/cli/src/index.ts test-cloud --CI \
+  --postgres \
+  --jwt \
+  --aws --gcp --azure --cloudflareR2 \
+  --sentry \
+  --noInstall --noGit
+echo "✅ Test 4 passed"
+echo ""
+
+echo "✨ All tests completed successfully!"
+echo ""
+echo "To test interactively, run:"
+echo "  cd /tmp && bun ~/Documents/cli/cli/src/index.ts my-project"

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "lib": [
+            "ES2022"
+        ],
+        "moduleResolution": "bundler",
+        "strict": true,
+        "skipLibCheck": true,
+        "types": [
+            "bun-types"
+        ]
+    }
+}