@yoms/create-monorepo 1.0.2

package/templates/backend-hono/base/src/middleware/rate-limit.middleware.ts

@@ -0,0 +1,135 @@
+import type { Context, Next } from 'hono';
+import { TooManyRequestsError } from '../lib/errors.js';
+import { logger } from '../config/logger.js';
+
+interface RateLimitOptions {
+  windowMs: number; // Time window in milliseconds
+  max: number; // Max requests per window
+  message?: string;
+  keyGenerator?: (c: Context) => string;
+}
+
+interface RateLimitStore {
+  get(key: string): Promise<number | null>;
+  increment(key: string, ttl: number): Promise<number>;
+}
+
+/**
+ * In-memory rate limit store
+ */
+class MemoryStore implements RateLimitStore {
+  private hits: Map<string, { count: number; resetTime: number }> = new Map();
+
+  async get(key: string): Promise<number | null> {
+    const entry = this.hits.get(key);
+    if (!entry) return null;
+
+    // Clean up expired entries
+    if (Date.now() > entry.resetTime) {
+      this.hits.delete(key);
+      return null;
+    }
+
+    return entry.count;
+  }
+
+  async increment(key: string, ttl: number): Promise<number> {
+    const now = Date.now();
+    const entry = this.hits.get(key);
+
+    if (!entry || now > entry.resetTime) {
+      const resetTime = now + ttl;
+      this.hits.set(key, { count: 1, resetTime });
+      return 1;
+    }
+
+    entry.count++;
+    return entry.count;
+  }
+
+  // Cleanup old entries periodically
+  startCleanup(intervalMs: number = 60000) {
+    setInterval(() => {
+      const now = Date.now();
+      for (const [key, entry] of this.hits.entries()) {
+        if (now > entry.resetTime) {
+          this.hits.delete(key);
+        }
+      }
+    }, intervalMs);
+  }
+}
+
+// Create singleton memory store
+const memoryStore = new MemoryStore();
+memoryStore.startCleanup();
+
+/**
+ * Rate limiting middleware factory
+ */
+export function rateLimit(options: RateLimitOptions) {
+  const {
+    windowMs,
+    max,
+    message = 'Too many requests, please try again later',
+    keyGenerator = (c) => c.req.header('x-forwarded-for') || c.req.header('x-real-ip') || 'unknown',
+  } = options;
+
+  return async (c: Context, next: Next) => {
+    const key = `rate-limit:${keyGenerator(c)}`;
+    const store = memoryStore;
+
+    try {
+      const hits = await store.increment(key, windowMs);
+
+      // Set rate limit headers
+      c.header('X-RateLimit-Limit', max.toString());
+      c.header('X-RateLimit-Remaining', Math.max(0, max - hits).toString());
+      c.header('X-RateLimit-Reset', new Date(Date.now() + windowMs).toISOString());
+
+      if (hits > max) {
+        logger.warn('Rate limit exceeded:', { key, hits, max });
+        throw new TooManyRequestsError(message);
+      }
+
+      await next();
+    } catch (error) {
+      if (error instanceof TooManyRequestsError) {
+        throw error;
+      }
+      // If store fails, log but allow request
+      logger.error('Rate limit store error:', error);
+      await next();
+    }
+  };
+}
+
+/**
+ * Common rate limit configurations
+ */
+export const rateLimits = {
+  // Strict: 10 requests per minute
+  strict: rateLimit({
+    windowMs: 60 * 1000,
+    max: 10,
+  }),
+
+  // Standard: 100 requests per minute
+  standard: rateLimit({
+    windowMs: 60 * 1000,
+    max: 100,
+  }),
+
+  // Lenient: 1000 requests per minute
+  lenient: rateLimit({
+    windowMs: 60 * 1000,
+    max: 1000,
+  }),
+
+  // Auth: 5 login attempts per 15 minutes
+  auth: rateLimit({
+    windowMs: 15 * 60 * 1000,
+    max: 5,
+    message: 'Too many login attempts, please try again later',
+  }),
+};

