deploy-bbc 1.2.3 → 1.3.0

package/README.md

@@ -39,7 +39,7 @@ It ships with production-ready defaults, optional integrations, Docker support,
 - 🚀 **Production-ready templates** with best practices
 - 🔌 **30+ integrations** (databases, auth, AI, cloud, infra)
 - 🛡️ **Fully type-safe** with strict TypeScript
-- 🐳 **Dockerfile and docker-compose** included
+- 🐳 **Optional Docker support** for databases and/or backend
 - 💎 **Strong developer experience** with testing and docs
 - ⚙️ **Zero-config defaults** that work out of the box
 
@@ -78,8 +78,9 @@ bunx deploy-bbc my-backend
   <img height="40" src="https://cdn.brandfetch.io/idwlYcQpHB/theme/dark/symbol.svg?c=1bxid64Mup7aczewSAYMX&t=1668515608635" alt="Redis" />
 </p>
 
-- **PostgreSQL** with Drizzle ORM
-- **MySQL** with Drizzle ORM
+- **PostgreSQL** with native postgres driver
+- **MySQL** with mysql2 driver (Bun-optimized)
+- **SQLite** with bun:sqlite (built-in, zero dependencies)
 - **MongoDB** with Mongoose
 - **Redis** for caching and queues
 
@@ -179,11 +180,55 @@ src/
 
 ## Docker Support
 
+The CLI provides flexible Docker configuration options:
+
+### Options
+
+During setup, you'll be asked:
+
+1. **Dockerize databases?** - Generates docker-compose services for:
+   - PostgreSQL
+   - MySQL
+   - MongoDB
+   - Redis
+
+2. **Dockerize the backend?** - Creates:
+   - Multi-stage Dockerfile optimized for Bun
+   - App service in docker-compose.yml
+
+### Usage
+
+If you selected to dockerize your databases:
+
 ```bash
+# Start only databases
+docker-compose up postgres redis -d
+
+# Run your app locally
+bun run dev
+```
+
+If you dockerized both databases and backend:
+
+```bash
+# Start everything
 docker-compose up
+
+# Or in detached mode
+docker-compose up -d
 ```
 
-Dockerfile and docker-compose are included by default.
+### SQLite with Docker
+
+When using SQLite with a dockerized backend, your database file is automatically mounted as a volume to persist data between container restarts.
+
+### CLI Flags
+
+You can also use CLI flags for non-interactive setup:
+
+```bash
+npx deploy-bbc my-api --dockerizeDb --dockerizeBackend
+```
 
 ---
 

package/dist/index.js

@@ -5934,39 +5934,58 @@ var defaultOptions = {
   CI: false
 };
 var run_cli = async () => {
-  const program2 = 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).option("--CI", "Run in CI mode (non-interactive)", defaultOptions.CI).option("--hono", "Use Hono framework (default)").option("--express", "Use Express framework").option("--bun-native", "Use Bun native HTTP server").option("--postgres", "Include PostgreSQL").option("--mysql", "Include MySQL").option("--mongodb", "Include MongoDB").option("--redis", "Include Redis").option("--jwt", "Include JWT authentication").option("--oauth", "Include OAuth 2.0").option("--session", "Include session-based auth").option("--openai", "Include OpenAI SDK").option("--anthropic", "Include Anthropic Claude SDK").option("--gemini", "Include Google Gemini SDK").option("--vercelAI", "Include Vercel AI SDK").option("--aws", "Include AWS SDK").option("--gcp", "Include Google Cloud SDK").option("--azure", "Include Azure SDK").option("--cloudflareR2", "Include Cloudflare R2").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").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").option("--swagger", "Include Swagger/OpenAPI").option("--scalar", "Include Scalar API docs").option("--vitest", "Include Vitest testing").option("--zod", "Include Zod validation").option("--yup", "Include Yup validation").parse(process.argv);
+  const program2 = 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).option("--CI", "Run in CI mode (non-interactive)", defaultOptions.CI).option("--hono", "Use Hono framework (default)").option("--express", "Use Express framework").option("--bun-native", "Use Bun native HTTP server").option("--postgres", "Include PostgreSQL").option("--mysql", "Include MySQL").option("--sqlite", "Include SQLite").option("--mongodb", "Include MongoDB").option("--redis", "Include Redis").option("--jwt", "Include JWT authentication").option("--oauth", "Include OAuth 2.0").option("--session", "Include session-based auth").option("--openai", "Include OpenAI SDK").option("--anthropic", "Include Anthropic Claude SDK").option("--gemini", "Include Google Gemini SDK").option("--vercelAI", "Include Vercel AI SDK").option("--aws", "Include AWS SDK").option("--gcp", "Include Google Cloud SDK").option("--azure", "Include Azure SDK").option("--cloudflareR2", "Include Cloudflare R2").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").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").option("--swagger", "Include Swagger/OpenAPI").option("--scalar", "Include Scalar API docs").option("--vitest", "Include Vitest testing").option("--zod", "Include Zod validation").option("--yup", "Include Yup validation").option("--dockerizeDb", "Dockerize databases (PostgreSQL, MySQL, Redis, MongoDB)").option("--dockerizeBackend", "Dockerize the backend application").parse(process.argv);
   const cliProvidedName = program2.args[0];
   const cliOptions = program2.opts();
   if (cliOptions.CI) {
     return build_from_flags(cliProvidedName, cliOptions);
   }
