deploy-bbc 0.0.1

package/cli/src/templates/base-bun-native/src/index.ts

@@ -0,0 +1,50 @@
+import { config } from "./config/index.js";
+import { logger } from "./middleware/logger.js";
+import { errorHandler } from "./middleware/error.js";
+import { router } from "./routes/index.js";
+
+/**
+ * Simple router matcher for Bun native server
+ */
+function match_route(pathname: string, method: string): Response | null {
+  return router(pathname, method);
+}
+
+const server = Bun.serve({
+  port: config.port,
+  async fetch(req) {
+    const url = new URL(req.url);
+    const start = Date.now();
+
+    try {
+      // Health check
+      if (url.pathname === "/health" && req.method === "GET") {
+        const response = Response.json({
+          status: "ok",
+          timestamp: new Date().toISOString(),
+        });
+        logger(req, response, Date.now() - start);
+        return response;
+      }
+
+      // Match routes
+      const response = match_route(url.pathname, req.method);
+      if (response) {
+        logger(req, response, Date.now() - start);
+        return response;
+      }
+
+      // 404 Not Found
+      const notFoundResponse = Response.json(
+        { error: "Not Found" },
+        { status: 404 }
+      );
+      logger(req, notFoundResponse, Date.now() - start);
+      return notFoundResponse;
+    } catch (error) {
+      return errorHandler(error, req);
+    }
+  },
+});
+
+console.log(`🚀 Server running on http://localhost:${server.port}`);

package/cli/src/templates/base-bun-native/src/middleware/error.ts

@@ -0,0 +1,20 @@
+/**
+ * Error handler for Bun native server
+ */
+export function errorHandler(error: unknown, req: Request): Response {
+  console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`, error);
+
+  const status = error instanceof Error && "status" in error
+    ? (error as Error & { status: number }).status
+    : 500;
+
+  const message = error instanceof Error ? error.message : "Internal Server Error";
+
+  return Response.json(
+    {
+      error: message,
+      status,
+    },
+    { status }
+  );
+}

package/cli/src/templates/base-bun-native/src/middleware/logger.ts

@@ -0,0 +1,6 @@
+/**
+ * Simple logger middleware for Bun native server
+ */
+export function logger(req: Request, res: Response, duration: number): void {
+  console.log(`${req.method} ${new URL(req.url).pathname} - ${res.status} (${duration}ms)`);
+}

package/cli/src/templates/base-bun-native/src/routes/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Simple router for Bun native server
+ * Add your routes here
+ */
+export function router(pathname: string, method: string): Response | null {
+  // GET /
+  if (pathname === "/" && method === "GET") {
+    return Response.json({
+      message: "Welcome to your Bun backend!",
+      docs: "/docs",
+    });
+  }
+
+  // Add more routes here
+  // Example:
+  // if (pathname === "/users" && method === "GET") {
+  //   return Response.json({ users: [] });
+  // }
+
+  return null; // No route matched
+}

package/cli/src/templates/base-bun-native/src/types/index.ts

@@ -0,0 +1,2 @@
+// Add your TypeScript types and interfaces here
+export {};

package/cli/src/templates/base-bun-native/src/utils/env.ts

@@ -0,0 +1,5 @@
+import { config as dotenvConfig } from "dotenv";
+
+export function load_env(): void {
+  dotenvConfig();
+}

package/cli/src/templates/base-bun-native/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "types": ["bun-types"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/cli/src/templates/base-express/.env.example

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

package/cli/src/templates/base-express/README.md

@@ -0,0 +1,31 @@
+# My Backend App
+
+Production-ready Bun backend with TypeScript and Hono.
+
+## Getting Started
+
+```bash
+# Install dependencies
+bun install
+
+# Copy environment variables
+cp .env.example .env
+
+# Run development server
+bun run dev
+
+# Build for production
+bun run build
+
+# Run production server
+bun run start
+```
+
+## API Endpoints
+
+- `GET /` - Welcome message
+- `GET /health` - Health check
+
+## Documentation
+
+Visit `/docs` for API documentation (if Swagger/Scalar is installed).

package/cli/src/templates/base-express/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "my-backend-app",
+  "version": "1.0.0",
+  "description": "Production-ready backend with Express and TypeScript",
+  "type": "module",
+  "scripts": {
+    "dev": "bun --watch src/index.ts",
+    "start": "bun src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target bun",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "dotenv": "^16.3.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/express": "^4.17.21",
+    "typescript": "^5.3.3"
+  }
+}

package/cli/src/templates/base-express/src/config/index.ts

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

package/cli/src/templates/base-express/src/index.ts

@@ -0,0 +1,27 @@
+import express from "express";
+import { logger as loggerMiddleware } from "./middleware/logger.js";
+import { errorHandler } from "./middleware/error.js";
+import routes from "./routes/index.js";
+import { config } from "./config/index.js";
+
+const app = express();
+
+// Middleware
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(loggerMiddleware);
+
+// Routes
+app.use("/", routes);
+
+// Health check
+app.get("/health", (req, res) => {
+  res.json({ status: "ok", timestamp: new Date().toISOString() });
+});
+
+// Error handler (must be last)
+app.use(errorHandler);
+
+app.listen(config.port, () => {
+  console.log(`🚀 Server running on http://localhost:${config.port}`);
+});

