create-buntok 0.1.0 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "create-buntok",
-	"version": "0.1.0",
+	"version": "0.1.3",
 	"description": "CLI tool to create new Buntok projects",
 	"type": "module",
 	"bin": {

package/templates/.vscode/settings.json

@@ -1,8 +1,10 @@
 {
 	"editor.formatOnSave": true,
 	"editor.defaultFormatter": "biomejs.biome",
-	"editor.tabSize": 2,
-	"editor.insertSpaces": false,
+	"editor.codeActionsOnSave": {
+		"source.organizeImports.biome": "explicit",
+		"quickfix.biome": "explicit"
+	},
 	"[typescript]": {
 		"editor.defaultFormatter": "biomejs.biome"
 	},

package/templates/README.md

@@ -0,0 +1,313 @@
+# Buntok Project
+
+> High-performance web framework for [Bun](https://bun.sh) runtime
+
+## Getting Started
+
+```bash
+# Development
+bun run dev
+
+# Production
+bun run start
+```
+
+Server starts on port `3000` (or `PORT` env var).
+
+## Project Structure
+
+```
+src/
+├── controllers/    # Request handlers
+├── db/
+│   └── schemas/    # Drizzle ORM schemas
+├── repositories/   # Database queries
+├── routes/         # Route definitions
+├── services/       # Business logic
+└── index.ts        # Entry point
+```
+
+## Code Generation
+
+Generate CRUD files for an entity:
+
+```bash
+# Generate all files
+bunx buntok create user
+
+# Generate specific files
+bunx buntok create user --schema
+bunx buntok create user --repo --service
+bunx buntok create user --controller
+bunx buntok create user --route
+```
+
+### What Gets Generated
+
+| File | Description |
+|------|-------------|
+| `src/db/schemas/user.ts` | Drizzle schema |
+| `src/repositories/user.repository.ts` | Database queries |
+| `src/services/user.service.ts` | Business logic |
+| `src/controllers/user.controller.ts` | Request handlers |
+| `src/routes/user.routes.ts` | Route definitions + DI registration |
+
+### After Generation
+
+1. Add columns to schema in `src/db/schemas/user.ts`
+2. Run migrations:
+   ```bash
+   bun run db:push      # Push schema to database
+   bun run db:generate  # Generate migration files
+   bun run db:migrate   # Run migrations
+   bun run db:studio    # Open Drizzle Studio
+   ```
+
+3. Register routes in `src/index.ts`:
+   ```ts
+   import { registerUserRoutes } from "@/routes/user.routes";
+   
+   registerUserRoutes(app);
+   ```
+
+## Basic Usage
+
+### Simple Route
+
+```ts
+import { App } from "buntok";
+
+const app = new App();
+
+app.get("/", (ctx) => {
+  return ctx.json({ message: "Hello!" });
+});
+```
+
+### Route with Params
+
+```ts
+app.get("/users/:id", (ctx) => {
+  const { id } = ctx.params;
+  return ctx.json({ id });
+});
+```
+
+### POST with Body
+
+```ts
+app.post("/users", async (ctx) => {
+  const body = await ctx.body<{ name: string }>();
+  return ctx.json({ created: true, data: body }, 201);
+});
+```
+
+### QUERY (Complex Queries)
+
+Like GET but with body support - idempotent and cacheable:
+
+```ts
+app.query("/search", async (ctx) => {
+  const filters = await ctx.body<{
+    query: string;
+    limit: number;
+    sort: string;
+  }>();
+  
+  const results = await db.search(filters);
+  return ctx.json({ data: results });
+});
+```
+
+**Why QUERY over GET/POST?**
+- Body allowed (unlike GET)
+- Idempotent & cacheable (unlike POST)
+- Safe for complex queries
+
+### Route Group
+
+```ts
+const api = app.group("/api");
+
+api.get("/users", getUsers);
+api.post("/users", createUser);
+```
+
+### Middleware
+
+```ts
+// Global middleware
+app.use(async (ctx, next) => {
+  console.log(`→ ${ctx.request.method}`);
+  const response = await next();
+  console.log(`← ${response.status}`);
+  return response;
+});
+
+// Per-route middleware
+app.get("/admin", authMiddleware, (ctx) => {
+  return ctx.json({ message: "Admin only" });
+});
+```
+
+### Dependency Injection
+
+```ts
+// Register
+app.set("userService", new UserService());
+
+// Access in handler
+app.get("/users", (ctx) => {
+  const users = ctx.di.userService.getAll();
+  return ctx.json({ data: users });
+});
+```
+
+## Built-in Middlewares
+
+### CORS
+
+```ts
+import { cors } from "buntok";
+
+app.use(cors({ origin: "*" }));
+```
+
+### Rate Limiter
+
+```ts
+import { rateLimiter } from "buntok";
+
+app.use(rateLimiter({ max: 100, windowMs: 60000 }));
+```
+
+### Request ID
+
+```ts
+import { requestId } from "buntok";
+
+app.use(requestId());
+
+// Access: ctx.store.requestId
+```
+
+### Response Time
+
+```ts
+import { responseTime } from "buntok";
+
+app.use(responseTime());
+
+// Access: ctx.store.responseTime
+```
+
+### Health Check
+
+```ts
+import { healthCheck } from "buntok";
+
+app.use(healthCheck({
+  path: "/health",
+  checks: {
+    database: async () => {
+      await db.query("SELECT 1");
+      return { status: "ok" };
+    },
+  },
+}));
+```
+
+## Context Methods
+
+```ts
+app.get("/example", async (ctx) => {
+  // Body
+  const body = await ctx.body<{ name: string }>();
+  
+  // Params
+  const id = ctx.params.id;
+  
+  // JSON response
+  return ctx.json({ data: "ok" });
+  
+  // Text response
+  return ctx.text("Hello");
+  
+  // HTML response
+  return ctx.html("<h1>Hello</h1>");
+  
+  // Status only
+  return ctx.status(204);
+  
+  // Redirect
+  return ctx.redirect("/login", 302);
+  
+  // Cookies
+  const token = ctx.getCookie("token");
+});
+```
+
+## Error Handling
+
+```ts
+import { NotFoundError, BadRequestError } from "buntok";
+
+// Throw errors - automatically returns proper status code
+throw new NotFoundError("User not found");    // 404
+throw new BadRequestError("Invalid data");    // 400
+
+// Or use asyncHandler in controllers (auto-catches errors)
+import { asyncHandler } from "buntok";
+
+export class UserController {
+  getAll = asyncHandler(async (ctx) => {
+    const users = await this.service.getAll();
+    return ctx.json({ data: users });
+  });
+}
+```
+
+## Database Commands
+
+```bash
+bun run db:push      # Push schema to database
+bun run db:generate  # Generate migration files
+bun run db:migrate   # Run migrations
+bun run db:studio    # Open Drizzle Studio
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+# .env
+DATABASE_URL=postgresql://user:password@localhost:5432/mydb
+PORT=3000
+NODE_ENV=development
+```
+
+### tsconfig.json
+
+Path aliases are configured:
+```json
+{
+  "paths": {
+    "@/*": ["./src/*"]
+  }
+}
+```
+
+Use `@/` for imports:
+```ts
+import { UserService } from "@/services/user.service";
+```
+
+## Learn More
+
+- [Buntok Documentation](https://www.npmjs.com/package/buntok)
+- [Bun Documentation](https://bun.sh/docs)
+
+## License
+
+MIT

package/templates/package.json

@@ -15,11 +15,12 @@
 	},
 	"dependencies": {
 		"buntok": "latest",
-		"drizzle-orm": "^0.38.0"
+		"drizzle-orm": "^0.45.2"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.3",
 		"@types/bun": "latest",
+		"@types/node": "^22",
 		"drizzle-kit": "^0.30.0",
 		"typescript": "^5"
 	}

package/templates/src/db/index.ts

@@ -1,5 +1,5 @@
 import { drizzle } from "drizzle-orm/bun-sql";
-import * as schema from "./schemas";
+import * as schema from "./schemas/index";
 
 // TODO: Update DATABASE_URL in .env file
 // Example: DATABASE_URL=postgresql://user:password@localhost:5432/mydb

package/templates/src/db/schemas/index.ts

@@ -0,0 +1,3 @@
+// Export your schemas here
+// Example:
+// export * from "./user";

package/templates/src/index.ts

@@ -3,9 +3,5 @@ import { App } from "buntok";
 const app = new App();
 
 app.get("/", (ctx) => {
-	return ctx.json({ message: "Welcome to {PROJECT_NAME}!" });
-});
-
-app.listen(3000, () => {
-	console.log("Server running on http://localhost:3000");
+	return ctx.json({ message: "Welcome to BUNTOK!" });
 });

package/templates/tsconfig.json

@@ -12,7 +12,11 @@
 		"verbatimModuleSyntax": true,
 		"noEmit": true,
 		"strict": true,
-		"skipLibCheck": true
+		"skipLibCheck": true,
+		"baseUrl": ".",
+		"paths": {
+			"@/*": ["./src/*"]
+		}
 	},
 	"include": ["src/**/*"]
 }