servcraft 0.1.6 → 0.2.0

package/src/cli/commands/init.ts

@@ -6,10 +6,12 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { execSync } from 'child_process';
 import { ensureDir, writeFile, error, warn } from '../utils/helpers.js';
+import { DryRunManager } from '../utils/dry-run.js';
 
 interface InitOptions {
   name: string;
   language: 'typescript' | 'javascript';
+  moduleSystem: 'esm' | 'commonjs';
   database: 'postgresql' | 'mysql' | 'sqlite' | 'mongodb' | 'none';
   orm: 'prisma' | 'mongoose' | 'none';
   validator: 'zod' | 'joi' | 'yup';
@@ -23,12 +25,30 @@ export const initCommand = new Command('init')
   .option('-y, --yes', 'Skip prompts and use defaults')
   .option('--ts, --typescript', 'Use TypeScript (default)')
   .option('--js, --javascript', 'Use JavaScript')
+  .option('--esm', 'Use ES Modules (import/export) - default')
+  .option('--cjs, --commonjs', 'Use CommonJS (require/module.exports)')
   .option('--db <database>', 'Database type (postgresql, mysql, sqlite, mongodb, none)')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(
     async (
       name?: string,
-      cmdOptions?: { yes?: boolean; typescript?: boolean; javascript?: boolean; db?: string }
+      cmdOptions?: {
+        yes?: boolean;
+        typescript?: boolean;
+        javascript?: boolean;
+        esm?: boolean;
+        commonjs?: boolean;
+        db?: string;
+        dryRun?: boolean;
+      }
     ) => {
+      // Enable dry-run mode if specified
+      const dryRun = DryRunManager.getInstance();
+      if (cmdOptions?.dryRun) {
+        dryRun.enable();
+        console.log(chalk.yellow('\n⚠ DRY RUN MODE - No files will be written\n'));
+      }
+
       console.log(
         chalk.blue(`
 ╔═══════════════════════════════════════════╗
@@ -46,6 +66,7 @@ export const initCommand = new Command('init')
         options = {
           name: name || 'my-servcraft-app',
           language: cmdOptions.javascript ? 'javascript' : 'typescript',
+          moduleSystem: cmdOptions.commonjs ? 'commonjs' : 'esm',
           database: db,
           orm: db === 'mongodb' ? 'mongoose' : db === 'none' ? 'none' : 'prisma',
           validator: 'zod',
@@ -75,6 +96,16 @@ export const initCommand = new Command('init')
             ],
             default: 'typescript',
           },
+          {
+            type: 'list',
+            name: 'moduleSystem',
+            message: 'Select module system:',
+            choices: [
+              { name: 'ESM (import/export) - Recommended', value: 'esm' },
+              { name: 'CommonJS (require/module.exports)', value: 'commonjs' },
+            ],
+            default: 'esm',
+          },
           {
             type: 'list',
             name: 'database',
@@ -150,10 +181,10 @@ export const initCommand = new Command('init')
 
         // Generate tsconfig or jsconfig
         if (options.language === 'typescript') {
-          await writeFile(path.join(projectDir, 'tsconfig.json'), generateTsConfig());
-          await writeFile(path.join(projectDir, 'tsup.config.ts'), generateTsupConfig());
+          await writeFile(path.join(projectDir, 'tsconfig.json'), generateTsConfig(options));
+          await writeFile(path.join(projectDir, 'tsup.config.ts'), generateTsupConfig(options));
         } else {
-          await writeFile(path.join(projectDir, 'jsconfig.json'), generateJsConfig());
+          await writeFile(path.join(projectDir, 'jsconfig.json'), generateJsConfig(options));
         }
 
         // Generate .env files
@@ -171,7 +202,10 @@ export const initCommand = new Command('init')
         );
 
         // Create directory structure
-        const ext = options.language === 'typescript' ? 'ts' : 'js';
+        // For JS: .js for ESM, .cjs for CommonJS
+        // For TS: always .ts (output format handled by tsup)
+        const ext =
+          options.language === 'typescript' ? 'ts' : options.moduleSystem === 'esm' ? 'js' : 'cjs';
         const dirs = [
           'src/core',
           'src/config',
@@ -207,6 +241,30 @@ export const initCommand = new Command('init')
           generateLoggerFile(options)
         );
 
+        // Generate config file
+        await writeFile(
+          path.join(projectDir, `src/config/index.${ext}`),
+          generateConfigFile(options)
+        );
+
+        // Generate middleware file
+        await writeFile(
+          path.join(projectDir, `src/middleware/index.${ext}`),
+          generateMiddlewareFile(options)
+        );
+
+        // Generate utils file
+        await writeFile(
+          path.join(projectDir, `src/utils/index.${ext}`),
+          generateUtilsFile(options)
+        );
+
+        // Generate types file
+        await writeFile(
+          path.join(projectDir, `src/types/index.${ext}`),
+          generateTypesFile(options)
+        );
+
         // Generate database files based on ORM choice
         if (options.orm === 'prisma') {
           await writeFile(
@@ -226,19 +284,23 @@ export const initCommand = new Command('init')
 
         spinner.succeed('Project files generated!');
 
-        // Install dependencies
-        const installSpinner = ora('Installing dependencies...').start();
-
-        try {
-          execSync('npm install', { cwd: projectDir, stdio: 'pipe' });
-          installSpinner.succeed('Dependencies installed!');
-        } catch {
-          installSpinner.warn('Failed to install dependencies automatically');
-          warn('  Run "npm install" manually in the project directory');
+        // Install dependencies (skip in dry-run mode)
+        if (!cmdOptions?.dryRun) {
+          const installSpinner = ora('Installing dependencies...').start();
+
+          try {
+            execSync('npm install', { cwd: projectDir, stdio: 'pipe' });
+            installSpinner.succeed('Dependencies installed!');
+          } catch {
+            installSpinner.warn('Failed to install dependencies automatically');
+            warn('  Run "npm install" manually in the project directory');
+          }
         }
 
         // Print success message
-        console.log('\n' + chalk.green('✨ Project created successfully!'));
+        if (!cmdOptions?.dryRun) {
+          console.log('\n' + chalk.green('✨ Project created successfully!'));
+        }
         console.log('\n' + chalk.bold('📁 Project structure:'));
         console.log(`
   ${options.name}/
@@ -269,6 +331,11 @@ export const initCommand = new Command('init')
   ${chalk.yellow('servcraft generate service <name>')}    Generate a service
   ${chalk.yellow('servcraft add auth')}                   Add authentication module
 `);
+
+        // Show dry-run summary if enabled
+        if (cmdOptions?.dryRun) {
+          dryRun.printSummary();
+        }
       } catch (err) {
         spinner.fail('Failed to create project');
         error(err instanceof Error ? err.message : String(err));
@@ -278,19 +345,46 @@ export const initCommand = new Command('init')
 
 function generatePackageJson(options: InitOptions): Record<string, unknown> {
   const isTS = options.language === 'typescript';
+  const isESM = options.moduleSystem === 'esm';
+
+  // Determine dev command based on language and module system
+  let devCommand: string;
+  if (isTS) {
+    devCommand = 'tsx watch src/index.ts';
+  } else if (isESM) {
+    devCommand = 'node --watch src/index.js';
+  } else {
+    devCommand = 'node --watch src/index.cjs';
+  }
+
+  // Determine start command
+  let startCommand: string;
+  if (isTS) {
+    startCommand = isESM ? 'node dist/index.js' : 'node dist/index.cjs';
+  } else if (isESM) {
+    startCommand = 'node src/index.js';
+  } else {
+    startCommand = 'node src/index.cjs';
+  }
 
   const pkg: Record<string, unknown> = {
     name: options.name,
     version: '0.1.0',
     description: 'A Servcraft application',
-    main: isTS ? 'dist/index.js' : 'src/index.js',
-    type: 'module',
+    main: isTS
+      ? isESM
+        ? 'dist/index.js'
+        : 'dist/index.cjs'
+      : isESM
+        ? 'src/index.js'
+        : 'src/index.cjs',
+    ...(isESM && { type: 'module' }),
     scripts: {
-      dev: isTS ? 'tsx watch src/index.ts' : 'node --watch src/index.js',
+      dev: devCommand,
       build: isTS ? 'tsup' : 'echo "No build needed for JS"',
-      start: isTS ? 'node dist/index.js' : 'node src/index.js',
+      start: startCommand,
       test: 'vitest',
-      lint: isTS ? 'eslint src --ext .ts' : 'eslint src --ext .js',
+      lint: isTS ? 'eslint src --ext .ts' : 'eslint src --ext .js,.cjs',
     },
     dependencies: {
       fastify: '^4.28.1',
@@ -361,13 +455,15 @@ function generatePackageJson(options: InitOptions): Record<string, unknown> {
   return pkg;
 }
 
-function generateTsConfig(): string {
+function generateTsConfig(options: InitOptions): string {
+  const isESM = options.moduleSystem === 'esm';
+
   return JSON.stringify(
     {
       compilerOptions: {
         target: 'ES2022',
-        module: 'NodeNext',
-        moduleResolution: 'NodeNext',
+        module: isESM ? 'NodeNext' : 'CommonJS',
+        moduleResolution: isESM ? 'NodeNext' : 'Node',
         lib: ['ES2022'],
         outDir: './dist',
         rootDir: './src',
@@ -387,12 +483,14 @@ function generateTsConfig(): string {
   );
 }
 
-function generateJsConfig(): string {
+function generateJsConfig(options: InitOptions): string {
+  const isESM = options.moduleSystem === 'esm';
+
   return JSON.stringify(
     {
       compilerOptions: {
-        module: 'NodeNext',
-        moduleResolution: 'NodeNext',
+        module: isESM ? 'NodeNext' : 'CommonJS',
+        moduleResolution: isESM ? 'NodeNext' : 'Node',
         target: 'ES2022',
         checkJs: true,
       },
@@ -404,12 +502,14 @@ function generateJsConfig(): string {
   );
 }
 
-function generateTsupConfig(): string {
+function generateTsupConfig(options: InitOptions): string {
+  const isESM = options.moduleSystem === 'esm';
+
   return `import { defineConfig } from 'tsup';
 
 export default defineConfig({
   entry: ['src/index.ts'],
-  format: ['esm'],
+  format: ['${isESM ? 'esm' : 'cjs'}'],
   dts: true,
   clean: true,
   sourcemap: true,
@@ -619,8 +719,13 @@ model User {
 
 function generateEntryFile(options: InitOptions): string {
   const isTS = options.language === 'typescript';
+  const isESM = options.moduleSystem === 'esm';
+  const fileExt = isTS ? 'js' : isESM ? 'js' : 'cjs';
 
-  return `${isTS ? "import 'dotenv/config';\nimport { createServer } from './core/server.js';\nimport { logger } from './core/logger.js';" : "require('dotenv').config();\nconst { createServer } = require('./core/server.js');\nconst { logger } = require('./core/logger.js');"}
+  if (isESM || isTS) {
+    return `import 'dotenv/config';
+import { createServer } from './core/server.${fileExt}';
+import { logger } from './core/logger.${fileExt}';
 
 async function main()${isTS ? ': Promise<void>' : ''} {
   const server = createServer();
@@ -635,22 +740,34 @@ async function main()${isTS ? ': Promise<void>' : ''} {
 
 main();
 `;
+  } else {
+    // CommonJS
+    return `require('dotenv').config();
+const { createServer } = require('./core/server.cjs');
+const { logger } = require('./core/logger.cjs');
+
+async function main() {
+  const server = createServer();
+
+  try {
+    await server.start();
+  } catch (error) {
+    logger.error({ err: error }, 'Failed to start server');
+    process.exit(1);
+  }
+}
+
+main();
+`;
+  }
 }
 
 function generateServerFile(options: InitOptions): string {
   const isTS = options.language === 'typescript';
+  const isESM = options.moduleSystem === 'esm';
+  const fileExt = isTS ? 'js' : isESM ? 'js' : 'cjs';
 
-  return `${
-    isTS
-      ? `import Fastify from 'fastify';
-import type { FastifyInstance } from 'fastify';
-import { logger } from './logger.js';`
-      : `const Fastify = require('fastify');
-const { logger } = require('./logger.js');`
-  }
-
-${isTS ? 'export function createServer(): { instance: FastifyInstance; start: () => Promise<void> }' : 'function createServer()'} {
-  const app = Fastify({ logger });
+  const serverBody = `  const app = Fastify({ logger });
 
   // Health check
   app.get('/health', async () => ({
@@ -677,37 +794,66 @@ ${isTS ? 'export function createServer(): { instance: FastifyInstance; start: ()
       logger.info(\`Server listening on \${host}:\${port}\`);
     },
   };
-}
+}`;
+
+  if (isESM || isTS) {
+    return `import Fastify from 'fastify';
+${isTS ? "import type { FastifyInstance } from 'fastify';" : ''}
+import { logger } from './logger.${fileExt}';
+
+${isTS ? 'export function createServer(): { instance: FastifyInstance; start: () => Promise<void> }' : 'export function createServer()'} {
+${serverBody}
+`;
+  } else {
+    // CommonJS
+    return `const Fastify = require('fastify');
+const { logger } = require('./logger.cjs');
 
-${isTS ? '' : 'module.exports = { createServer };'}
+function createServer() {
+${serverBody}
+
+module.exports = { createServer };
 `;
+  }
 }
 
 function generateLoggerFile(options: InitOptions): string {
   const isTS = options.language === 'typescript';
+  const isESM = options.moduleSystem === 'esm';
 
-  return `${isTS ? "import pino from 'pino';\nimport type { Logger } from 'pino';" : "const pino = require('pino');"}
-
-${isTS ? 'export const logger: Logger' : 'const logger'} = pino({
+  const loggerBody = `pino({
   level: process.env.LOG_LEVEL || 'info',
   transport: process.env.NODE_ENV !== 'production' ? {
     target: 'pino-pretty',
     options: { colorize: true },
   } : undefined,
-});
+})`;
+
+  if (isESM || isTS) {
+    return `import pino from 'pino';
+${isTS ? "import type { Logger } from 'pino';" : ''}
 
-${isTS ? '' : 'module.exports = { logger };'}
+export const logger${isTS ? ': Logger' : ''} = ${loggerBody};
 `;
+  } else {
+    // CommonJS
+    return `const pino = require('pino');
+
+const logger = ${loggerBody};
+
+module.exports = { logger };
+`;
+  }
 }
 
 function generateMongooseConnection(options: InitOptions): string {
   const isTS = options.language === 'typescript';
+  const isESM = options.moduleSystem === 'esm';
+  const fileExt = isTS ? 'js' : isESM ? 'js' : 'cjs';
 
-  return `${isTS ? "import mongoose from 'mongoose';\nimport { logger } from '../core/logger.js';" : "const mongoose = require('mongoose');\nconst { logger } = require('../core/logger.js');"}
+  const connectionBody = `const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/mydb';
 
-const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/mydb';
-
-${isTS ? 'export async function connectDatabase(): Promise<typeof mongoose>' : 'async function connectDatabase()'} {
+async function connectDatabase()${isTS ? ': Promise<typeof mongoose>' : ''} {
   try {
     const conn = await mongoose.connect(MONGODB_URI);
     logger.info(\`MongoDB connected: \${conn.connection.host}\`);
@@ -718,41 +864,40 @@ ${isTS ? 'export async function connectDatabase(): Promise<typeof mongoose>' : '
   }
 }
 
-${isTS ? 'export async function disconnectDatabase(): Promise<void>' : 'async function disconnectDatabase()'} {
+async function disconnectDatabase()${isTS ? ': Promise<void>' : ''} {
   try {
     await mongoose.disconnect();
     logger.info('MongoDB disconnected');
   } catch (error) {
     logger.error({ err: error }, 'MongoDB disconnect failed');
   }
-}
+}`;
 
-${isTS ? 'export { mongoose };' : 'module.exports = { connectDatabase, disconnectDatabase, mongoose };'}
+  if (isESM || isTS) {
+    return `import mongoose from 'mongoose';
+import { logger } from '../core/logger.${fileExt}';
+
+${connectionBody}
+
+export { connectDatabase, disconnectDatabase, mongoose };
+`;
+  } else {
+    // CommonJS
+    return `const mongoose = require('mongoose');
+const { logger } = require('../core/logger.cjs');
+
+${connectionBody}
+
+module.exports = { connectDatabase, disconnectDatabase, mongoose };
 `;
+  }
 }
 
 function generateMongooseUserModel(options: InitOptions): string {
   const isTS = options.language === 'typescript';
+  const isESM = options.moduleSystem === 'esm';
 
-  return `${isTS ? "import mongoose, { Schema, Document } from 'mongoose';\nimport bcrypt from 'bcryptjs';" : "const mongoose = require('mongoose');\nconst bcrypt = require('bcryptjs');\nconst { Schema } = mongoose;"}
-
-${
-  isTS
-    ? `export interface IUser extends Document {
-  email: string;
-  password: string;
-  name?: string;
-  role: 'user' | 'admin';
-  status: 'active' | 'inactive' | 'suspended';
-  emailVerified: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-  comparePassword(candidatePassword: string): Promise<boolean>;
-}`
-    : ''
-}
-
-const userSchema = new Schema${isTS ? '<IUser>' : ''}({
+  const schemaBody = `const userSchema = new Schema${isTS ? '<IUser>' : ''}({
   email: {
     type: String,
     required: true,
@@ -803,8 +948,258 @@ userSchema.pre('save', async function(next) {
 // Compare password method
 userSchema.methods.comparePassword = async function(candidatePassword${isTS ? ': string' : ''})${isTS ? ': Promise<boolean>' : ''} {
   return bcrypt.compare(candidatePassword, this.password);
-};
+};`;
+
+  const tsInterface = isTS
+    ? `
+export interface IUser extends Document {
+  email: string;
+  password: string;
+  name?: string;
+  role: 'user' | 'admin';
+  status: 'active' | 'inactive' | 'suspended';
+  emailVerified: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  comparePassword(candidatePassword: string): Promise<boolean>;
+}
+`
+    : '';
+
+  if (isESM || isTS) {
+    return `import mongoose${isTS ? ', { Schema, Document }' : ''} from 'mongoose';
+import bcrypt from 'bcryptjs';
+${!isTS ? 'const { Schema } = mongoose;' : ''}
+${tsInterface}
+${schemaBody}
+
+export const User = mongoose.model${isTS ? '<IUser>' : ''}('User', userSchema);
+`;
+  } else {
+    // CommonJS
+    return `const mongoose = require('mongoose');
+const bcrypt = require('bcryptjs');
+const { Schema } = mongoose;
+
+${schemaBody}
+
+const User = mongoose.model('User', userSchema);
+
+module.exports = { User };
+`;
+  }
+}
+
+function generateConfigFile(options: InitOptions): string {
+  const isTS = options.language === 'typescript';
+  const isESM = options.moduleSystem === 'esm';
+
+  const configBody = `{
+  env: process.env.NODE_ENV || 'development',
+  port: parseInt(process.env.PORT || '3000', 10),
+  host: process.env.HOST || '0.0.0.0',
+
+  jwt: {
+    secret: process.env.JWT_SECRET || 'your-secret-key',
+    accessExpiresIn: process.env.JWT_ACCESS_EXPIRES_IN || '15m',
+    refreshExpiresIn: process.env.JWT_REFRESH_EXPIRES_IN || '7d',
+  },
 
-${isTS ? "export const User = mongoose.model<IUser>('User', userSchema);" : "const User = mongoose.model('User', userSchema);\nmodule.exports = { User };"}
+  cors: {
+    origin: process.env.CORS_ORIGIN || 'http://localhost:3000',
+  },
+
+  rateLimit: {
+    max: parseInt(process.env.RATE_LIMIT_MAX || '100', 10),
+  },
+
+  log: {
+    level: process.env.LOG_LEVEL || 'info',
+  },
+}${isTS ? ' as const' : ''}`;
+
+  if (isESM || isTS) {
+    return `import 'dotenv/config';
+
+export const config = ${configBody};
+`;
+  } else {
+    // CommonJS
+    return `require('dotenv').config();
+
+const config = ${configBody};
+
+module.exports = { config };
+`;
+  }
+}
+
+function generateMiddlewareFile(options: InitOptions): string {
+  const isTS = options.language === 'typescript';
+  const isESM = options.moduleSystem === 'esm';
+  const fileExt = isTS ? 'js' : isESM ? 'js' : 'cjs';
+
+  const middlewareBody = `/**
+ * Error handler middleware
+ */
+function errorHandler(error${isTS ? ': Error' : ''}, request${isTS ? ': FastifyRequest' : ''}, reply${isTS ? ': FastifyReply' : ''})${isTS ? ': void' : ''} {
+  logger.error({ err: error, url: request.url, method: request.method }, 'Request error');
+
+  const statusCode = (error${isTS ? ' as any' : ''}).statusCode || 500;
+  const message = statusCode === 500 ? 'Internal Server Error' : error.message;
+
+  reply.status(statusCode).send({
+    success: false,
+    error: message,
+    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
+  });
+}
+
+/**
+ * Request logging middleware
+ */
+function requestLogger(request${isTS ? ': FastifyRequest' : ''}, reply${isTS ? ': FastifyReply' : ''}, done${isTS ? ': () => void' : ''})${isTS ? ': void' : ''} {
+  logger.info({ url: request.url, method: request.method, ip: request.ip }, 'Incoming request');
+  done();
+}`;
+
+  if (isESM || isTS) {
+    return `${isTS ? "import type { FastifyRequest, FastifyReply } from 'fastify';" : ''}
+import { logger } from '../core/logger.${fileExt}';
+
+${middlewareBody}
+
+export { errorHandler, requestLogger };
+`;
+  } else {
+    // CommonJS
+    return `const { logger } = require('../core/logger.cjs');
+
+${middlewareBody}
+
+module.exports = { errorHandler, requestLogger };
+`;
+  }
+}
+
+function generateUtilsFile(options: InitOptions): string {
+  const isTS = options.language === 'typescript';
+  const isESM = options.moduleSystem === 'esm';
+
+  const utilsBody = `/**
+ * Standard API response helper
+ */
+function apiResponse${isTS ? '<T>' : ''}(data${isTS ? ': T' : ''}, message = "Success")${isTS ? ': { success: boolean; message: string; data: T }' : ''} {
+  return {
+    success: true,
+    message,
+    data,
+  };
+}
+
+/**
+ * Error response helper
+ */
+function errorResponse(message${isTS ? ': string' : ''}, code${isTS ? '?: string' : ''})${isTS ? ': { success: boolean; error: string; code?: string }' : ''} {
+  return {
+    success: false,
+    error: message,
+    ...(code && { code }),
+  };
+}
+
+/**
+ * Pagination helper
+ */
+function paginate${isTS ? '<T>' : ''}(data${isTS ? ': T[]' : ''}, page${isTS ? ': number' : ''}, limit${isTS ? ': number' : ''}, total${isTS ? ': number' : ''})${isTS ? ': PaginationResult<T>' : ''} {
+  const totalPages = Math.ceil(total / limit);
+
+  return {
+    data,
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages,
+      hasNextPage: page < totalPages,
+      hasPrevPage: page > 1,
+    },
+  };
+}`;
+
+  const tsInterface = isTS
+    ? `
+/**
+ * Pagination result type
+ */
+export interface PaginationResult<T> {
+  data: T[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+  };
+}
+`
+    : '';
+
+  if (isESM || isTS) {
+    return `${tsInterface}
+${utilsBody}
+
+export { apiResponse, errorResponse, paginate };
+`;
+  } else {
+    // CommonJS
+    return `${utilsBody}
+
+module.exports = { apiResponse, errorResponse, paginate };
+`;
+  }
+}
+
+function generateTypesFile(options: InitOptions): string {
+  if (options.language !== 'typescript') {
+    return '// Types file - not needed for JavaScript\n';
+  }
+
+  return `/**
+ * Common type definitions
+ */
+
+export interface ApiResponse<T = unknown> {
+  success: boolean;
+  message?: string;
+  data?: T;
+  error?: string;
+  code?: string;
+}
+
+export interface PaginatedResponse<T> {
+  data: T[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+  };
+}
+
+export interface RequestUser {
+  id: string;
+  email: string;
+  role: string;
+}
+
+declare module 'fastify' {
+  interface FastifyRequest {
+    user?: RequestUser;
+  }
+}
 `;
 }