package/cli/src/templates/base-express/src/middleware/error.ts

@@ -0,0 +1,15 @@
+import type { Request, Response, NextFunction } from "express";
+
+export const errorHandler = (
+  err: Error & { status?: number },
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  console.error(`Error: ${err.message}`, err);
+
+  res.status(err.status || 500).json({
+    error: err.message || "Internal Server Error",
+    status: err.status || 500,
+  });
+};

package/cli/src/templates/base-express/src/middleware/logger.ts

@@ -0,0 +1,12 @@
+import type { Request, Response, NextFunction } from "express";
+
+export const logger = (req: Request, res: Response, next: NextFunction) => {
+  const start = Date.now();
+
+  res.on("finish", () => {
+    const ms = Date.now() - start;
+    console.log(`${req.method} ${req.url} - ${res.statusCode} (${ms}ms)`);
+  });
+
+  next();
+};

package/cli/src/templates/base-express/src/routes/index.ts

@@ -0,0 +1,12 @@
+import express from "express";
+
+const router = express.Router();
+
+router.get("/", (req, res) => {
+  res.json({
+    message: "Welcome to your Bun backend!",
+    docs: "/docs",
+  });
+});
+
+export default router;

package/cli/src/templates/base-express/src/types/index.ts

@@ -0,0 +1,2 @@
+// Add your TypeScript types and interfaces here
+export {};

package/cli/src/templates/base-express/src/utils/env.ts

@@ -0,0 +1,5 @@
+import { config as dotenvConfig } from "dotenv";
+
+export function load_env(): void {
+  dotenvConfig();
+}

package/cli/src/templates/base-express/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "types": ["bun-types"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/cli/src/templates/extras/validation/yup/src/middleware/index.ts

@@ -0,0 +1 @@
+export { validate, get_validated, type ValidateTarget } from "./validate.js";

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

@@ -0,0 +1,83 @@
+import { Context, Next } from "hono";
+import * as yup from "yup";
+
+/**
+ * Validation middleware for Hono using Yup schemas
+ * Validates request body, query parameters, or route params
+ */
+
+export type ValidateTarget = "body" | "query" | "param";
+
+interface ValidationOptions {
+  target: ValidateTarget;
+  schema: yup.AnySchema;
+}
+
+/**
+ * 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 = await options.schema.validate(data, {
+        abortEarly: false,
+        stripUnknown: true,
+      });
+
+      // Store validated data in context for route handlers
+      c.set(`validated_${options.target}`, validated);
+
+      await next();
+    } catch (error) {
+      if (error instanceof yup.ValidationError) {
+        return c.json(
+          {
+            error: "Validation failed",
+            details: error.inner.map((err) => ({
+              path: err.path || "unknown",
+              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/yup/src/routes/users.ts

@@ -0,0 +1,132 @@
+import { Hono } from "hono";
+import * as yup from "yup";
+import { validate, get_validated } from "../middleware/validate.js";
+
+const users = new Hono();
+
+/**
+ * Yup Schemas for validation
+ */
+
+// Schema for creating a new user
+const create_user_schema = yup.object({
+  name: yup.string().required().min(2, "Name must be at least 2 characters"),
+  email: yup.string().required().email("Invalid email format"),
+  age: yup.number().integer().min(18, "Must be at least 18 years old").optional(),
+});
+
+// Schema for updating a user
+const update_user_schema = yup.object({
+  name: yup.string().min(2).optional(),
+  email: yup.string().email().optional(),
+  age: yup.number().integer().min(18).optional(),
+});
+
+// Schema for query parameters
+const list_users_query_schema = yup.object({
+  page: yup.number().transform((value, originalValue) => {
+    return originalValue ? parseInt(originalValue, 10) : undefined;
+  }).optional(),
+  limit: yup.number().transform((value, originalValue) => {
+    return originalValue ? parseInt(originalValue, 10) : undefined;
+  }).optional(),
+  search: yup.string().optional(),
+});
+
+// Schema for route params
+const user_id_param_schema = yup.object({
+  id: yup.string().required().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<yup.InferType<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<yup.InferType<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<yup.InferType<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<yup.InferType<typeof user_id_param_schema>>(c, "param");
+    const body = get_validated<yup.InferType<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<yup.InferType<typeof user_id_param_schema>>(c, "param");
+
+    return c.json({
+      message: `User ${params.id} deleted successfully`,
+    });
+  }
+);
+
+export default users;

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

@@ -0,0 +1 @@
+export { validate, get_validated, type ValidateTarget } from "./validate.js";