+  const blue = "\x1B[38;5;75m";
+  const gray = "\x1B[90m";
+  const reset = "\x1B[0m";
   const intro = `
-╔═══════════════════════════════════════════════╗
-║                                               ║
-║     \uD83D\uDE80  deploy-bbc                            ║
-║         (Best Backend Code)                   ║
-║                                               ║
-║     Bootstrap a production-ready backend      ║
-║     with Bun, TypeScript & Docker             ║
-║                                               ║
-╚═══════════════════════════════════════════════╝
+ ${gray}____________________________________________________________________${reset}
+${gray}/                                                                    \\${reset}
+${gray}|${reset}  ${blue}█▀▀▄ █▀▀ █▀▀█ █    █▀▀█ █  █    █▀▀▄ █▀▀▄ █▀▀${reset}                     ${gray}|${reset}
+${gray}|${reset}  ${blue}█  █ █▀▀ █  █ █    █  █ █▄▄█    █▀▀▄ █▀▀▄ █${reset}                       ${gray}|${reset}
+${gray}|${reset}  ${blue}█▄▄▀ ▀▀▀ █▀▀▀ ▀▀▀  ▀▀▀▀ ▄▄▄█    █▄▄▀ █▄▄▀ ▀▀▀${reset}                     ${gray}|${reset}
+${gray}|${reset}                                                                                   ${gray}|${reset}
+${gray}|${reset}  \uD83D\uDE80 ${blue}Best Backend Code${reset}                                              ${gray}|${reset}
+${gray}|${reset}                                                                                   ${gray}|${reset}
+${gray}|${reset}  ${gray}Backend so good, it hurts${reset}                                         ${gray}|${reset}
+${gray}|${reset}  ${gray}[ Bun ] ---------- [ TypeScript ] ---------- [ Docker ]${reset}           ${gray}|${reset}
+${gray}\\____________________________________________________________________/${reset}
   `;
