create-featurebased-architecture-backend 1.0.0

package/templates/user-management-backend/README.md

@@ -0,0 +1,105 @@
+# {{PROJECT_NAME}}
+
+A User Management System backend with feature-based architecture using Bun, Hono, and NeonDB.
+
+## Project Structure
+
+```
+src/
+├── config/           # Configuration (env, database)
+├── features/         # Feature modules
+│   └── users/
+│       ├── routes.ts
+│       ├── controller.ts
+│       ├── service.ts
+│       ├── repository.ts
+│       ├── types.ts
+│       └── schema.ts
+├── routes/           # Route aggregation
+├── shared/           # Shared utilities and types
+│   ├── types/
+│   └── utils/
+└── index.ts          # Application entry
+```
+
+## Getting Started
+
+```bash
+# Install dependencies
+bun install
+
+# Copy environment file
+cp .env.example .env
+
+# Update DATABASE_URL with your NeonDB connection string
+
+# Run development server
+bun run dev
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `DATABASE_URL` | NeonDB PostgreSQL connection string |
+| `PORT` | Server port (default: 3000) |
+| `NODE_ENV` | Environment (development/production) |
+
+## Database Setup (NeonDB)
+
+Run the following SQL in your NeonDB console to create the users table:
+
+```sql
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+CREATE TABLE users (
+  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+  email VARCHAR(255) UNIQUE NOT NULL,
+  name VARCHAR(100) NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Optional: Add index for email lookups
+CREATE INDEX idx_users_email ON users(email);
+
+-- Optional: Add trigger to auto-update updated_at
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+  NEW.updated_at = CURRENT_TIMESTAMP;
+  RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+CREATE TRIGGER update_users_updated_at
+  BEFORE UPDATE ON users
+  FOR EACH ROW
+  EXECUTE FUNCTION update_updated_at_column();
+```
+
+## API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/users` | Get all users |
+| GET | `/api/users/:id` | Get user by ID |
+| POST | `/api/users` | Create new user |
+| PUT | `/api/users/:id` | Update user |
+| DELETE | `/api/users/:id` | Delete user |
+
+### Request/Response Examples
+
+**Create User**
+```bash
+curl -X POST http://localhost:3000/api/users \
+  -H "Content-Type: application/json" \
+  -d '{"email": "user@example.com", "name": "John Doe"}'
+```
+
+**Update User**
+```bash
+curl -X PUT http://localhost:3000/api/users/{id} \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Jane Doe"}'
+```

package/templates/user-management-backend/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "bun run --watch src/index.ts",
+    "start": "bun run src/index.ts",
+    "build": "bun build src/index.ts --outdir ./dist --target bun"
+  },
+  "dependencies": {
+    "hono": "^4.11.3",
+    "@neondatabase/serverless": "^0.9.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  }
+}

package/templates/user-management-backend/src/config/database.ts

@@ -0,0 +1,4 @@
+import { neon } from "@neondatabase/serverless";
+import { env } from "./env";
+
+export const sql = neon(env.DATABASE_URL);

package/templates/user-management-backend/src/config/env.ts

@@ -0,0 +1,5 @@
+export const env = {
+  DATABASE_URL: process.env.DATABASE_URL || "",
+  PORT: Number(process.env.PORT) || 3000,
+  NODE_ENV: process.env.NODE_ENV || "development",
+} as const;

package/templates/user-management-backend/src/config/index.ts

@@ -0,0 +1,2 @@
+export * from "./env";
+export * from "./database";

package/templates/user-management-backend/src/features/users/controller.ts

@@ -0,0 +1,100 @@
+import type { Context } from "hono";
+import { userService } from "./service";
+import { createUserSchema, updateUserSchema, userIdSchema } from "./schema";
+import { successResponse, errorResponse } from "../../shared/utils/response";
+
+export const userController = {
+  async getAll(c: Context) {
+    try {
+      const users = await userService.getAllUsers();
+      return successResponse(c, users);
+    } catch (error) {
+      return errorResponse(c, "Failed to fetch users", 500);
+    }
+  },
+
+  async getById(c: Context) {
+    try {
+      const { id } = c.req.param();
+      const validation = userIdSchema.safeParse({ id });
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const user = await userService.getUserById(id);
+      if (!user) {
+        return errorResponse(c, "User not found", 404);
+      }
+
+      return successResponse(c, user);
+    } catch (error) {
+      return errorResponse(c, "Failed to fetch user", 500);
+    }
+  },
+
+  async create(c: Context) {
+    try {
+      const body = await c.req.json();
+      const validation = createUserSchema.safeParse(body);
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const user = await userService.createUser(validation.data);
+      return successResponse(c, user, "User created successfully", 201);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to create user";
+      return errorResponse(c, message, error instanceof Error && error.message === "Email already exists" ? 409 : 500);
+    }
+  },
+
+  async update(c: Context) {
+    try {
+      const { id } = c.req.param();
+      const idValidation = userIdSchema.safeParse({ id });
+
+      if (!idValidation.success) {
+        return errorResponse(c, idValidation.error.errors[0].message);
+      }
+
+      const body = await c.req.json();
+      const validation = updateUserSchema.safeParse(body);
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const user = await userService.updateUser(id, validation.data);
+      if (!user) {
+        return errorResponse(c, "User not found", 404);
+      }
+
+      return successResponse(c, user, "User updated successfully");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to update user";
+      return errorResponse(c, message, error instanceof Error && error.message === "Email already exists" ? 409 : 500);
+    }
+  },
+
+  async delete(c: Context) {
+    try {
+      const { id } = c.req.param();
+      const validation = userIdSchema.safeParse({ id });
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const deleted = await userService.deleteUser(id);
+      if (!deleted) {
+        return errorResponse(c, "User not found", 404);
+      }
+
+      return successResponse(c, null, "User deleted successfully");
+    } catch (error) {
+      return errorResponse(c, "Failed to delete user", 500);
+    }
+  },
+};

