@yoms/create-monorepo 1.0.2

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@yoms/create-monorepo",
+  "version": "1.0.2",
+  "description": "CLI tool to scaffold monorepo projects from templates",
+  "type": "module",
+  "bin": {
+    "create-monorepo": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --clean",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "test:generate": "tsx scripts/test-generate.ts",
+    "test:validate": "tsx scripts/validate-templates.ts",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "pnpm build && changeset publish",
+    "prepublishOnly": "pnpm build && pnpm typecheck"
+  },
+  "keywords": [
+    "monorepo",
+    "template",
+    "scaffold",
+    "cli",
+    "pnpm",
+    "workspace",
+    "typescript",
+    "hono",
+    "nextjs",
+    "prisma",
+    "generator",
+    "boilerplate",
+    "starter"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yoms07/monorepo-template.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yoms07/monorepo-template/issues"
+  },
+  "homepage": "https://github.com/yoms07/monorepo-template#readme",
+  "files": [
+    "dist",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "cac": "^6.7.14",
+    "chalk": "^5.3.0",
+    "enquirer": "^2.4.1",
+    "execa": "^9.5.2",
+    "fs-extra": "^11.2.0",
+    "ora": "^8.1.1",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.10",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.10.5",
+    "prettier": "^3.4.2",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/backend-hono/base/.env.example

@@ -0,0 +1,7 @@
+# Server Configuration
+NODE_ENV=development
+PORT=__API_PORT__
+LOG_LEVEL=info
+
+# CORS Configuration
+CORS_ORIGIN=http://localhost:__WEB_PORT__

package/templates/backend-hono/base/Dockerfile

@@ -0,0 +1,55 @@
+FROM node:20-alpine AS base
+
+# Install pnpm
+RUN corepack enable && corepack prepare pnpm@latest --activate
+
+# Build stage
+FROM base AS build
+
+WORKDIR /app
+
+# Copy workspace configuration
+COPY pnpm-workspace.yaml package.json pnpm-lock.yaml ./
+
+# Copy package.json files for all workspaces
+COPY packages/api/package.json ./packages/api/
+COPY packages/shared/package.json ./packages/shared/
+
+# Install dependencies
+RUN pnpm install --frozen-lockfile
+
+# Copy source code
+COPY packages/api ./packages/api
+COPY packages/shared ./packages/shared
+
+# Build shared package first, then api
+RUN pnpm --filter __PACKAGE_SCOPE__/shared build && \
+    pnpm --filter __PACKAGE_SCOPE__/api build
+
+# Production stage
+FROM base AS production
+
+WORKDIR /app
+
+ENV NODE_ENV=production
+
+# Copy workspace configuration
+COPY pnpm-workspace.yaml package.json pnpm-lock.yaml ./
+COPY packages/api/package.json ./packages/api/
+COPY packages/shared/package.json ./packages/shared/
+
+# Install production dependencies only
+RUN pnpm install --prod --frozen-lockfile
+
+# Copy built files from build stage
+COPY --from=build /app/packages/shared/dist ./packages/shared/dist
+COPY --from=build /app/packages/api/dist ./packages/api/dist
+
+# Set working directory to api package
+WORKDIR /app/packages/api
+
+# Expose port
+EXPOSE __API_PORT__
+
+# Start
+CMD ["node", "dist/index.js"]

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

@@ -0,0 +1,30 @@
+{
+  "name": "__PACKAGE_SCOPE__/api",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsup src/index.ts --format esm --clean",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\""
+  },
+  "dependencies": {
+    "hono": "^4.6.14",
+    "zod": "^3.24.1",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "@vitest/coverage-v8": "^2.1.8",
+    "tsx": "^4.19.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}

package/templates/backend-hono/base/src/config/env.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  PORT: z.coerce.number().default(__API_PORT__),
+  LOG_LEVEL: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+  CORS_ORIGIN: z.string().default('http://localhost:__WEB_PORT__'),
+});
+
+export const env = envSchema.parse(process.env);
+
+export type Env = z.infer<typeof envSchema>;

package/templates/backend-hono/base/src/config/logger.ts

