@yoms/create-monorepo 1.0.2

package/templates/backend-hono/features/postgres-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/redis/env-additions.txt

@@ -0,0 +1,2 @@
+# Redis Configuration
+REDIS_URL="redis://localhost:6379"

package/templates/backend-hono/features/redis/package-additions.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "ioredis": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/ioredis": "^5.0.0"
+  }
+}

package/templates/backend-hono/features/redis/src/config/redis.ts

@@ -0,0 +1,32 @@
+import Redis from 'ioredis';
+import { z } from 'zod';
+import { logger } from './logger.js';
+
+// Validate Redis environment variables
+const redisEnvSchema = z.object({
+  REDIS_URL: z.string().default('redis://localhost:6379'),
+});
+
+const redisEnv = redisEnvSchema.parse(process.env);
+
+export const redis = new Redis(redisEnv.REDIS_URL, {
+  maxRetriesPerRequest: 3,
+  retryStrategy: (times) => {
+    const delay = Math.min(times * 50, 2000);
+    return delay;
+  },
+});
+
+redis.on('connect', () => {
+  logger.info('Redis connected successfully');
+});
+
+redis.on('error', (error) => {
+  logger.error('Redis connection error:', error);
+});
+
+// Graceful shutdown
+process.on('beforeExit', async () => {
+  await redis.quit();
+  logger.info('Redis disconnected');
+});

package/templates/backend-hono/features/redis/src/services/cache.service.ts

@@ -0,0 +1,107 @@
+import { redis } from '../config/redis.js';
+import { logger } from '../config/logger.js';
+
+export class CacheService {
+  /**
+   * Get cached value
+   */
+  static async get<T>(key: string): Promise<T | null> {
+    try {
+      const value = await redis.get(key);
+      if (!value) return null;
+      return JSON.parse(value) as T;
+    } catch (error) {
+      logger.error('Cache get error:', { key, error });
+      return null;
+    }
+  }
+
+  /**
+   * Set cached value with optional TTL (in seconds)
+   */
+  static async set(key: string, value: unknown, ttl?: number): Promise<boolean> {
+    try {
+      const serialized = JSON.stringify(value);
+      if (ttl) {
+        await redis.setex(key, ttl, serialized);
+      } else {
+        await redis.set(key, serialized);
+      }
+      return true;
+    } catch (error) {
+      logger.error('Cache set error:', { key, error });
+      return false;
+    }
+  }
+
+  /**
+   * Delete cached value
+   */
+  static async delete(key: string): Promise<boolean> {
+    try {
+      await redis.del(key);
+      return true;
+    } catch (error) {
+      logger.error('Cache delete error:', { key, error });
+      return false;
+    }
+  }
+
+  /**
+   * Delete cached values matching pattern using SCAN
+   * (Non-blocking alternative to KEYS command)
+   */
+  static async deletePattern(pattern: string): Promise<number> {
+    try {
+      let cursor = '0';
+      let deletedCount = 0;
+
+      do {
+        // Use SCAN instead of KEYS to avoid blocking Redis
+        const [nextCursor, keys] = await redis.scan(
+          cursor,
+          'MATCH',
+          pattern,
+          'COUNT',
+          100
+        );
+        cursor = nextCursor;
+
+        if (keys.length > 0) {
+          deletedCount += await redis.del(...keys);
+        }
+      } while (cursor !== '0');
+
+      return deletedCount;
+    } catch (error) {
+      logger.error('Cache delete pattern error:', { pattern, error });
+      return 0;
+    }
+  }
+
+  /**
+   * Check if key exists
+   */
+  static async exists(key: string): Promise<boolean> {
+    try {
+      const result = await redis.exists(key);
+      return result === 1;
+    } catch (error) {
+      logger.error('Cache exists error:', { key, error });
+      return false;
+    }
+  }
+
+  /**
+   * Set expiry on existing key
+   */
+  static async expire(key: string, ttl: number): Promise<boolean> {
+    try {
+      const result = await redis.expire(key, ttl);
+      return result === 1;
+    } catch (error) {
+      logger.error('Cache expire error:', { key, ttl, error });
+      return false;
+    }
+  }
+}