package/templates/backend-hono/base/src/routes/__tests__/health.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { Hono } from 'hono';
+import { health } from '../health.route.js';
+
+describe('Health Route', () => {
+  const app = new Hono();
+  app.route('/health', health);
+
+  it('should return 200 OK with health status', async () => {
+    const res = await app.request('/health');
+    expect(res.status).toBe(200);
+
+    const json = await res.json();
+    expect(json.success).toBe(true);
+    expect(json.data).toHaveProperty('status', 'ok');
+    expect(json.data).toHaveProperty('timestamp');
+    expect(json.data).toHaveProperty('uptime');
+  });
+
+  it('should return valid timestamp', async () => {
+    const res = await app.request('/health');
+    const json = await res.json();
+
+    const timestamp = new Date(json.data.timestamp);
+    expect(timestamp.getTime()).not.toBeNaN();
+    expect(timestamp.getTime()).toBeLessThanOrEqual(Date.now());
+  });
+
+  it('should return positive uptime', async () => {
+    const res = await app.request('/health');
+    const json = await res.json();
+
+    expect(json.data.uptime).toBeGreaterThan(0);
+    expect(typeof json.data.uptime).toBe('number');
+  });
+});

package/templates/backend-hono/base/src/routes/health.route.ts

@@ -0,0 +1,14 @@
+import { Hono } from 'hono';
+import { success } from '../lib/response.js';
+
+const health = new Hono();
+
+health.get('/', (c) => {
+  return success(c, {
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+  });
+});
+
+export { health };

package/templates/backend-hono/base/src/types/app.types.ts

@@ -0,0 +1,26 @@
+import type { Hono } from 'hono';
+
+export type AppType = Hono;
+
+export interface ApiResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  message?: string;
+  code?: string;
+  details?: unknown;
+}
+
+export interface PaginationParams {
+  page: number;
+  limit: number;
+}
+
+export interface PaginatedResponse<T> extends ApiResponse<T[]> {
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}

package/templates/backend-hono/base/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/backend-hono/base/vitest.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'dist/',
+        '**/*.test.ts',
+        '**/*.spec.ts',
+        'vitest.config.ts',
+      ],
+    },
+  },
+});

package/templates/backend-hono/features/mongodb-prisma/env-additions.txt

@@ -0,0 +1,2 @@
+# Database Configuration (MongoDB)
+DATABASE_URL="mongodb://localhost:27017/__PROJECT_NAME__"

package/templates/backend-hono/features/mongodb-prisma/package-additions.json

@@ -0,0 +1,14 @@
+{
+  "dependencies": {
+    "@prisma/client": "^6.2.0",
+    "@hono/zod-validator": "^0.4.1"
+  },
+  "devDependencies": {
+    "prisma": "^6.2.0"
+  },
+  "scripts": {
+    "prisma:generate": "prisma generate",
+    "prisma:push": "prisma db push",
+    "prisma:studio": "prisma studio"
+  }
+}

package/templates/backend-hono/features/mongodb-prisma/prisma/schema.prisma

@@ -0,0 +1,18 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "mongodb"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(auto()) @map("_id") @db.ObjectId
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("users")
+}

package/templates/backend-hono/features/mongodb-prisma/src/config/database.ts

@@ -0,0 +1,43 @@
+import { PrismaClient } from '@prisma/client';
+import { z } from 'zod';
+import { logger } from './logger.js';
+
+// Validate database environment variables
+const dbEnvSchema = z.object({
+  DATABASE_URL: z.string().min(1, 'DATABASE_URL is required'),
+});
+
+const dbEnv = dbEnvSchema.parse(process.env);
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const prisma = globalForPrisma.prisma ?? new PrismaClient({
+  datasources: {
+    db: {
+      url: dbEnv.DATABASE_URL,
+    },
+  },
+  log: process.env.NODE_ENV === 'development'
+    ? ['query', 'error', 'warn']
+    : ['error'],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  globalForPrisma.prisma = prisma;
+}
+
+// Test connection
+prisma.$connect()
+  .then(() => logger.info('Database connected successfully'))
+  .catch((error) => {
+    logger.error('Database connection failed:', error);
+    process.exit(1);
+  });
+
+// Graceful shutdown
+process.on('beforeExit', async () => {
+  await prisma.$disconnect();
+  logger.info('Database disconnected');
+});

package/templates/backend-hono/features/mongodb-prisma/src/routes/users.route.ts

@@ -0,0 +1,82 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+import { UserService } from '../services/user.service.js';
+import { success, created, noContent, paginated } from '../lib/response.js';
+import { CreateUserSchema, UpdateUserSchema } from '__PACKAGE_SCOPE__/shared';
+
+const users = new Hono();
+
+// Query params schema for pagination
+const paginationSchema = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  limit: z.coerce.number().int().min(1).max(100).default(10),
+});
+
+// Query params schema for search
+const searchSchema = paginationSchema.extend({
+  q: z.string().min(1),
+});
+
+/**
+ * GET /users - List all users
+ */
+users.get('/', zValidator('query', paginationSchema), async (c) => {
+  const { page, limit } = c.req.valid('query');
+  const result = await UserService.getAll(page, limit);
+
+  return paginated(c, result.users, page, limit, result.total);
+});
+
+/**
+ * GET /users/search - Search users
+ */
+users.get('/search', zValidator('query', searchSchema), async (c) => {
+  const { q, page, limit } = c.req.valid('query');
+  const result = await UserService.search(q, page, limit);
+
+  return paginated(c, result.users, page, limit, result.total);
+});
+
+/**
+ * GET /users/:id - Get user by ID
+ */
+users.get('/:id', async (c) => {
+  const id = c.req.param('id');
+  const user = await UserService.getById(id);
+
+  return success(c, user);
+});
+
+/**
+ * POST /users - Create new user
+ */
+users.post('/', zValidator('json', CreateUserSchema), async (c) => {
+  const data = c.req.valid('json');
+  const user = await UserService.create(data);
+
+  return created(c, user);
+});
+
+/**
+ * PATCH /users/:id - Update user
+ */
+users.patch('/:id', zValidator('json', UpdateUserSchema), async (c) => {
+  const id = c.req.param('id');
+  const data = c.req.valid('json');
+  const user = await UserService.update(id, data);
+
+  return success(c, user);
+});
+
+/**
+ * DELETE /users/:id - Delete user
+ */
+users.delete('/:id', async (c) => {
+  const id = c.req.param('id');
+  await UserService.delete(id);
+
+  return noContent(c);
+});
+
+export { users };