@@ -0,0 +1,52 @@
+import winston from 'winston';
+import { env } from './env.js';
+
+const { combine, timestamp, printf, colorize, errors } = winston.format;
+
+// Custom format for development
+const devFormat = printf(({ level, message, timestamp, stack, ...metadata }) => {
+  let msg = `${timestamp} [${level}]: ${message}`;
+
+  // Add metadata if present
+  const metaStr = Object.keys(metadata).length > 0
+    ? `\n${JSON.stringify(metadata, null, 2)}`
+    : '';
+
+  // Add stack trace if error
+  const stackStr = stack ? `\n${stack}` : '';
+
+  return msg + metaStr + stackStr;
+});
+
+// Custom format for production (JSON)
+const prodFormat = combine(
+  errors({ stack: true }),
+  timestamp(),
+  winston.format.json()
+);
+
+const logger = winston.createLogger({
+  level: env.LOG_LEVEL,
+  format: env.NODE_ENV === 'production' ? prodFormat : combine(
+    colorize(),
+    timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    errors({ stack: true }),
+    devFormat
+  ),
+  transports: [
+    new winston.transports.Console(),
+  ],
+});
+
+// Add file transport in production
+if (env.NODE_ENV === 'production') {
+  logger.add(new winston.transports.File({
+    filename: 'logs/error.log',
+    level: 'error'
+  }));
+  logger.add(new winston.transports.File({
+    filename: 'logs/combined.log'
+  }));
+}
+
+export { logger };

package/templates/backend-hono/base/src/index.ts

@@ -0,0 +1,49 @@
+import { Hono } from 'hono';
+import { env } from './config/env.js';
+import { logger } from './config/logger.js';
+import { corsMiddleware } from './middleware/cors.middleware.js';
+import { loggerMiddleware } from './middleware/logger.middleware.js';
+import { errorHandler } from './middleware/error.middleware.js';
+import { health } from './routes/health.route.js';
+
+const app = new Hono();
+
+// Global middleware
+app.use('*', corsMiddleware);
+app.use('*', loggerMiddleware);
+
+// Routes
+app.route('/health', health);
+
+// Root endpoint
+app.get('/', (c) => {
+  return c.json({
+    success: true,
+    message: 'Welcome to __PROJECT_NAME__ API',
+    version: '0.1.0',
+  });
+});
+
+// Error handling
+app.onError(errorHandler);
+
+// 404 handler
+app.notFound((c) => {
+  return c.json({
+    success: false,
+    error: 'Not found',
+    message: `Route ${c.req.method} ${c.req.url} not found`,
+  }, 404);
+});
+
+// Start server
+const port = env.PORT;
+
+logger.info(`Starting server in ${env.NODE_ENV} mode...`);
+
+export default {
+  port,
+  fetch: app.fetch,
+};
+
+console.log(`Server running on http://localhost:${port}`);

package/templates/backend-hono/base/src/lib/__tests__/response.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { Hono } from 'hono';
+import { success, created, noContent, paginated, error } from '../response.js';
+
+describe('Response Helpers', () => {
+  const app = new Hono();
+
+  app.get('/success', (c) => success(c, { message: 'OK' }));
+  app.post('/created', (c) => created(c, { id: '123' }));
+  app.delete('/no-content', (c) => noContent(c));
+  app.get('/paginated', (c) =>
+    paginated(c, [{ id: 1 }, { id: 2 }], 1, 10, 25)
+  );
+  app.get('/error', (c) => error(c, 'Something failed', 400, 'BAD_REQUEST'));
+
+  it('should return success response with 200', async () => {
+    const res = await app.request('/success');
+    expect(res.status).toBe(200);
+
+    const json = await res.json();
+    expect(json.success).toBe(true);
+    expect(json.data).toEqual({ message: 'OK' });
+  });
+
+  it('should return created response with 201', async () => {
+    const res = await app.request('/created', { method: 'POST' });
+    expect(res.status).toBe(201);
+
+    const json = await res.json();
+    expect(json.success).toBe(true);
+    expect(json.data).toEqual({ id: '123' });
+  });
+
+  it('should return no content with 204', async () => {
+    const res = await app.request('/no-content', { method: 'DELETE' });
+    expect(res.status).toBe(204);
+    expect(res.body).toBeNull();
+  });
+
+  it('should return paginated response', async () => {
+    const res = await app.request('/paginated');
+    expect(res.status).toBe(200);
+
+    const json = await res.json();
+    expect(json.success).toBe(true);
+    expect(json.data).toHaveLength(2);
+    expect(json.pagination).toEqual({
+      page: 1,
+      limit: 10,
+      total: 25,
+      totalPages: 3,
+      hasNext: true,
+      hasPrev: false,
+    });
+  });
+
+  it('should return error response', async () => {
+    const res = await app.request('/error');
+    expect(res.status).toBe(400);
+
+    const json = await res.json();
+    expect(json.success).toBe(false);
+    expect(json.error).toBe('Something failed');
+    expect(json.code).toBe('BAD_REQUEST');
+  });
+});