package/templates/backend-hono/features/smtp/env-additions.txt

@@ -0,0 +1,7 @@
+# SMTP Configuration
+SMTP_HOST="smtp.gmail.com"
+SMTP_PORT="587"
+SMTP_USER="your-email@gmail.com"
+SMTP_PASS="your-app-password"
+SMTP_FROM="noreply@__PROJECT_NAME__.com"
+WEB_URL="http://localhost:__WEB_PORT__"

package/templates/backend-hono/features/smtp/package-additions.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "nodemailer": "^6.9.16"
+  },
+  "devDependencies": {
+    "@types/nodemailer": "^6.4.16"
+  }
+}

package/templates/backend-hono/features/smtp/src/config/mail.ts

@@ -0,0 +1,38 @@
+import nodemailer from 'nodemailer';
+import type { Transporter } from 'nodemailer';
+import { z } from 'zod';
+import { logger } from './logger.js';
+
+// Validate SMTP environment variables
+const smtpEnvSchema = z.object({
+  SMTP_HOST: z.string().default('localhost'),
+  SMTP_PORT: z.coerce.number().default(587),
+  SMTP_USER: z.string().optional(),
+  SMTP_PASS: z.string().optional(),
+  SMTP_FROM: z.string().email().default('noreply@example.com'),
+});
+
+const smtpEnv = smtpEnvSchema.parse(process.env);
+
+export const transporter: Transporter = nodemailer.createTransporter({
+  host: smtpEnv.SMTP_HOST,
+  port: smtpEnv.SMTP_PORT,
+  secure: smtpEnv.SMTP_PORT === 465,
+  auth: smtpEnv.SMTP_USER && smtpEnv.SMTP_PASS ? {
+    user: smtpEnv.SMTP_USER,
+    pass: smtpEnv.SMTP_PASS,
+  } : undefined,
+});
+
+// Verify connection
+transporter.verify((error) => {
+  if (error) {
+    logger.error('SMTP connection failed:', error);
+  } else {
+    logger.info('SMTP server ready');
+  }
+});
+
+export const mailConfig = {
+  from: smtpEnv.SMTP_FROM,
+};

package/templates/backend-hono/features/smtp/src/services/email.service.ts

@@ -0,0 +1,78 @@
+import { transporter, mailConfig } from '../config/mail.js';
+import { logger } from '../config/logger.js';
+
+export interface EmailOptions {
+  to: string | string[];
+  subject: string;
+  text?: string;
+  html?: string;
+  from?: string;
+}
+
+export class EmailService {
+  /**
+   * Send email
+   */
+  static async send(options: EmailOptions): Promise<boolean> {
+    try {
+      const info = await transporter.sendMail({
+        from: options.from || mailConfig.from,
+        to: Array.isArray(options.to) ? options.to.join(', ') : options.to,
+        subject: options.subject,
+        text: options.text,
+        html: options.html,
+      });
+
+      logger.info('Email sent successfully:', {
+        messageId: info.messageId,
+        to: options.to,
+        subject: options.subject,
+      });
+
+      return true;
+    } catch (error) {
+      logger.error('Failed to send email:', {
+        error,
+        to: options.to,
+        subject: options.subject,
+      });
+      return false;
+    }
+  }
+
+  /**
+   * Send welcome email
+   */
+  static async sendWelcome(email: string, name: string): Promise<boolean> {
+    return this.send({
+      to: email,
+      subject: 'Welcome to __PROJECT_NAME__!',
+      html: `
+        <h1>Welcome, ${name}!</h1>
+        <p>Thank you for joining __PROJECT_NAME__.</p>
+        <p>We're excited to have you on board!</p>
+      `,
+      text: `Welcome, ${name}! Thank you for joining __PROJECT_NAME__. We're excited to have you on board!`,
+    });
+  }
+
+  /**
+   * Send password reset email
+   */
+  static async sendPasswordReset(email: string, resetToken: string): Promise<boolean> {
+    const resetUrl = `${process.env.WEB_URL}/reset-password?token=${resetToken}`;
+
+    return this.send({
+      to: email,
+      subject: 'Password Reset Request',
+      html: `
+        <h1>Password Reset</h1>
+        <p>You requested a password reset. Click the link below to reset your password:</p>
+        <a href="${resetUrl}">${resetUrl}</a>
+        <p>This link will expire in 1 hour.</p>
+        <p>If you didn't request this, please ignore this email.</p>
+      `,
+      text: `You requested a password reset. Visit this link to reset your password: ${resetUrl}. This link will expire in 1 hour.`,
+    });
+  }
+}