package/templates/backend-hono/features/mongodb-prisma/src/services/user.service.ts

@@ -0,0 +1,121 @@
+import { prisma } from '../config/database.js';
+import { NotFoundError, ConflictError } from '../lib/errors.js';
+import type { CreateUser, UpdateUser, User } from '__PACKAGE_SCOPE__/shared';
+
+export class UserService {
+  /**
+   * Get all users with pagination
+   */
+  static async getAll(page: number = 1, limit: number = 10) {
+    const skip = (page - 1) * limit;
+
+    const [users, total] = await Promise.all([
+      prisma.user.findMany({
+        skip,
+        take: limit,
+        orderBy: { createdAt: 'desc' },
+      }),
+      prisma.user.count(),
+    ]);
+
+    return { users, total, page, limit };
+  }
+
+  /**
+   * Get user by ID
+   */
+  static async getById(id: string): Promise<User> {
+    const user = await prisma.user.findUnique({
+      where: { id },
+    });
+
+    if (!user) {
+      throw new NotFoundError(`User with ID ${id} not found`);
+    }
+
+    return user;
+  }
+
+  /**
+   * Get user by email
+   */
+  static async getByEmail(email: string): Promise<User | null> {
+    return prisma.user.findUnique({
+      where: { email },
+    });
+  }
+
+  /**
+   * Create new user
+   */
+  static async create(data: CreateUser): Promise<User> {
+    // Check if email already exists
+    const existing = await this.getByEmail(data.email);
+    if (existing) {
+      throw new ConflictError(`User with email ${data.email} already exists`);
+    }
+
+    return prisma.user.create({
+      data,
+    });
+  }
+
+  /**
+   * Update user
+   */
+  static async update(id: string, data: UpdateUser): Promise<User> {
+    // Verify user exists
+    await this.getById(id);
+
+    // If email is being updated, check it's not taken
+    if (data.email) {
+      const existing = await this.getByEmail(data.email);
+      if (existing && existing.id !== id) {
+        throw new ConflictError(`Email ${data.email} is already taken`);
+      }
+    }
+
+    return prisma.user.update({
+      where: { id },
+      data,
+    });
+  }
+
+  /**
+   * Delete user
+   */
+  static async delete(id: string): Promise<void> {
+    // Verify user exists
+    await this.getById(id);
+
+    await prisma.user.delete({
+      where: { id },
+    });
+  }
+
+  /**
+   * Search users by name or email
+   */
+  static async search(query: string, page: number = 1, limit: number = 10) {
+    const skip = (page - 1) * limit;
+
+    const where = {
+      OR: [
+        { name: { contains: query, mode: 'insensitive' as const } },
+        { email: { contains: query, mode: 'insensitive' as const } },
+      ],
+    };
+
+    const [users, total] = await Promise.all([
+      prisma.user.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy: { createdAt: 'desc' },
+      }),
+      prisma.user.count({ where }),
+    ]);
+
+    return { users, total, page, limit };
+  }
+}