package/templates/backend-hono/base/src/lib/errors.ts

@@ -0,0 +1,87 @@
+/**
+ * Base application error class
+ */
+export class AppError extends Error {
+  constructor(
+    message: string,
+    public statusCode: number = 500,
+    public code?: string,
+    public details?: unknown
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * 400 Bad Request
+ */
+export class BadRequestError extends AppError {
+  constructor(message: string = 'Bad request', details?: unknown) {
+    super(message, 400, 'BAD_REQUEST', details);
+  }
+}
+
+/**
+ * 401 Unauthorized
+ */
+export class UnauthorizedError extends AppError {
+  constructor(message: string = 'Unauthorized', details?: unknown) {
+    super(message, 401, 'UNAUTHORIZED', details);
+  }
+}
+
+/**
+ * 403 Forbidden
+ */
+export class ForbiddenError extends AppError {
+  constructor(message: string = 'Forbidden', details?: unknown) {
+    super(message, 403, 'FORBIDDEN', details);
+  }
+}
+
+/**
+ * 404 Not Found
+ */
+export class NotFoundError extends AppError {
+  constructor(message: string = 'Resource not found', details?: unknown) {
+    super(message, 404, 'NOT_FOUND', details);
+  }
+}
+
+/**
+ * 409 Conflict
+ */
+export class ConflictError extends AppError {
+  constructor(message: string = 'Resource already exists', details?: unknown) {
+    super(message, 409, 'CONFLICT', details);
+  }
+}
+
+/**
+ * 422 Unprocessable Entity
+ */
+export class ValidationError extends AppError {
+  constructor(message: string = 'Validation failed', details?: unknown) {
+    super(message, 422, 'VALIDATION_ERROR', details);
+  }
+}
+
+/**
+ * 429 Too Many Requests
+ */
+export class TooManyRequestsError extends AppError {
+  constructor(message: string = 'Too many requests', details?: unknown) {
+    super(message, 429, 'TOO_MANY_REQUESTS', details);
+  }
+}
+
+/**
+ * 500 Internal Server Error
+ */
+export class InternalServerError extends AppError {
+  constructor(message: string = 'Internal server error', details?: unknown) {
+    super(message, 500, 'INTERNAL_SERVER_ERROR', details);
+  }
+}

package/templates/backend-hono/base/src/lib/response.ts

@@ -0,0 +1,72 @@
+import type { Context } from 'hono';
+import type { StatusCode } from 'hono/utils/http-status';
+import type { ApiResponse } from '../types/app.types.js';
+
+/**
+ * Success response helper
+ */
+export function success<T>(c: Context, data: T, statusCode: StatusCode = 200) {
+  const response: ApiResponse<T> = {
+    success: true,
+    data,
+  };
+  return c.json(response, statusCode);
+}
+
+/**
+ * Error response helper
+ */
+export function error(
+  c: Context,
+  message: string,
+  statusCode: StatusCode = 500,
+  code?: string,
+  details?: unknown
+) {
+  const response: ApiResponse = {
+    success: false,
+    error: message,
+    code,
+    details: process.env.NODE_ENV === 'development' ? details : undefined,
+  };
+  return c.json(response, statusCode);
+}
+
+/**
+ * Created response (201)
+ */
+export function created<T>(c: Context, data: T) {
+  return success(c, data, 201);
+}
+
+/**
+ * No content response (204)
+ */
+export function noContent(c: Context) {
+  return c.body(null, 204);
+}
+
+/**
+ * Paginated response helper
+ */
+export function paginated<T>(
+  c: Context,
+  data: T[],
+  page: number,
+  limit: number,
+  total: number
+) {
+  const response = {
+    success: true,
+    data,
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages: Math.ceil(total / limit),
+      hasNext: page * limit < total,
+      hasPrev: page > 1,
+    },
+  };
+  return c.json(response);
+}

package/templates/backend-hono/base/src/middleware/__tests__/error.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Hono } from 'hono';
+import { errorHandler } from '../error.middleware.js';
+import {
+  BadRequestError,
+  NotFoundError,
+  UnauthorizedError,
+  InternalServerError,
+} from '../../lib/errors.js';
+
+describe('Error Middleware', () => {
+  const app = new Hono();
+
+  // Test route that throws errors
+  app.get('/bad-request', () => {
+    throw new BadRequestError('Invalid input');
+  });
+
+  app.get('/not-found', () => {
+    throw new NotFoundError('Resource not found');
+  });
+
+  app.get('/unauthorized', () => {
+    throw new UnauthorizedError('Not authenticated');
+  });
+
+  app.get('/server-error', () => {
+    throw new InternalServerError('Something went wrong');
+  });
+
+  app.get('/unknown-error', () => {
+    throw new Error('Unknown error');
+  });
+
+  app.onError(errorHandler);
+
+  it('should handle BadRequestError with 400 status', async () => {
+    const res = await app.request('/bad-request');
+    expect(res.status).toBe(400);
+
+    const json = await res.json();
+    expect(json.success).toBe(false);
+    expect(json.error).toBe('Invalid input');
+    expect(json.code).toBe('BAD_REQUEST');
+  });
+
+  it('should handle NotFoundError with 404 status', async () => {
+    const res = await app.request('/not-found');
+    expect(res.status).toBe(404);
+
+    const json = await res.json();
+    expect(json.success).toBe(false);
+    expect(json.error).toBe('Resource not found');
+    expect(json.code).toBe('NOT_FOUND');
+  });
+
+  it('should handle UnauthorizedError with 401 status', async () => {
+    const res = await app.request('/unauthorized');
+    expect(res.status).toBe(401);
+
+    const json = await res.json();
+    expect(json.success).toBe(false);
+    expect(json.error).toBe('Not authenticated');
+    expect(json.code).toBe('UNAUTHORIZED');
+  });
+
+  it('should handle InternalServerError with 500 status', async () => {
+    const res = await app.request('/server-error');
+    expect(res.status).toBe(500);
+
+    const json = await res.json();
+    expect(json.success).toBe(false);
+    expect(json.error).toBe('Something went wrong');
+    expect(json.code).toBe('INTERNAL_SERVER_ERROR');
+  });
+
+  it('should handle unknown errors with 500 status', async () => {
+    const res = await app.request('/unknown-error');
+    expect(res.status).toBe(500);
+
+    const json = await res.json();
+    expect(json.success).toBe(false);
+    expect(json.error).toBe('Internal server error');
+    expect(json.code).toBe('INTERNAL_SERVER_ERROR');
+  });
+});