package/templates/backend-hono/features/swagger/package-additions.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "@hono/zod-openapi": "^0.18.4",
+    "@scalar/hono-api-reference": "^0.5.175"
+  }
+}

package/templates/backend-hono/features/swagger/src/lib/openapi.ts

@@ -0,0 +1,19 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+
+export const app = new OpenAPIHono();
+
+// Add OpenAPI documentation
+app.doc('/openapi.json', {
+  openapi: '3.0.0',
+  info: {
+    version: '0.1.0',
+    title: '__PROJECT_NAME__ API',
+    description: 'API documentation for __PROJECT_NAME__',
+  },
+  servers: [
+    {
+      url: 'http://localhost:__API_PORT__',
+      description: 'Development server',
+    },
+  ],
+});

package/templates/backend-hono/features/swagger/src/routes/docs.route.ts

@@ -0,0 +1,18 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import { apiReference } from '@scalar/hono-api-reference';
+
+const docs = new OpenAPIHono();
+
+// Scalar UI for API documentation
+docs.get(
+  '/',
+  apiReference({
+    spec: {
+      url: '/openapi.json',
+    },
+    theme: 'purple',
+    layout: 'modern',
+  })
+);
+
+export { docs };

package/templates/frontend-nextjs/base/.env.example

@@ -0,0 +1,2 @@
+# API Configuration
+NEXT_PUBLIC_API_URL=__API_URL__

package/templates/frontend-nextjs/base/app/globals.css

@@ -0,0 +1,59 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 222.2 84% 4.9%;
+    --primary: 221.2 83.2% 53.3%;
+    --primary-foreground: 210 40% 98%;
+    --secondary: 210 40% 96.1%;
+    --secondary-foreground: 222.2 47.4% 11.2%;
+    --muted: 210 40% 96.1%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+    --accent: 210 40% 96.1%;
+    --accent-foreground: 222.2 47.4% 11.2%;
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 221.2 83.2% 53.3%;
+    --radius: 0.5rem;
+  }
+
+  .dark {
+    --background: 222.2 84% 4.9%;
+    --foreground: 210 40% 98%;
+    --card: 222.2 84% 4.9%;
+    --card-foreground: 210 40% 98%;
+    --popover: 222.2 84% 4.9%;
+    --popover-foreground: 210 40% 98%;
+    --primary: 217.2 91.2% 59.8%;
+    --primary-foreground: 222.2 47.4% 11.2%;
+    --secondary: 217.2 32.6% 17.5%;
+    --secondary-foreground: 210 40% 98%;
+    --muted: 217.2 32.6% 17.5%;
+    --muted-foreground: 215 20.2% 65.1%;
+    --accent: 217.2 32.6% 17.5%;
+    --accent-foreground: 210 40% 98%;
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 40% 98%;
+    --border: 217.2 32.6% 17.5%;
+    --input: 217.2 32.6% 17.5%;
+    --ring: 224.3 76.3% 48%;
+  }
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}

package/templates/frontend-nextjs/base/app/layout.tsx