package/templates/user-management-backend/src/features/users/index.ts

@@ -0,0 +1,6 @@
+export * from "./routes";
+export * from "./controller";
+export * from "./service";
+export * from "./repository";
+export * from "./types";
+export * from "./schema";

package/templates/user-management-backend/src/features/users/repository.ts

@@ -0,0 +1,57 @@
+import { sql } from "../../config/database";
+import type { User, CreateUserDto, UpdateUserDto } from "./types";
+
+export const userRepository = {
+  async findAll(): Promise<User[]> {
+    const result = await sql`SELECT * FROM users ORDER BY created_at DESC`;
+    return result as User[];
+  },
+
+  async findById(id: string): Promise<User | null> {
+    const result = await sql`SELECT * FROM users WHERE id = ${id}`;
+    return (result[0] as User) || null;
+  },
+
+  async findByEmail(email: string): Promise<User | null> {
+    const result = await sql`SELECT * FROM users WHERE email = ${email}`;
+    return (result[0] as User) || null;
+  },
+
+  async create(data: CreateUserDto): Promise<User> {
+    const result = await sql`
+      INSERT INTO users (email, name)
+      VALUES (${data.email}, ${data.name})
+      RETURNING *
+    `;
+    return result[0] as User;
+  },
+
+  async update(id: string, data: UpdateUserDto): Promise<User | null> {
+    const fields: string[] = [];
+    const values: unknown[] = [];
+
+    if (data.email) {
+      fields.push("email");
+      values.push(data.email);
+    }
+    if (data.name) {
+      fields.push("name");
+      values.push(data.name);
+    }
+
+    if (fields.length === 0) return this.findById(id);
+
+    const result = await sql`
+      UPDATE users
+      SET ${sql(Object.fromEntries(fields.map((f, i) => [f, values[i]])))}
+      WHERE id = ${id}
+      RETURNING *
+    `;
+    return (result[0] as User) || null;
+  },
+
+  async delete(id: string): Promise<boolean> {
+    const result = await sql`DELETE FROM users WHERE id = ${id} RETURNING id`;
+    return result.length > 0;
+  },
+};

package/templates/user-management-backend/src/features/users/routes.ts

@@ -0,0 +1,10 @@
+import { Hono } from "hono";
+import { userController } from "./controller";
+
+export const userRoutes = new Hono();
+
+userRoutes.get("/", userController.getAll);
+userRoutes.get("/:id", userController.getById);
+userRoutes.post("/", userController.create);
+userRoutes.put("/:id", userController.update);
+userRoutes.delete("/:id", userController.delete);

package/templates/user-management-backend/src/features/users/schema.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+export const createUserSchema = z.object({
+  email: z.string().email("Invalid email format"),
+  name: z.string().min(1, "Name is required").max(100, "Name too long"),
+});
+
+export const updateUserSchema = z.object({
+  email: z.string().email("Invalid email format").optional(),
+  name: z.string().min(1).max(100).optional(),
+});
+
+export const userIdSchema = z.object({
+  id: z.string().uuid("Invalid user ID"),
+});

package/templates/user-management-backend/src/features/users/service.ts

@@ -0,0 +1,40 @@
+import { userRepository } from "./repository";
+import type { CreateUserDto, UpdateUserDto, User } from "./types";
+
+export const userService = {
+  async getAllUsers(): Promise<User[]> {
+    return userRepository.findAll();
+  },
+
+  async getUserById(id: string): Promise<User | null> {
+    return userRepository.findById(id);
+  },
+
+  async createUser(data: CreateUserDto): Promise<User> {
+    const existing = await userRepository.findByEmail(data.email);
+    if (existing) {
+      throw new Error("Email already exists");
+    }
+    return userRepository.create(data);
+  },
+
+  async updateUser(id: string, data: UpdateUserDto): Promise<User | null> {
+    const user = await userRepository.findById(id);
+    if (!user) {
+      return null;
+    }
+
+    if (data.email && data.email !== user.email) {
+      const existing = await userRepository.findByEmail(data.email);
+      if (existing) {
+        throw new Error("Email already exists");
+      }
+    }
+
+    return userRepository.update(id, data);
+  },
+
+  async deleteUser(id: string): Promise<boolean> {
+    return userRepository.delete(id);
+  },
+};