package/templates/backend-hono/base/src/middleware/cors.middleware.ts

@@ -0,0 +1,9 @@
+import { cors } from 'hono/cors';
+import { env } from '../config/env.js';
+
+export const corsMiddleware = cors({
+  origin: env.CORS_ORIGIN.split(',').map(o => o.trim()),
+  allowMethods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  allowHeaders: ['Content-Type', 'Authorization'],
+  credentials: true,
+});

package/templates/backend-hono/base/src/middleware/error.middleware.ts

@@ -0,0 +1,43 @@
+import type { Context } from 'hono';
+import { logger } from '../config/logger.js';
+import { AppError } from '../lib/errors.js';
+import type { ApiResponse } from '../types/app.types.js';
+
+export function errorHandler(error: Error, c: Context) {
+  // Handle known application errors
+  if (error instanceof AppError) {
+    logger.warn('Application error:', {
+      code: error.code,
+      message: error.message,
+      statusCode: error.statusCode,
+      path: c.req.path,
+      method: c.req.method,
+    });
+
+    const response: ApiResponse = {
+      success: false,
+      error: error.message,
+      code: error.code,
+      details: process.env.NODE_ENV === 'development' ? error.details : undefined,
+    };
+
+    return c.json(response, error.statusCode);
+  }
+
+  // Handle unknown errors
+  logger.error('Unhandled error:', {
+    error: error.message,
+    stack: error.stack,
+    path: c.req.path,
+    method: c.req.method,
+  });
+
+  const response: ApiResponse = {
+    success: false,
+    error: 'Internal server error',
+    code: 'INTERNAL_SERVER_ERROR',
+    message: process.env.NODE_ENV === 'development' ? error.message : undefined,
+  };
+
+  return c.json(response, 500);
+}

package/templates/backend-hono/base/src/middleware/logger.middleware.ts

@@ -0,0 +1,14 @@
+import type { Context, Next } from 'hono';
+import { logger } from '../config/logger.js';
+
+export async function loggerMiddleware(c: Context, next: Next) {
+  const start = Date.now();
+  const { method, url } = c.req;
+
+  await next();
+
+  const duration = Date.now() - start;
+  const status = c.res.status;
+
+  logger.info(`${method} ${url} ${status} - ${duration}ms`);
+}