-  console.log(source_default.cyan(intro));
+  console.log(intro);
   Ie(source_default.bgCyan(source_default.black(" deploy-bbc ")));
   const project = await Ce({
     ...add_cli_header("\uD83D\uDCE6 CORE"),
     projectName: () => he({
       message: "What will your project be called?",
-      placeholder: "my-awesome-api (or . for current directory)",
+      placeholder: "my-awesome-api (use '.' for current dir if empty)",
       defaultValue: cliProvidedName || "my-backend",
       validate: (value) => {
         if (!value)
           return "Please enter a project name";
-        if (value === "." || value.startsWith("./") || value.startsWith("../") || value.startsWith("~/")) {
-          return;
+        if (!/^[a-z0-9-_/.]+$/i.test(value)) {
+          return "Only letters, numbers, dashes, underscores, and slashes allowed";
+        }
+        if (value === ".") {
+          const fs = __require("fs");
+          const path = __require("path");
+          const cwd = process.cwd();
+          const conflictingPaths = ["src", "package.json"];
+          const conflicts = [];
+          for (const pathToCheck of conflictingPaths) {
+            if (fs.existsSync(path.join(cwd, pathToCheck))) {
+              conflicts.push(pathToCheck);
+            }
+          }
+          if (conflicts.length > 0) {
+            return `Current directory already contains: ${conflicts.join(", ")}. Please use a new directory name or run from an empty directory.`;
+          }
         }
-        if (!/^[a-z0-9-_/]+$/i.test(value))
-          return "Only letters, numbers, dashes, underscores, and slashes";
+        return;
       }
     }),
     framework: () => ve({
@@ -5996,12 +6015,17 @@ var run_cli = async () => {
         {
           value: "postgres" /* postgres */,
           label: "PostgreSQL",
-          hint: "Dockerized • Drizzle ORM"
+          hint: "Dockerized • Native postgres driver"
         },
         {
           value: "mysql" /* mysql */,
           label: "MySQL",
-          hint: "Dockerized • Drizzle ORM"
+          hint: "Dockerized • mysql2 driver"
+        },
+        {
+          value: "sqlite" /* sqlite */,
+          label: "SQLite",
+          hint: "File-based • bun:sqlite (built-in)"
         },
         {
           value: "mongodb" /* mongodb */,
@@ -6166,6 +6190,20 @@ var run_cli = async () => {
       ],
       initialValue: "zod" /* zod */
     }),
+    ...add_cli_header("\uD83D\uDC33 DOCKER"),
+    dockerizeDb: ({ results }) => {
+      const hasDatabases = results.databases && results.databases.length > 0;
+      if (!hasDatabases)
+        return Promise.resolve(false);
+      return ye({
+        message: "Dockerize databases? (PostgreSQL, MySQL, Redis, MongoDB)",
+        initialValue: true
+      });
+    },
+    dockerizeBackend: () => ye({
+      message: "Dockerize the backend application?",
+      initialValue: true
+    }),
     installDeps: () => ye({
       message: "Install dependencies?",
       initialValue: !cliOptions.noInstall
@@ -6200,7 +6238,9 @@ var run_cli = async () => {
     flags: {
       ...defaultOptions,
       noInstall: !project.installDeps,
-      noGit: !project.initGit
+      noGit: !project.initGit,
+      dockerizeDb: project.dockerizeDb,
+      dockerizeBackend: project.dockerizeBackend
     }
   };
 };
@@ -6224,6 +6264,8 @@ function build_from_flags(appName, flags) {
     packages.push("postgres" /* postgres */);
   if (flags.mysql)
     packages.push("mysql" /* mysql */);
+  if (flags.sqlite)
+    packages.push("sqlite" /* sqlite */);
   if (flags.mongodb)
     packages.push("mongodb" /* mongodb */);
   if (flags.redis)
@@ -9050,8 +9092,14 @@ async function scaffold_project(options) {
       }
       if (conflicts.length > 0) {
         spinner.fail("Cannot scaffold in current directory");
-        throw new Error(`The following files/folders already exist: ${conflicts.join(", ")}
-` + "Please use an empty directory or choose a different location.");
+        throw new Error(`Current directory already contains: ${conflicts.join(", ")}
+
+` + `To fix this:
+` + `  1. Create a new directory: mkdir my-project && cd my-project
+` + `  2. Or run from a parent directory and specify a new project name
+` + `  3. Or use an empty directory
+
+` + "Example: npx deploy-bbc (then enter a new project name like 'my-api')");
       }
     }
     await import_fs_extra.default.ensureDir(projectDir);
@@ -9120,9 +9168,6 @@ var DEPENDENCY_VERSION_MAP = {
   mysql2: "^3.9.0",
   mongoose: "^8.1.0",
   redis: "^4.6.12",
-  "drizzle-orm": "^0.29.3",
-  "drizzle-kit": "^0.20.10",
-  kysely: "^0.27.2",
   jsonwebtoken: "^9.0.2",
   "@types/jsonwebtoken": "^9.0.5",
   bcryptjs: "^2.4.3",
@@ -9180,6 +9225,9 @@ async function database_installer(options) {
       case "mysql" /* mysql */:
         await install_mysql(projectDir);
         break;
+      case "sqlite" /* sqlite */:
+        await install_sqlite(projectDir);
+        break;
       case "mongodb" /* mongodb */:
         await install_mongodb(projectDir);
         break;
@@ -9193,33 +9241,40 @@ async function install_postgres(projectDir) {
   const templateDir = path4.resolve(__dirname3, "templates/extras/database/postgres");
   await copy_template_files(templateDir, projectDir);
   await add_package_dependency(projectDir, {
-    postgres: DEPENDENCY_VERSION_MAP["postgres"],
-    "drizzle-orm": DEPENDENCY_VERSION_MAP["drizzle-orm"]
-  });
-  await add_package_dependency(projectDir, {}, {
-    "drizzle-kit": DEPENDENCY_VERSION_MAP["drizzle-kit"]
+    postgres: DEPENDENCY_VERSION_MAP["postgres"]
   });
   await append_env_example(projectDir, `
 # PostgreSQL Configuration
 DATABASE_URL=postgresql://user:password@localhost:5432/dbname
 `);
-  await add_db_scripts(projectDir, "postgres");
 }
 async function install_mysql(projectDir) {
   const templateDir = path4.resolve(__dirname3, "templates/extras/database/mysql");
   await copy_template_files(templateDir, projectDir);
   await add_package_dependency(projectDir, {
-    mysql2: DEPENDENCY_VERSION_MAP["mysql2"],
-    "drizzle-orm": DEPENDENCY_VERSION_MAP["drizzle-orm"]
-  });
-  await add_package_dependency(projectDir, {}, {
-    "drizzle-kit": DEPENDENCY_VERSION_MAP["drizzle-kit"]
+    mysql2: DEPENDENCY_VERSION_MAP["mysql2"]
   });
   await append_env_example(projectDir, `
 # MySQL Configuration
 DATABASE_URL=mysql://user:password@localhost:3306/dbname
 `);
-  await add_db_scripts(projectDir, "mysql");
+}
+async function install_sqlite(projectDir) {
+  const templateDir = path4.resolve(__dirname3, "templates/extras/database/sqlite");
+  await copy_template_files(templateDir, projectDir);
+  await append_env_example(projectDir, `
+# SQLite Configuration
+DATABASE_PATH=./data/app.db
+`);
+  await import_fs_extra3.default.ensureDir(path4.join(projectDir, "data"));
+  const gitignorePath = path4.join(projectDir, ".gitignore");
+  const gitignoreContent = await import_fs_extra3.default.readFile(gitignorePath, "utf-8");
+  if (!gitignoreContent.includes("data/")) {
+    await import_fs_extra3.default.appendFile(gitignorePath, `
+# SQLite database
+data/
+`);
+  }
 }
 async function install_mongodb(projectDir) {
   const templateDir = path4.resolve(__dirname3, "templates/extras/database/mongodb");
@@ -9271,17 +9326,6 @@ async function append_env_example(projectDir, content) {
   const envPath = path4.join(projectDir, ".env.example");
   await import_fs_extra3.default.appendFile(envPath, content);
 }
-async function add_db_scripts(projectDir, dbType) {
-  const packageJsonPath = path4.join(projectDir, "package.json");
-  const packageJson = await import_fs_extra3.default.readJson(packageJsonPath);
-  packageJson.scripts = {
-    ...packageJson.scripts,
-    "db:generate": "drizzle-kit generate",
-    "db:migrate": "drizzle-kit migrate",
-    "db:studio": "drizzle-kit studio"
-  };
-  await import_fs_extra3.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-}
 
 // src/installers/auth.ts
 var import_fs_extra4 = __toESM(require_lib(), 1);
@@ -10182,19 +10226,21 @@ CMD ["bun", "run", "src/index.ts"]
 var import_fs_extra17 = __toESM(require_lib(), 1);
 import path18 from "path";
 async function generate_docker_compose(options) {
-  const { projectDir, packages, appName } = options;
-  const hasPostgres = packages.includes("postgres" /* postgres */);
-  const hasMysql = packages.includes("mysql" /* mysql */);
-  const hasMongodb = packages.includes("mongodb" /* mongodb */);
-  const hasRedis = packages.includes("redis" /* redis */);
-  if (!hasPostgres && !hasMysql && !hasMongodb && !hasRedis) {
+  const { projectDir, packages, appName, dockerizeDb, dockerizeBackend } = options;
+  const hasPostgres = dockerizeDb && packages.includes("postgres" /* postgres */);
+  const hasMysql = dockerizeDb && packages.includes("mysql" /* mysql */);
+  const hasSqlite = dockerizeDb && packages.includes("sqlite" /* sqlite */);
+  const hasMongodb = dockerizeDb && packages.includes("mongodb" /* mongodb */);
+  const hasRedis = dockerizeDb && packages.includes("redis" /* redis */);
+  if (!dockerizeBackend && !hasPostgres && !hasMysql && !hasSqlite && !hasMongodb && !hasRedis) {
     return;
   }
   let composeContent = `version: '3.8'
 
 services:
 `;
-  composeContent += `  app:
+  if (dockerizeBackend) {
+    composeContent += `  app:
     build: .
     ports:
       - "8000:8000"
@@ -10203,22 +10249,28 @@ services:
     env_file:
       - .env
 `;
-  const dependencies = [];
-  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:
+    if (hasSqlite) {
+      composeContent += `    volumes:
+      - ./data:/app/data
 `;
-    dependencies.forEach((dep) => {
-      composeContent += `      - ${dep}
+    }
+    const dependencies = [];
+    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}
+`;
+      });
+    }
   }
   if (hasPostgres) {
     composeContent += `
@@ -16809,16 +16861,24 @@ async function create_project(cliResults) {
       appName: projectName,
       framework: cliResults.framework,
       packages: cliResults.packages,
-      noInstall: cliResults.flags.noInstall
+      noInstall: cliResults.flags.noInstall,
+      dockerizeDb: cliResults.flags.dockerizeDb || false,
+      dockerizeBackend: cliResults.flags.dockerizeBackend || false
     };
     render_title("Creating project structure");
     await scaffold_project(installerOptions);
     render_title("Installing selected packages");
     const installerMap = build_installer_map(installerOptions);
     await run_installers(installerMap, installerOptions);
-    render_title("Generating Docker configuration");
-    await generate_dockerfile(installerOptions);
-    await generate_docker_compose(installerOptions);
+    if (cliResults.flags.dockerizeDb || cliResults.flags.dockerizeBackend) {
+      render_title("Generating Docker configuration");
+      if (cliResults.flags.dockerizeBackend) {
+        await generate_dockerfile(installerOptions);
+      }
+      if (cliResults.flags.dockerizeDb || cliResults.flags.dockerizeBackend) {
+        await generate_docker_compose(installerOptions);
+      }
+    }
     if (!cliResults.flags.noInstall) {
       render_title("Installing dependencies");
       await install_dependencies(projectDir);

package/dist/templates/base/.env.example

@@ -1,3 +1,3 @@
 # Server Configuration
-PORT=3000
+PORT=8000
 NODE_ENV=development

package/dist/templates/base/package.json

@@ -10,8 +10,9 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
+    "dotenv": "^16.3.1",
     "hono": "^4.0.0",
-    "dotenv": "^16.3.1"
+    "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/dist/templates/base/src/config/index.ts

@@ -3,6 +3,6 @@ import { load_env } from "../utils/env.js";
 load_env();
 
 export const config = {
-  port: parseInt(process.env.PORT || "3000", 10),
+  port: parseInt(process.env.PORT || "8000", 10),
   nodeEnv: process.env.NODE_ENV || "development",
 } as const;

package/dist/templates/base/src/controllers/user/create-user.controller.ts

@@ -0,0 +1,84 @@
+import type { Context } from "hono";
+import { z } from "zod";
+import { user_model } from "../../models/user.model.js";
+import type { ApiResponse, ApiError } from "../../types/common/api-response.types.js";
+import type { UserResponse } from "../../types/models/user.types.js";
+
+/**
+ * Validation schema
+ */
+const create_user_schema = z.object({
+  email: z.string().email("Invalid email address"),
+  name: z.string().min(2, "Name must be at least 2 characters").max(100, "Name must not exceed 100 characters"),
+});
+
+/**
+ * Helper to format user response
+ */
+function format_user_response(user: any): UserResponse {
+  return {
+    id: user.id,
+    email: user.email,
+    name: user.name,
+    createdAt: user.createdAt.toISOString(),
+    updatedAt: user.updatedAt.toISOString(),
+  };
+}
+
+/**
+ * Create a new user
+ * POST /users
+ */
+export async function create_user(c: Context) {
+  try {
+    const body = await c.req.json();
+
+    // Validate request body
+    const validation = create_user_schema.safeParse(body);
+    if (!validation.success) {
+      return c.json<ApiError>(
+        {
+          success: false,
+          error: "Validation failed",
+          details: validation.error.errors.map((err) => ({
+            field: err.path.join("."),
+            message: err.message,
+          })),
+        },
+        400
+      );
+    }
+
+    // Check if email already exists
+    const existing_user = await user_model.find_by_email(validation.data.email);
+    if (existing_user) {
+      return c.json<ApiError>(
+        {
+          success: false,
+          error: "User with this email already exists",
+        },
+        409
+      );
+    }
+
+    // Create user
+    const user = await user_model.create(validation.data);
+
+    return c.json<ApiResponse<UserResponse>>(
+      {
+        success: true,
+        data: format_user_response(user),
+        message: "User created successfully",
+      },
+      201
+    );
+  } catch (error) {
+    return c.json<ApiError>(
+      {
+        success: false,
+        error: "Failed to create user",
+      },
+      500
+    );
+  }
+}

package/dist/templates/base/src/controllers/user/delete-user.controller.ts

@@ -0,0 +1,60 @@
+import type { Context } from "hono";
+import { z } from "zod";
+import { user_model } from "../../models/user.model.js";
+import type { ApiResponse, ApiError } from "../../types/common/api-response.types.js";
+
+/**
+ * Validation schema
+ */
+const user_id_schema = z.string().uuid("Invalid user ID format");
+
+/**
+ * Delete user by ID
+ * DELETE /users/:id
+ */
+export async function delete_user(c: Context) {
+  try {
+    const id = c.req.param("id");
+
+    // Validate ID format
+    const validation = user_id_schema.safeParse(id);
+    if (!validation.success) {
+      return c.json<ApiError>(
+        {
+          success: false,
+          error: "Invalid user ID",
+          details: validation.error.errors.map((err) => ({
+            field: err.path.join("."),
+            message: err.message,
+          })),
+        },
+        400
+      );
+    }
+
+    const deleted = await user_model.delete(id);
+
+    if (!deleted) {
+      return c.json<ApiError>(
+        {
+          success: false,
+          error: "User not found",
+        },
+        404
+      );
+    }
+
+    return c.json<ApiResponse>({
+      success: true,
+      message: "User deleted successfully",
+    });
+  } catch (error) {
+    return c.json<ApiError>(
+      {
+        success: false,
+        error: "Failed to delete user",
+      },
+      500
+    );
+  }
+}

package/dist/templates/base/src/controllers/user/get-user.controller.ts

@@ -0,0 +1,74 @@
+import type { Context } from "hono";
+import { z } from "zod";
+import { user_model } from "../../models/user.model.js";
+import type { ApiResponse, ApiError } from "../../types/common/api-response.types.js";
+import type { UserResponse } from "../../types/models/user.types.js";
+
+/**
+ * Validation schema
+ */
+const user_id_schema = z.string().uuid("Invalid user ID format");
+
+/**
+ * Helper to format user response
+ */
+function format_user_response(user: any): UserResponse {
+  return {
+    id: user.id,
+    email: user.email,
+    name: user.name,
+    createdAt: user.createdAt.toISOString(),
+    updatedAt: user.updatedAt.toISOString(),
+  };
+}
+
+/**
+ * Get user by ID
+ * GET /users/:id
+ */
+export async function get_user(c: Context) {
+  try {
+    const id = c.req.param("id");
+
+    // Validate ID format
+    const validation = user_id_schema.safeParse(id);
+    if (!validation.success) {
+      return c.json<ApiError>(
+        {
+          success: false,
+          error: "Invalid user ID",
+          details: validation.error.errors.map((err) => ({
+            field: err.path.join("."),
+            message: err.message,
+          })),
+        },
+        400
+      );
+    }
+
+    const user = await user_model.find_by_id(id);
+
+    if (!user) {
+      return c.json<ApiError>(
+        {
+          success: false,
+          error: "User not found",
+        },
+        404
+      );
+    }
+
+    return c.json<ApiResponse<UserResponse>>({
+      success: true,
+      data: format_user_response(user),
+    });
+  } catch (error) {
+    return c.json<ApiError>(
+      {
+        success: false,
+        error: "Failed to fetch user",
+      },
+      500
+    );
+  }
+}