@@ -0,0 +1,22 @@
+import type { Metadata } from 'next';
+import { Inter } from 'next/font/google';
+import './globals.css';
+
+const inter = Inter({ subsets: ['latin'] });
+
+export const metadata: Metadata = {
+  title: '__PROJECT_NAME__',
+  description: 'Generated with create-monorepo',
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body className={inter.className}>{children}</body>
+    </html>
+  );
+}

package/templates/frontend-nextjs/base/app/page.tsx

@@ -0,0 +1,49 @@
+export default function Home() {
+  return (
+    <main className="flex min-h-screen flex-col items-center justify-center p-24">
+      <div className="max-w-5xl w-full items-center justify-center font-mono text-sm">
+        <h1 className="text-4xl font-bold text-center mb-8">
+          Welcome to __PROJECT_NAME__
+        </h1>
+        <p className="text-center text-muted-foreground mb-8">
+          Get started by editing <code className="font-mono font-bold">app/page.tsx</code>
+        </p>
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-4 max-w-2xl mx-auto">
+          <a
+            href="https://nextjs.org/docs"
+            target="_blank"
+            rel="noopener noreferrer"
+            className="group rounded-lg border border-transparent px-5 py-4 transition-colors hover:border-gray-300 hover:bg-gray-100 dark:hover:border-neutral-700 dark:hover:bg-neutral-800/30"
+          >
+            <h2 className="mb-3 text-2xl font-semibold">
+              Next.js Docs{' '}
+              <span className="inline-block transition-transform group-hover:translate-x-1 motion-reduce:transform-none">
+                →
+              </span>
+            </h2>
+            <p className="m-0 max-w-[30ch] text-sm opacity-50">
+              Find in-depth information about Next.js features and API.
+            </p>
+          </a>
+
+          <a
+            href="https://ui.shadcn.com"
+            target="_blank"
+            rel="noopener noreferrer"
+            className="group rounded-lg border border-transparent px-5 py-4 transition-colors hover:border-gray-300 hover:bg-gray-100 dark:hover:border-neutral-700 dark:hover:bg-neutral-800/30"
+          >
+            <h2 className="mb-3 text-2xl font-semibold">
+              shadcn/ui{' '}
+              <span className="inline-block transition-transform group-hover:translate-x-1 motion-reduce:transform-none">
+                →
+              </span>
+            </h2>
+            <p className="m-0 max-w-[30ch] text-sm opacity-50">
+              Beautifully designed components built with Radix UI and Tailwind CSS.
+            </p>
+          </a>
+        </div>
+      </div>
+    </main>
+  );
+}

package/templates/frontend-nextjs/base/components.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.ts",
+    "css": "app/globals.css",
+    "baseColor": "slate",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui"
+  }
+}

package/templates/frontend-nextjs/base/lib/api-client.ts

@@ -0,0 +1,67 @@
+import type { ApiResponse } from '__PACKAGE_SCOPE__/shared';
+
+const API_URL = process.env.NEXT_PUBLIC_API_URL || '__API_URL__';
+
+export class ApiClient {
+  private static async request<T>(
+    endpoint: string,
+    options?: RequestInit
+  ): Promise<ApiResponse<T>> {
+    const url = `${API_URL}${endpoint}`;
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          'Content-Type': 'application/json',
+          ...options?.headers,
+        },
+      });
+
+      const data = await response.json();
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || 'Request failed',
+        };
+      }
+
+      return data;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Network error',
+      };
+    }
+  }
+
+  static async get<T>(endpoint: string): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, { method: 'GET' });
+  }
+
+  static async post<T>(endpoint: string, body: unknown): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, {
+      method: 'POST',
+      body: JSON.stringify(body),
+    });
+  }
+
+  static async put<T>(endpoint: string, body: unknown): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, {
+      method: 'PUT',
+      body: JSON.stringify(body),
+    });
+  }
+
+  static async patch<T>(endpoint: string, body: unknown): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, {
+      method: 'PATCH',
+      body: JSON.stringify(body),
+    });
+  }
+
+  static async delete<T>(endpoint: string): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, { method: 'DELETE' });
+  }
+}

package/templates/frontend-nextjs/base/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}