package/templates/backend-hono/features/postgres-prisma/env-additions.txt

@@ -0,0 +1,2 @@
+# Database Configuration (PostgreSQL)
+DATABASE_URL="postgresql://user:password@localhost:5432/__PROJECT_NAME__?schema=public"

package/templates/backend-hono/features/postgres-prisma/package-additions.json

@@ -0,0 +1,15 @@
+{
+  "dependencies": {
+    "@prisma/client": "^6.2.0",
+    "@hono/zod-validator": "^0.4.1"
+  },
+  "devDependencies": {
+    "prisma": "^6.2.0"
+  },
+  "scripts": {
+    "prisma:generate": "prisma generate",
+    "prisma:migrate": "prisma migrate dev",
+    "prisma:studio": "prisma studio",
+    "prisma:push": "prisma db push"
+  }
+}

package/templates/backend-hono/features/postgres-prisma/prisma/schema.prisma

@@ -0,0 +1,18 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("users")
+}

package/templates/backend-hono/features/postgres-prisma/src/config/database.ts

@@ -0,0 +1,43 @@
+import { PrismaClient } from '@prisma/client';
+import { z } from 'zod';
+import { logger } from './logger.js';
+
+// Validate database environment variables
+const dbEnvSchema = z.object({
+  DATABASE_URL: z.string().min(1, 'DATABASE_URL is required'),
+});
+
+const dbEnv = dbEnvSchema.parse(process.env);
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const prisma = globalForPrisma.prisma ?? new PrismaClient({
+  datasources: {
+    db: {
+      url: dbEnv.DATABASE_URL,
+    },
+  },
+  log: process.env.NODE_ENV === 'development'
+    ? ['query', 'error', 'warn']
+    : ['error'],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  globalForPrisma.prisma = prisma;
+}
+
+// Test connection
+prisma.$connect()
+  .then(() => logger.info('Database connected successfully'))
+  .catch((error) => {
+    logger.error('Database connection failed:', error);
+    process.exit(1);
+  });
+
+// Graceful shutdown
+process.on('beforeExit', async () => {
+  await prisma.$disconnect();
+  logger.info('Database disconnected');
+});

package/templates/backend-hono/features/postgres-prisma/src/routes/users.route.ts

@@ -0,0 +1,82 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+import { UserService } from '../services/user.service.js';
+import { success, created, noContent, paginated } from '../lib/response.js';
+import { CreateUserSchema, UpdateUserSchema } from '__PACKAGE_SCOPE__/shared';
+
+const users = new Hono();
+
+// Query params schema for pagination
+const paginationSchema = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  limit: z.coerce.number().int().min(1).max(100).default(10),
+});
+
+// Query params schema for search
+const searchSchema = paginationSchema.extend({
+  q: z.string().min(1),
+});
+
+/**
+ * GET /users - List all users
+ */
+users.get('/', zValidator('query', paginationSchema), async (c) => {
+  const { page, limit } = c.req.valid('query');
+  const result = await UserService.getAll(page, limit);
+
+  return paginated(c, result.users, page, limit, result.total);
+});
+
+/**
+ * GET /users/search - Search users
+ */
+users.get('/search', zValidator('query', searchSchema), async (c) => {
+  const { q, page, limit } = c.req.valid('query');
+  const result = await UserService.search(q, page, limit);
+
+  return paginated(c, result.users, page, limit, result.total);
+});
+
+/**
+ * GET /users/:id - Get user by ID
+ */
+users.get('/:id', async (c) => {
+  const id = c.req.param('id');
+  const user = await UserService.getById(id);
+
+  return success(c, user);
+});
+
+/**
+ * POST /users - Create new user
+ */
+users.post('/', zValidator('json', CreateUserSchema), async (c) => {
+  const data = c.req.valid('json');
+  const user = await UserService.create(data);
+
+  return created(c, user);
+});
+
+/**
+ * PATCH /users/:id - Update user
+ */
+users.patch('/:id', zValidator('json', UpdateUserSchema), async (c) => {
+  const id = c.req.param('id');
+  const data = c.req.valid('json');
+  const user = await UserService.update(id, data);
+
+  return success(c, user);
+});
+
+/**
+ * DELETE /users/:id - Delete user
+ */
+users.delete('/:id', async (c) => {
+  const id = c.req.param('id');
+  await UserService.delete(id);
+
+  return noContent(c);
+});
+
+export { users };