package/templates/user-management-backend/src/features/users/types.ts

@@ -0,0 +1,17 @@
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+  created_at: Date;
+  updated_at: Date;
+}
+
+export interface CreateUserDto {
+  email: string;
+  name: string;
+}
+
+export interface UpdateUserDto {
+  email?: string;
+  name?: string;
+}

package/templates/user-management-backend/src/index.ts

@@ -0,0 +1,22 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { env } from "./config/env";
+import { appRouter } from "./routes";
+
+const app = new Hono();
+
+// Middleware
+app.use("*", logger());
+app.use("*", cors());
+
+// Routes
+app.route("/api", appRouter);
+
+// Health check
+app.get("/health", (c) => c.json({ status: "ok", timestamp: new Date().toISOString() }));
+
+export default {
+  port: env.PORT,
+  fetch: app.fetch,
+};

package/templates/user-management-backend/src/routes/index.ts

@@ -0,0 +1,8 @@
+import { Hono } from "hono";
+import { userRoutes } from "../features/users/routes";
+
+export const appRouter = new Hono();
+
+appRouter.route("/users", userRoutes);
+
+appRouter.get("/", (c) => c.json({ message: "User Management API" }));

package/templates/user-management-backend/src/shared/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./utils";

package/templates/user-management-backend/src/shared/types/index.ts

@@ -0,0 +1,16 @@
+// Shared types across features
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  message?: string;
+}
+
+export interface PaginatedResponse<T> extends ApiResponse<T[]> {
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}

package/templates/user-management-backend/src/shared/utils/index.ts

@@ -0,0 +1 @@
+export * from "./response";

package/templates/user-management-backend/src/shared/utils/response.ts

@@ -0,0 +1,10 @@
+import type { Context } from "hono";
+import type { ApiResponse } from "../types";
+
+export function successResponse<T>(c: Context, data: T, message?: string, status = 200) {
+  return c.json<ApiResponse<T>>({ success: true, data, message }, status);
+}
+
+export function errorResponse(c: Context, error: string, status = 400) {
+  return c.json<ApiResponse<never>>({ success: false, error }, status);
+}

package/templates/user-management-backend/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"],
+      "@/features/*": ["src/features/*"],
+      "@/shared/*": ["src/shared/*"],
+      "@/config/*": ["src/config/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/user-management-frontend/.env.example

@@ -0,0 +1 @@
+VITE_API_URL=http://localhost:3000/api

package/templates/user-management-frontend/README.md

@@ -0,0 +1,53 @@
+# {{PROJECT_NAME}}
+
+A User Management System frontend with feature-based architecture using React, Vite, and Bun.
+
+## Project Structure
+
+```
+src/
+├── config/           # Configuration
+├── features/         # Feature modules
+│   └── users/
+│       ├── components/
+│       ├── hooks/
+│       ├── services/
+│       ├── types.ts
+│       └── index.ts
+├── shared/           # Shared components
+├── App.tsx
+├── main.tsx
+└── index.css
+```
+
+## Getting Started
+
+```bash
+# Install dependencies
+bun install
+
+# Copy environment file
+cp .env.example .env
+
+# Update VITE_API_URL if your backend runs on a different port
+
+# Run development server
+bun run dev
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `VITE_API_URL` | Backend API URL (default: http://localhost:3000/api) |
+
+## Features
+
+- List all users
+- Create new user
+- Edit existing user
+- Delete user
+
+## Backend Setup
+
+This frontend requires the User Management Backend to be running. See the backend template for setup instructions.

package/templates/user-management-frontend/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{PROJECT_NAME}}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/user-management-frontend/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "bunx --bun vite",
+    "build": "bunx --bun vite build",
+    "preview": "bunx --bun vite preview"
+  },
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.20.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@vitejs/plugin-react": "^4.2.0",
+    "typescript": "^5.0.0",
+    "vite": "^5.0.0"
+  }
+}

package/templates/user-management-frontend/src/App.tsx

@@ -0,0 +1,19 @@
+import { Routes, Route } from "react-router-dom";
+import { UsersPage, UserFormPage } from "./features/users";
+
+export function App() {
+  return (
+    <div className="app">
+      <header className="header">
+        <h1>User Management</h1>
+      </header>
+      <main className="main">
+        <Routes>
+          <Route path="/" element={<UsersPage />} />
+          <Route path="/users/new" element={<UserFormPage />} />
+          <Route path="/users/:id/edit" element={<UserFormPage />} />
+        </Routes>
+      </main>
+    </div>
+  );
+}

package/templates/user-management-frontend/src/config/env.ts

@@ -0,0 +1 @@
+export const API_URL = import.meta.env.VITE_API_URL || "http://localhost:3000/api";

package/templates/user-management-frontend/src/config/index.ts

@@ -0,0 +1 @@
+export * from "./env";