servcraft 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,3945 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command6 } from "commander";
+
+// src/cli/commands/init.ts
+import { Command } from "commander";
+import path2 from "path";
+import fs2 from "fs/promises";
+import ora from "ora";
+import inquirer from "inquirer";
+import chalk2 from "chalk";
+import { execSync } from "child_process";
+
+// src/cli/utils/helpers.ts
+import fs from "fs/promises";
+import path from "path";
+import chalk from "chalk";
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function pluralize(str) {
+  if (str.endsWith("y")) {
+    return str.slice(0, -1) + "ies";
+  }
+  if (str.endsWith("s") || str.endsWith("x") || str.endsWith("ch") || str.endsWith("sh")) {
+    return str + "es";
+  }
+  return str + "s";
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function writeFile(filePath, content) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+function success(message) {
+  console.log(chalk.green("\u2713"), message);
+}
+function error(message) {
+  console.error(chalk.red("\u2717"), message);
+}
+function warn(message) {
+  console.log(chalk.yellow("\u26A0"), message);
+}
+function info(message) {
+  console.log(chalk.blue("\u2139"), message);
+}
+function getProjectRoot() {
+  return process.cwd();
+}
+function getSourceDir() {
+  return path.join(getProjectRoot(), "src");
+}
+function getModulesDir() {
+  return path.join(getSourceDir(), "modules");
+}
+
+// src/cli/commands/init.ts
+var initCommand = new Command("init").alias("new").description("Initialize a new Servcraft project").argument("[name]", "Project name").option("-y, --yes", "Skip prompts and use defaults").option("--ts, --typescript", "Use TypeScript (default)").option("--js, --javascript", "Use JavaScript").option("--db <database>", "Database type (postgresql, mysql, sqlite, mongodb, none)").action(async (name, cmdOptions) => {
+  console.log(chalk2.blue(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                           \u2551
+\u2551   ${chalk2.bold("\u{1F680} Servcraft Project Generator")}          \u2551
+\u2551                                           \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`));
+  let options;
+  if (cmdOptions?.yes) {
+    options = {
+      name: name || "my-servcraft-app",
+      language: cmdOptions.javascript ? "javascript" : "typescript",
+      database: cmdOptions.db || "postgresql",
+      validator: "zod",
+      features: ["auth", "users", "email"]
+    };
+  } else {
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Project name:",
+        default: name || "my-servcraft-app",
+        validate: (input) => {
+          if (!/^[a-z0-9-_]+$/i.test(input)) {
+            return "Project name can only contain letters, numbers, hyphens, and underscores";
+          }
+          return true;
+        }
+      },
+      {
+        type: "list",
+        name: "language",
+        message: "Select language:",
+        choices: [
+          { name: "TypeScript (Recommended)", value: "typescript" },
+          { name: "JavaScript", value: "javascript" }
+        ],
+        default: "typescript"
+      },
+      {
+        type: "list",
+        name: "database",
+        message: "Select database:",
+        choices: [
+          { name: "PostgreSQL (Recommended)", value: "postgresql" },
+          { name: "MySQL", value: "mysql" },
+          { name: "SQLite (Development)", value: "sqlite" },
+          { name: "MongoDB", value: "mongodb" },
+          { name: "None (Add later)", value: "none" }
+        ],
+        default: "postgresql"
+      },
+      {
+        type: "list",
+        name: "validator",
+        message: "Select validation library:",
+        choices: [
+          { name: "Zod (Recommended - TypeScript-first)", value: "zod" },
+          { name: "Joi (Battle-tested, feature-rich)", value: "joi" },
+          { name: "Yup (Inspired by Joi, lighter)", value: "yup" }
+        ],
+        default: "zod"
+      },
+      {
+        type: "checkbox",
+        name: "features",
+        message: "Select features to include:",
+        choices: [
+          { name: "Authentication (JWT)", value: "auth", checked: true },
+          { name: "User Management", value: "users", checked: true },
+          { name: "Email Service", value: "email", checked: true },
+          { name: "Audit Logs", value: "audit", checked: false },
+          { name: "File Upload", value: "upload", checked: false },
+          { name: "Redis Cache", value: "redis", checked: false }
+        ]
+      }
+    ]);
+    options = answers;
+  }
+  const projectDir = path2.resolve(process.cwd(), options.name);
+  const spinner = ora("Creating project...").start();
+  try {
+    try {
+      await fs2.access(projectDir);
+      spinner.stop();
+      error(`Directory "${options.name}" already exists`);
+      return;
+    } catch {
+    }
+    await ensureDir(projectDir);
+    spinner.text = "Generating project files...";
+    const packageJson = generatePackageJson(options);
+    await writeFile(path2.join(projectDir, "package.json"), JSON.stringify(packageJson, null, 2));
+    if (options.language === "typescript") {
+      await writeFile(path2.join(projectDir, "tsconfig.json"), generateTsConfig());
+      await writeFile(path2.join(projectDir, "tsup.config.ts"), generateTsupConfig());
+    } else {
+      await writeFile(path2.join(projectDir, "jsconfig.json"), generateJsConfig());
+    }
+    await writeFile(path2.join(projectDir, ".env.example"), generateEnvExample(options));
+    await writeFile(path2.join(projectDir, ".env"), generateEnvExample(options));
+    await writeFile(path2.join(projectDir, ".gitignore"), generateGitignore());
+    await writeFile(path2.join(projectDir, "Dockerfile"), generateDockerfile(options));
+    await writeFile(path2.join(projectDir, "docker-compose.yml"), generateDockerCompose(options));
+    const ext = options.language === "typescript" ? "ts" : "js";
+    const dirs = [
+      "src/core",
+      "src/config",
+      "src/modules",
+      "src/middleware",
+      "src/utils",
+      "src/types",
+      "tests/unit",
+      "tests/integration"
+    ];
+    if (options.database !== "none" && options.database !== "mongodb") {
+      dirs.push("prisma");
+    }
+    for (const dir of dirs) {
+      await ensureDir(path2.join(projectDir, dir));
+    }
+    await writeFile(
+      path2.join(projectDir, `src/index.${ext}`),
+      generateEntryFile(options)
+    );
+    await writeFile(
+      path2.join(projectDir, `src/core/server.${ext}`),
+      generateServerFile(options)
+    );
+    await writeFile(
+      path2.join(projectDir, `src/core/logger.${ext}`),
+      generateLoggerFile(options)
+    );
+    if (options.database !== "none" && options.database !== "mongodb") {
+      await writeFile(
+        path2.join(projectDir, "prisma/schema.prisma"),
+        generatePrismaSchema(options)
+      );
+    }
+    spinner.succeed("Project files generated!");
+    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');
+    }
+    console.log("\n" + chalk2.green("\u2728 Project created successfully!"));
+    console.log("\n" + chalk2.bold("\u{1F4C1} Project structure:"));
+    console.log(`
+  ${options.name}/
+  \u251C\u2500\u2500 src/
+  \u2502   \u251C\u2500\u2500 core/           # Core server, logger
+  \u2502   \u251C\u2500\u2500 config/         # Configuration
+  \u2502   \u251C\u2500\u2500 modules/        # Feature modules
+  \u2502   \u251C\u2500\u2500 middleware/     # Middlewares
+  \u2502   \u251C\u2500\u2500 utils/          # Utilities
+  \u2502   \u2514\u2500\u2500 index.${ext}       # Entry point
+  \u251C\u2500\u2500 tests/              # Tests
+  \u251C\u2500\u2500 prisma/             # Database schema
+  \u251C\u2500\u2500 docker-compose.yml
+  \u2514\u2500\u2500 package.json
+`);
+    console.log(chalk2.bold("\u{1F680} Get started:"));
+    console.log(`
+  ${chalk2.cyan(`cd ${options.name}`)}
+  ${options.database !== "none" ? chalk2.cyan("npm run db:push        # Setup database") : ""}
+  ${chalk2.cyan("npm run dev            # Start development server")}
+`);
+    console.log(chalk2.bold("\u{1F4DA} Available commands:"));
+    console.log(`
+  ${chalk2.yellow("servcraft generate module <name>")}    Generate a new module
+  ${chalk2.yellow("servcraft generate controller <name>")} Generate a controller
+  ${chalk2.yellow("servcraft generate service <name>")}    Generate a service
+  ${chalk2.yellow("servcraft add auth")}                   Add authentication module
+`);
+  } catch (err) {
+    spinner.fail("Failed to create project");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+function generatePackageJson(options) {
+  const isTS = options.language === "typescript";
+  const pkg = {
+    name: options.name,
+    version: "0.1.0",
+    description: "A Servcraft application",
+    main: isTS ? "dist/index.js" : "src/index.js",
+    type: "module",
+    scripts: {
+      dev: isTS ? "tsx watch src/index.ts" : "node --watch src/index.js",
+      build: isTS ? "tsup" : 'echo "No build needed for JS"',
+      start: isTS ? "node dist/index.js" : "node src/index.js",
+      test: "vitest",
+      lint: isTS ? "eslint src --ext .ts" : "eslint src --ext .js"
+    },
+    dependencies: {
+      fastify: "^4.28.1",
+      "@fastify/cors": "^9.0.1",
+      "@fastify/helmet": "^11.1.1",
+      "@fastify/jwt": "^8.0.1",
+      "@fastify/rate-limit": "^9.1.0",
+      "@fastify/cookie": "^9.3.1",
+      pino: "^9.5.0",
+      "pino-pretty": "^11.3.0",
+      bcryptjs: "^2.4.3",
+      dotenv: "^16.4.5"
+    },
+    devDependencies: {
+      vitest: "^2.1.8"
+    }
+  };
+  switch (options.validator) {
+    case "zod":
+      pkg.dependencies.zod = "^3.23.8";
+      break;
+    case "joi":
+      pkg.dependencies.joi = "^17.13.3";
+      break;
+    case "yup":
+      pkg.dependencies.yup = "^1.4.0";
+      break;
+  }
+  if (isTS) {
+    pkg.devDependencies.typescript = "^5.7.2";
+    pkg.devDependencies.tsx = "^4.19.2";
+    pkg.devDependencies.tsup = "^8.3.5";
+    pkg.devDependencies["@types/node"] = "^22.10.1";
+    pkg.devDependencies["@types/bcryptjs"] = "^2.4.6";
+  }
+  if (options.database !== "none" && options.database !== "mongodb") {
+    pkg.dependencies["@prisma/client"] = "^5.22.0";
+    pkg.devDependencies.prisma = "^5.22.0";
+    pkg.scripts["db:generate"] = "prisma generate";
+    pkg.scripts["db:migrate"] = "prisma migrate dev";
+    pkg.scripts["db:push"] = "prisma db push";
+    pkg.scripts["db:studio"] = "prisma studio";
+  }
+  if (options.database === "mongodb") {
+    pkg.dependencies.mongoose = "^8.8.4";
+  }
+  if (options.features.includes("email")) {
+    pkg.dependencies.nodemailer = "^6.9.15";
+    pkg.dependencies.handlebars = "^4.7.8";
+    if (isTS) {
+      pkg.devDependencies["@types/nodemailer"] = "^6.4.17";
+    }
+  }
+  if (options.features.includes("redis")) {
+    pkg.dependencies.ioredis = "^5.4.1";
+  }
+  return pkg;
+}
+function generateTsConfig() {
+  return JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      lib: ["ES2022"],
+      outDir: "./dist",
+      rootDir: "./src",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      resolveJsonModule: true,
+      declaration: true,
+      sourceMap: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  }, null, 2);
+}
+function generateJsConfig() {
+  return JSON.stringify({
+    compilerOptions: {
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      target: "ES2022",
+      checkJs: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules"]
+  }, null, 2);
+}
+function generateTsupConfig() {
+  return `import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  target: 'node18',
+});
+`;
+}
+function generateEnvExample(options) {
+  let env2 = `# Server
+NODE_ENV=development
+PORT=3000
+HOST=0.0.0.0
+
+# JWT
+JWT_SECRET=your-super-secret-key-min-32-characters
+JWT_ACCESS_EXPIRES_IN=15m
+JWT_REFRESH_EXPIRES_IN=7d
+
+# Security
+CORS_ORIGIN=http://localhost:3000
+RATE_LIMIT_MAX=100
+
+# Logging
+LOG_LEVEL=info
+`;
+  if (options.database === "postgresql") {
+    env2 += `
+# Database (PostgreSQL)
+DATABASE_PROVIDER=postgresql
+DATABASE_URL="postgresql://user:password@localhost:5432/mydb?schema=public"
+`;
+  } else if (options.database === "mysql") {
+    env2 += `
+# Database (MySQL)
+DATABASE_PROVIDER=mysql
+DATABASE_URL="mysql://user:password@localhost:3306/mydb"
+`;
+  } else if (options.database === "sqlite") {
+    env2 += `
+# Database (SQLite)
+DATABASE_PROVIDER=sqlite
+DATABASE_URL="file:./dev.db"
+`;
+  } else if (options.database === "mongodb") {
+    env2 += `
+# Database (MongoDB)
+MONGODB_URI="mongodb://localhost:27017/mydb"
+`;
+  }
+  if (options.features.includes("email")) {
+    env2 += `
+# Email
+SMTP_HOST=smtp.example.com
+SMTP_PORT=587
+SMTP_USER=
+SMTP_PASS=
+SMTP_FROM="App <noreply@example.com>"
+`;
+  }
+  if (options.features.includes("redis")) {
+    env2 += `
+# Redis
+REDIS_URL=redis://localhost:6379
+`;
+  }
+  return env2;
+}
+function generateGitignore() {
+  return `node_modules/
+dist/
+.env
+.env.local
+*.log
+coverage/
+.DS_Store
+*.db
+`;
+}
+function generateDockerfile(options) {
+  const isTS = options.language === "typescript";
+  return `FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY ${isTS ? "dist" : "src"} ./${isTS ? "dist" : "src"}
+${options.database !== "none" && options.database !== "mongodb" ? "COPY prisma ./prisma\nRUN npx prisma generate" : ""}
+EXPOSE 3000
+CMD ["node", "${isTS ? "dist" : "src"}/index.js"]
+`;
+}
+function generateDockerCompose(options) {
+  let compose = `version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "\${PORT:-3000}:3000"
+    environment:
+      - NODE_ENV=development
+`;
+  if (options.database === "postgresql") {
+    compose += `      - DATABASE_URL=postgresql://postgres:postgres@postgres:5432/mydb
+    depends_on:
+      - postgres
+
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: mydb
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+
+volumes:
+  postgres-data:
+`;
+  } else if (options.database === "mysql") {
+    compose += `      - DATABASE_URL=mysql://root:root@mysql:3306/mydb
+    depends_on:
+      - mysql
+
+  mysql:
+    image: mysql:8.0
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: mydb
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql-data:/var/lib/mysql
+
+volumes:
+  mysql-data:
+`;
+  }
+  if (options.features.includes("redis")) {
+    compose += `
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+`;
+  }
+  return compose;
+}
+function generatePrismaSchema(options) {
+  const provider = options.database === "sqlite" ? "sqlite" : options.database;
+  return `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${provider}"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id            String    @id @default(uuid())
+  email         String    @unique
+  password      String
+  name          String?
+  role          String    @default("user")
+  status        String    @default("active")
+  emailVerified Boolean   @default(false)
+  createdAt     DateTime  @default(now())
+  updatedAt     DateTime  @updatedAt
+
+  @@map("users")
+}
+`;
+}
+function generateEntryFile(options) {
+  const isTS = options.language === "typescript";
+  return `${isTS ? "import { createServer } from './core/server.js';\nimport { logger } from './core/logger.js';" : "const { createServer } = require('./core/server.js');\nconst { logger } = require('./core/logger.js');"}
+
+async function main()${isTS ? ": Promise<void>" : ""} {
+  const server = createServer();
+
+  try {
+    await server.start();
+  } catch (error) {
+    logger.error({ err: error }, 'Failed to start server');
+    process.exit(1);
+  }
+}
+
+main();
+`;
+}
+function generateServerFile(options) {
+  const isTS = options.language === "typescript";
+  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 });
+
+  // Health check
+  app.get('/health', async () => ({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+  }));
+
+  // Graceful shutdown
+  const signals${isTS ? ": NodeJS.Signals[]" : ""} = ['SIGINT', 'SIGTERM'];
+  signals.forEach((signal) => {
+    process.on(signal, async () => {
+      logger.info(\`Received \${signal}, shutting down...\`);
+      await app.close();
+      process.exit(0);
+    });
+  });
+
+  return {
+    instance: app,
+    start: async ()${isTS ? ": Promise<void>" : ""} => {
+      const port = parseInt(process.env.PORT || '3000', 10);
+      const host = process.env.HOST || '0.0.0.0';
+      await app.listen({ port, host });
+      logger.info(\`Server listening on \${host}:\${port}\`);
+    },
+  };
+}
+
+${isTS ? "" : "module.exports = { createServer };"}
+`;
+}
+function generateLoggerFile(options) {
+  const isTS = options.language === "typescript";
+  return `${isTS ? "import pino from 'pino';\nimport type { Logger } from 'pino';" : "const pino = require('pino');"}
+
+${isTS ? "export const logger: Logger" : "const logger"} = pino({
+  level: process.env.LOG_LEVEL || 'info',
+  transport: process.env.NODE_ENV !== 'production' ? {
+    target: 'pino-pretty',
+    options: { colorize: true },
+  } : undefined,
+});
+
+${isTS ? "" : "module.exports = { logger };"}
+`;
+}
+
+// src/cli/commands/generate.ts
+import { Command as Command2 } from "commander";
+import path4 from "path";
+import ora3 from "ora";
+import inquirer2 from "inquirer";
+
+// src/cli/utils/field-parser.ts
+var tsTypeMap = {
+  string: "string",
+  number: "number",
+  boolean: "boolean",
+  date: "Date",
+  datetime: "Date",
+  text: "string",
+  json: "Record<string, unknown>",
+  email: "string",
+  url: "string",
+  uuid: "string",
+  int: "number",
+  float: "number",
+  decimal: "number",
+  enum: "string"
+};
+var prismaTypeMap = {
+  string: "String",
+  number: "Int",
+  boolean: "Boolean",
+  date: "DateTime",
+  datetime: "DateTime",
+  text: "String",
+  json: "Json",
+  email: "String",
+  url: "String",
+  uuid: "String",
+  int: "Int",
+  float: "Float",
+  decimal: "Decimal",
+  enum: "String"
+};
+var zodTypeMap = {
+  string: "z.string()",
+  number: "z.number()",
+  boolean: "z.boolean()",
+  date: "z.coerce.date()",
+  datetime: "z.coerce.date()",
+  text: "z.string()",
+  json: "z.record(z.unknown())",
+  email: "z.string().email()",
+  url: "z.string().url()",
+  uuid: "z.string().uuid()",
+  int: "z.number().int()",
+  float: "z.number()",
+  decimal: "z.number()",
+  enum: "z.string()"
+};
+var joiTypeMap = {
+  string: "Joi.string()",
+  number: "Joi.number()",
+  boolean: "Joi.boolean()",
+  date: "Joi.date()",
+  datetime: "Joi.date()",
+  text: "Joi.string()",
+  json: "Joi.object()",
+  email: "Joi.string().email()",
+  url: "Joi.string().uri()",
+  uuid: "Joi.string().uuid()",
+  int: "Joi.number().integer()",
+  float: "Joi.number()",
+  decimal: "Joi.number()",
+  enum: "Joi.string()"
+};
+var yupTypeMap = {
+  string: "yup.string()",
+  number: "yup.number()",
+  boolean: "yup.boolean()",
+  date: "yup.date()",
+  datetime: "yup.date()",
+  text: "yup.string()",
+  json: "yup.object()",
+  email: "yup.string().email()",
+  url: "yup.string().url()",
+  uuid: "yup.string().uuid()",
+  int: "yup.number().integer()",
+  float: "yup.number()",
+  decimal: "yup.number()",
+  enum: "yup.string()"
+};
+function parseField(fieldStr) {
+  const parts = fieldStr.split(":");
+  let name = parts[0] || "";
+  let typeStr = parts[1] || "string";
+  const modifiers = parts.slice(2);
+  const isOptional = name.endsWith("?") || typeStr.endsWith("?");
+  name = name.replace("?", "");
+  typeStr = typeStr.replace("?", "");
+  const isArray = typeStr.endsWith("[]");
+  typeStr = typeStr.replace("[]", "");
+  const validTypes = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "datetime",
+    "text",
+    "json",
+    "email",
+    "url",
+    "uuid",
+    "int",
+    "float",
+    "decimal",
+    "enum"
+  ];
+  let type = "string";
+  if (validTypes.includes(typeStr)) {
+    type = typeStr;
+  }
+  let isUnique = false;
+  let defaultValue;
+  let relation;
+  for (const mod of modifiers) {
+    if (mod === "unique") {
+      isUnique = true;
+    } else if (mod.startsWith("default=")) {
+      defaultValue = mod.replace("default=", "");
+    } else if (typeStr === "relation") {
+      relation = {
+        model: mod,
+        type: "many-to-one"
+      };
+      type = "string";
+    }
+  }
+  return {
+    name,
+    type,
+    isOptional,
+    isArray,
+    isUnique,
+    defaultValue,
+    relation
+  };
+}
+function parseFields(fieldsStr) {
+  if (!fieldsStr) return [];
+  return fieldsStr.split(/\s+/).filter(Boolean).map(parseField);
+}
+
+// src/cli/templates/controller.ts
+function controllerTemplate(name, pascalName, camelName) {
+  return `import type { FastifyRequest, FastifyReply } from 'fastify';
+import type { ${pascalName}Service } from './${name}.service.js';
+import { create${pascalName}Schema, update${pascalName}Schema, ${camelName}QuerySchema } from './${name}.schemas.js';
+import { success, created, noContent } from '../../utils/response.js';
+import { parsePaginationParams } from '../../utils/pagination.js';
+import { validateBody, validateQuery } from '../validation/validator.js';
+
+export class ${pascalName}Controller {
+  constructor(private ${camelName}Service: ${pascalName}Service) {}
+
+  async list(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    const query = validateQuery(${camelName}QuerySchema, request.query);
+    const pagination = parsePaginationParams(query);
+    const filters = {
+      search: query.search,
+    };
+
+    const result = await this.${camelName}Service.findMany(pagination, filters);
+    success(reply, result);
+  }
+
+  async getById(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const item = await this.${camelName}Service.findById(request.params.id);
+
+    if (!item) {
+      return reply.status(404).send({
+        success: false,
+        message: '${pascalName} not found',
+      });
+    }
+
+    success(reply, item);
+  }
+
+  async create(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    const data = validateBody(create${pascalName}Schema, request.body);
+    const item = await this.${camelName}Service.create(data);
+    created(reply, item);
+  }
+
+  async update(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const data = validateBody(update${pascalName}Schema, request.body);
+    const item = await this.${camelName}Service.update(request.params.id, data);
+    success(reply, item);
+  }
+
+  async delete(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    await this.${camelName}Service.delete(request.params.id);
+    noContent(reply);
+  }
+}
+
+export function create${pascalName}Controller(${camelName}Service: ${pascalName}Service): ${pascalName}Controller {
+  return new ${pascalName}Controller(${camelName}Service);
+}
+`;
+}
+
+// src/cli/templates/service.ts
+function serviceTemplate(name, pascalName, camelName) {
+  return `import type { PaginatedResult, PaginationParams } from '../../types/index.js';
+import { NotFoundError, ConflictError } from '../../utils/errors.js';
+import { ${pascalName}Repository, create${pascalName}Repository } from './${name}.repository.js';
+import type { ${pascalName}, Create${pascalName}Data, Update${pascalName}Data, ${pascalName}Filters } from './${name}.types.js';
+import { logger } from '../../core/logger.js';
+
+export class ${pascalName}Service {
+  constructor(private repository: ${pascalName}Repository) {}
+
+  async findById(id: string): Promise<${pascalName} | null> {
+    return this.repository.findById(id);
+  }
+
+  async findMany(
+    params: PaginationParams,
+    filters?: ${pascalName}Filters
+  ): Promise<PaginatedResult<${pascalName}>> {
+    return this.repository.findMany(params, filters);
+  }
+
+  async create(data: Create${pascalName}Data): Promise<${pascalName}> {
+    const item = await this.repository.create(data);
+    logger.info({ ${camelName}Id: item.id }, '${pascalName} created');
+    return item;
+  }
+
+  async update(id: string, data: Update${pascalName}Data): Promise<${pascalName}> {
+    const existing = await this.repository.findById(id);
+    if (!existing) {
+      throw new NotFoundError('${pascalName}');
+    }
+
+    const updated = await this.repository.update(id, data);
+    if (!updated) {
+      throw new NotFoundError('${pascalName}');
+    }
+
+    logger.info({ ${camelName}Id: id }, '${pascalName} updated');
+    return updated;
+  }
+
+  async delete(id: string): Promise<void> {
+    const existing = await this.repository.findById(id);
+    if (!existing) {
+      throw new NotFoundError('${pascalName}');
+    }
+
+    await this.repository.delete(id);
+    logger.info({ ${camelName}Id: id }, '${pascalName} deleted');
+  }
+}
+
+export function create${pascalName}Service(repository?: ${pascalName}Repository): ${pascalName}Service {
+  return new ${pascalName}Service(repository || create${pascalName}Repository());
+}
+`;
+}
+
+// src/cli/templates/repository.ts
+function repositoryTemplate(name, pascalName, camelName, pluralName) {
+  return `import { randomUUID } from 'crypto';
+import type { PaginatedResult, PaginationParams } from '../../types/index.js';
+import { createPaginatedResult, getSkip } from '../../utils/pagination.js';
+import type { ${pascalName}, Create${pascalName}Data, Update${pascalName}Data, ${pascalName}Filters } from './${name}.types.js';
+
+// In-memory storage (will be replaced by Prisma in production)
+const ${pluralName} = new Map<string, ${pascalName}>();
+
+export class ${pascalName}Repository {
+  async findById(id: string): Promise<${pascalName} | null> {
+    return ${pluralName}.get(id) || null;
+  }
+
+  async findMany(
+    params: PaginationParams,
+    filters?: ${pascalName}Filters
+  ): Promise<PaginatedResult<${pascalName}>> {
+    let items = Array.from(${pluralName}.values());
+
+    // Apply filters
+    if (filters?.search) {
+      const search = filters.search.toLowerCase();
+      items = items.filter((item) =>
+        JSON.stringify(item).toLowerCase().includes(search)
+      );
+    }
+
+    // Sort
+    if (params.sortBy) {
+      const sortKey = params.sortBy as keyof ${pascalName};
+      items.sort((a, b) => {
+        const aVal = a[sortKey];
+        const bVal = b[sortKey];
+        if (aVal === undefined || bVal === undefined) return 0;
+        if (aVal < bVal) return params.sortOrder === 'desc' ? 1 : -1;
+        if (aVal > bVal) return params.sortOrder === 'desc' ? -1 : 1;
+        return 0;
+      });
+    }
+
+    const total = items.length;
+    const skip = getSkip(params);
+    const data = items.slice(skip, skip + params.limit);
+
+    return createPaginatedResult(data, total, params);
+  }
+
+  async create(data: Create${pascalName}Data): Promise<${pascalName}> {
+    const now = new Date();
+    const item: ${pascalName} = {
+      id: randomUUID(),
+      ...data,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    ${pluralName}.set(item.id, item);
+    return item;
+  }
+
+  async update(id: string, data: Update${pascalName}Data): Promise<${pascalName} | null> {
+    const item = ${pluralName}.get(id);
+    if (!item) return null;
+
+    const updated: ${pascalName} = {
+      ...item,
+      ...data,
+      updatedAt: new Date(),
+    };
+
+    ${pluralName}.set(id, updated);
+    return updated;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    return ${pluralName}.delete(id);
+  }
+
+  async count(filters?: ${pascalName}Filters): Promise<number> {
+    if (!filters) return ${pluralName}.size;
+
+    let count = 0;
+    for (const item of ${pluralName}.values()) {
+      if (filters.search) {
+        const search = filters.search.toLowerCase();
+        if (!JSON.stringify(item).toLowerCase().includes(search)) continue;
+      }
+      count++;
+    }
+    return count;
+  }
+
+  // Clear all (for testing)
+  async clear(): Promise<void> {
+    ${pluralName}.clear();
+  }
+}
+
+export function create${pascalName}Repository(): ${pascalName}Repository {
+  return new ${pascalName}Repository();
+}
+`;
+}
+
+// src/cli/templates/types.ts
+function typesTemplate(name, pascalName) {
+  return `import type { BaseEntity } from '../../types/index.js';
+
+export interface ${pascalName} extends BaseEntity {
+  // Add your ${pascalName} specific fields here
+  name: string;
+  description?: string;
+  // status?: string;
+  // metadata?: Record<string, unknown>;
+}
+
+export interface Create${pascalName}Data {
+  name: string;
+  description?: string;
+}
+
+export interface Update${pascalName}Data {
+  name?: string;
+  description?: string;
+}
+
+export interface ${pascalName}Filters {
+  search?: string;
+  // Add more filters as needed
+}
+`;
+}
+
+// src/cli/templates/schemas.ts
+function schemasTemplate(name, pascalName, camelName) {
+  return `import { z } from 'zod';
+
+export const create${pascalName}Schema = z.object({
+  name: z.string().min(1, 'Name is required').max(255),
+  description: z.string().max(1000).optional(),
+});
+
+export const update${pascalName}Schema = z.object({
+  name: z.string().min(1).max(255).optional(),
+  description: z.string().max(1000).optional(),
+});
+
+export const ${camelName}QuerySchema = z.object({
+  page: z.string().transform(Number).optional(),
+  limit: z.string().transform(Number).optional(),
+  sortBy: z.string().optional(),
+  sortOrder: z.enum(['asc', 'desc']).optional(),
+  search: z.string().optional(),
+});
+
+export type Create${pascalName}Input = z.infer<typeof create${pascalName}Schema>;
+export type Update${pascalName}Input = z.infer<typeof update${pascalName}Schema>;
+export type ${pascalName}QueryInput = z.infer<typeof ${camelName}QuerySchema>;
+`;
+}
+
+// src/cli/templates/routes.ts
+function routesTemplate(name, pascalName, camelName, pluralName, fields = []) {
+  const serializedFields = JSON.stringify(fields, null, 2);
+  return `import type { FastifyInstance } from 'fastify';
+import type { ${pascalName}Controller } from './${name}.controller.js';
+import type { AuthService } from '../auth/auth.service.js';
+import { createAuthMiddleware, createRoleMiddleware } from '../auth/auth.middleware.js';
+import { generateRouteSchema } from '../swagger/schema-builder.js';
+import type { FieldDefinition } from '../cli/utils/field-parser.js';
+
+const ${camelName}Fields: FieldDefinition[] = ${serializedFields};
+const ${camelName}Schemas = {
+  list: generateRouteSchema('${pascalName}', ${camelName}Fields, 'list'),
+  get: generateRouteSchema('${pascalName}', ${camelName}Fields, 'get'),
+  create: generateRouteSchema('${pascalName}', ${camelName}Fields, 'create'),
+  update: generateRouteSchema('${pascalName}', ${camelName}Fields, 'update'),
+  delete: generateRouteSchema('${pascalName}', ${camelName}Fields, 'delete'),
+};
+
+export function register${pascalName}Routes(
+  app: FastifyInstance,
+  controller: ${pascalName}Controller,
+  authService: AuthService
+): void {
+  const authenticate = createAuthMiddleware(authService);
+  const isAdmin = createRoleMiddleware(['admin', 'super_admin']);
+
+  // Public routes (if any)
+  // app.get('/${pluralName}/public', controller.publicList.bind(controller));
+
+  // Protected routes
+  app.get(
+    '/${pluralName}',
+    { preHandler: [authenticate], ...${camelName}Schemas.list },
+    controller.list.bind(controller)
+  );
+
+  app.get(
+    '/${pluralName}/:id',
+    { preHandler: [authenticate], ...${camelName}Schemas.get },
+    controller.getById.bind(controller)
+  );
+
+  app.post(
+    '/${pluralName}',
+    { preHandler: [authenticate], ...${camelName}Schemas.create },
+    controller.create.bind(controller)
+  );
+
+  app.patch(
+    '/${pluralName}/:id',
+    { preHandler: [authenticate], ...${camelName}Schemas.update },
+    controller.update.bind(controller)
+  );
+
+  app.delete(
+    '/${pluralName}/:id',
+    { preHandler: [authenticate, isAdmin], ...${camelName}Schemas.delete },
+    controller.delete.bind(controller)
+  );
+}
+`;
+}
+
+// src/cli/templates/module-index.ts
+function moduleIndexTemplate(name, pascalName, camelName) {
+  return `import type { FastifyInstance } from 'fastify';
+import { logger } from '../../core/logger.js';
+import { ${pascalName}Service, create${pascalName}Service } from './${name}.service.js';
+import { ${pascalName}Controller, create${pascalName}Controller } from './${name}.controller.js';
+import { ${pascalName}Repository, create${pascalName}Repository } from './${name}.repository.js';
+import { register${pascalName}Routes } from './${name}.routes.js';
+import type { AuthService } from '../auth/auth.service.js';
+
+export async function register${pascalName}Module(
+  app: FastifyInstance,
+  authService: AuthService
+): Promise<void> {
+  // Create repository and service
+  const repository = create${pascalName}Repository();
+  const ${camelName}Service = create${pascalName}Service(repository);
+
+  // Create controller
+  const ${camelName}Controller = create${pascalName}Controller(${camelName}Service);
+
+  // Register routes
+  register${pascalName}Routes(app, ${camelName}Controller, authService);
+
+  logger.info('${pascalName} module registered');
+}
+
+export { ${pascalName}Service, create${pascalName}Service } from './${name}.service.js';
+export { ${pascalName}Controller, create${pascalName}Controller } from './${name}.controller.js';
+export { ${pascalName}Repository, create${pascalName}Repository } from './${name}.repository.js';
+export * from './${name}.types.js';
+export * from './${name}.schemas.js';
+`;
+}
+
+// src/cli/templates/prisma-model.ts
+function prismaModelTemplate(name, pascalName, tableName) {
+  return `
+// Add this model to your prisma/schema.prisma file
+
+model ${pascalName} {
+  id          String   @id @default(uuid())
+  name        String
+  description String?
+
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+
+  @@index([name])
+  @@map("${tableName}")
+}
+`;
+}
+
+// src/cli/templates/dynamic-types.ts
+function dynamicTypesTemplate(name, pascalName, fields) {
+  const fieldLines = fields.map((field) => {
+    const tsType = tsTypeMap[field.type];
+    const arrayMark = field.isArray ? "[]" : "";
+    const optionalMark = field.isOptional ? "?" : "";
+    return `  ${field.name}${optionalMark}: ${tsType}${arrayMark};`;
+  });
+  const createFieldLines = fields.filter((f) => !f.isOptional).map((field) => {
+    const tsType = tsTypeMap[field.type];
+    const arrayMark = field.isArray ? "[]" : "";
+    return `  ${field.name}: ${tsType}${arrayMark};`;
+  });
+  const createOptionalLines = fields.filter((f) => f.isOptional).map((field) => {
+    const tsType = tsTypeMap[field.type];
+    const arrayMark = field.isArray ? "[]" : "";
+    return `  ${field.name}?: ${tsType}${arrayMark};`;
+  });
+  const updateFieldLines = fields.map((field) => {
+    const tsType = tsTypeMap[field.type];
+    const arrayMark = field.isArray ? "[]" : "";
+    return `  ${field.name}?: ${tsType}${arrayMark};`;
+  });
+  return `import type { BaseEntity } from '../../types/index.js';
+
+export interface ${pascalName} extends BaseEntity {
+${fieldLines.join("\n")}
+}
+
+export interface Create${pascalName}Data {
+${[...createFieldLines, ...createOptionalLines].join("\n")}
+}
+
+export interface Update${pascalName}Data {
+${updateFieldLines.join("\n")}
+}
+
+export interface ${pascalName}Filters {
+  search?: string;
+${fields.filter((f) => ["string", "enum", "boolean"].includes(f.type)).map((f) => `  ${f.name}?: ${tsTypeMap[f.type]};`).join("\n")}
+}
+`;
+}
+
+// src/cli/templates/dynamic-schemas.ts
+function dynamicSchemasTemplate(name, pascalName, camelName, fields, validator = "zod") {
+  switch (validator) {
+    case "joi":
+      return generateJoiSchemas(pascalName, camelName, fields);
+    case "yup":
+      return generateYupSchemas(pascalName, camelName, fields);
+    default:
+      return generateZodSchemas(pascalName, camelName, fields);
+  }
+}
+function generateZodSchemas(pascalName, camelName, fields) {
+  const createFields = fields.map((field) => {
+    let validator = zodTypeMap[field.type];
+    if (field.isArray) {
+      validator = `z.array(${validator})`;
+    }
+    if (field.isOptional) {
+      validator += ".optional()";
+    }
+    if (field.defaultValue) {
+      validator += `.default(${field.defaultValue})`;
+    }
+    if (field.type === "string" && !field.isOptional) {
+      validator = validator.replace("z.string()", "z.string().min(1)");
+    }
+    return `  ${field.name}: ${validator},`;
+  });
+  const updateFields = fields.map((field) => {
+    let validator = zodTypeMap[field.type];
+    if (field.isArray) {
+      validator = `z.array(${validator})`;
+    }
+    validator += ".optional()";
+    return `  ${field.name}: ${validator},`;
+  });
+  return `import { z } from 'zod';
+
+export const create${pascalName}Schema = z.object({
+${createFields.join("\n")}
+});
+
+export const update${pascalName}Schema = z.object({
+${updateFields.join("\n")}
+});
+
+export const ${camelName}QuerySchema = z.object({
+  page: z.string().transform(Number).optional(),
+  limit: z.string().transform(Number).optional(),
+  sortBy: z.string().optional(),
+  sortOrder: z.enum(['asc', 'desc']).optional(),
+  search: z.string().optional(),
+});
+
+export type Create${pascalName}Input = z.infer<typeof create${pascalName}Schema>;
+export type Update${pascalName}Input = z.infer<typeof update${pascalName}Schema>;
+export type ${pascalName}QueryInput = z.infer<typeof ${camelName}QuerySchema>;
+`;
+}
+function generateJoiSchemas(pascalName, camelName, fields) {
+  const createFields = fields.map((field) => {
+    let validator = joiTypeMap[field.type];
+    if (field.isArray) {
+      validator = `Joi.array().items(${validator})`;
+    }
+    if (!field.isOptional) {
+      validator += ".required()";
+    }
+    if (field.defaultValue) {
+      validator += `.default(${field.defaultValue})`;
+    }
+    return `  ${field.name}: ${validator},`;
+  });
+  const updateFields = fields.map((field) => {
+    let validator = joiTypeMap[field.type];
+    if (field.isArray) {
+      validator = `Joi.array().items(${validator})`;
+    }
+    return `  ${field.name}: ${validator},`;
+  });
+  return `import Joi from 'joi';
+
+export const create${pascalName}Schema = Joi.object({
+${createFields.join("\n")}
+});
+
+export const update${pascalName}Schema = Joi.object({
+${updateFields.join("\n")}
+});
+
+export const ${camelName}QuerySchema = Joi.object({
+  page: Joi.number().integer().min(1),
+  limit: Joi.number().integer().min(1).max(100),
+  sortBy: Joi.string(),
+  sortOrder: Joi.string().valid('asc', 'desc'),
+  search: Joi.string(),
+});
+
+export type Create${pascalName}Input = {
+${fields.map((f) => `  ${f.name}${f.isOptional ? "?" : ""}: ${getJsType(f)};`).join("\n")}
+};
+
+export type Update${pascalName}Input = Partial<Create${pascalName}Input>;
+export type ${pascalName}QueryInput = {
+  page?: number;
+  limit?: number;
+  sortBy?: string;
+  sortOrder?: 'asc' | 'desc';
+  search?: string;
+};
+`;
+}
+function generateYupSchemas(pascalName, camelName, fields) {
+  const createFields = fields.map((field) => {
+    let validator = yupTypeMap[field.type];
+    if (field.isArray) {
+      validator = `yup.array().of(${validator})`;
+    }
+    if (!field.isOptional) {
+      validator += ".required()";
+    }
+    if (field.defaultValue) {
+      validator += `.default(${field.defaultValue})`;
+    }
+    return `  ${field.name}: ${validator},`;
+  });
+  const updateFields = fields.map((field) => {
+    let validator = yupTypeMap[field.type];
+    if (field.isArray) {
+      validator = `yup.array().of(${validator})`;
+    }
+    validator += ".optional()";
+    return `  ${field.name}: ${validator},`;
+  });
+  return `import * as yup from 'yup';
+
+export const create${pascalName}Schema = yup.object({
+${createFields.join("\n")}
+});
+
+export const update${pascalName}Schema = yup.object({
+${updateFields.join("\n")}
+});
+
+export const ${camelName}QuerySchema = yup.object({
+  page: yup.number().integer().min(1),
+  limit: yup.number().integer().min(1).max(100),
+  sortBy: yup.string(),
+  sortOrder: yup.string().oneOf(['asc', 'desc']),
+  search: yup.string(),
+});
+
+export type Create${pascalName}Input = yup.InferType<typeof create${pascalName}Schema>;
+export type Update${pascalName}Input = yup.InferType<typeof update${pascalName}Schema>;
+export type ${pascalName}QueryInput = yup.InferType<typeof ${camelName}QuerySchema>;
+`;
+}
+function getJsType(field) {
+  const typeMap = {
+    string: "string",
+    number: "number",
+    boolean: "boolean",
+    date: "Date",
+    datetime: "Date",
+    text: "string",
+    json: "Record<string, unknown>",
+    email: "string",
+    url: "string",
+    uuid: "string",
+    int: "number",
+    float: "number",
+    decimal: "number",
+    enum: "string"
+  };
+  const baseType = typeMap[field.type] || "unknown";
+  return field.isArray ? `${baseType}[]` : baseType;
+}
+
+// src/cli/templates/dynamic-prisma.ts
+function dynamicPrismaTemplate(modelName, tableName, fields) {
+  const fieldLines = [];
+  for (const field of fields) {
+    const prismaType = prismaTypeMap[field.type];
+    const optionalMark = field.isOptional ? "?" : "";
+    const arrayMark = field.isArray ? "[]" : "";
+    const annotations = [];
+    if (field.isUnique) {
+      annotations.push("@unique");
+    }
+    if (field.defaultValue !== void 0) {
+      if (field.type === "boolean") {
+        annotations.push(`@default(${field.defaultValue})`);
+      } else if (field.type === "number" || field.type === "int" || field.type === "float") {
+        annotations.push(`@default(${field.defaultValue})`);
+      } else {
+        annotations.push(`@default("${field.defaultValue}")`);
+      }
+    }
+    if (field.type === "text") {
+      annotations.push("@db.Text");
+    }
+    if (field.type === "decimal") {
+      annotations.push("@db.Decimal(10, 2)");
+    }
+    const annotationStr = annotations.length > 0 ? "  " + annotations.join(" ") : "";
+    const typePart = `${prismaType}${optionalMark}${arrayMark}`;
+    fieldLines.push(`  ${field.name.padEnd(15)} ${typePart.padEnd(12)}${annotationStr}`);
+  }
+  const indexLines = [];
+  const uniqueFields = fields.filter((f) => f.isUnique);
+  for (const field of uniqueFields) {
+    indexLines.push(`  @@index([${field.name}])`);
+  }
+  const searchableFields = fields.filter(
+    (f) => ["string", "email"].includes(f.type) && !f.isUnique
+  );
+  if (searchableFields.length > 0) {
+    const firstSearchable = searchableFields[0];
+    if (firstSearchable) {
+      indexLines.push(`  @@index([${firstSearchable.name}])`);
+    }
+  }
+  return `
+// ==========================================
+// Add this model to your prisma/schema.prisma file
+// ==========================================
+
+model ${modelName} {
+  id              String    @id @default(uuid())
+
+${fieldLines.join("\n")}
+
+  createdAt       DateTime  @default(now())
+  updatedAt       DateTime  @updatedAt
+
+${indexLines.join("\n")}
+  @@map("${tableName}")
+}
+
+// ==========================================
+// After adding the model, run:
+// npm run db:migrate -- --name add_${tableName}
+// ==========================================
+`;
+}
+
+// src/cli/utils/docs-generator.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import ora2 from "ora";
+
+// src/core/server.ts
+import Fastify from "fastify";
+
+// src/core/logger.ts
+import pino from "pino";
+var defaultConfig = {
+  level: process.env.LOG_LEVEL || "info",
+  pretty: process.env.NODE_ENV !== "production",
+  name: "servcraft"
+};
+function createLogger(config2 = {}) {
+  const mergedConfig = { ...defaultConfig, ...config2 };
+  const transport = mergedConfig.pretty ? {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "SYS:standard",
+      ignore: "pid,hostname"
+    }
+  } : void 0;
+  return pino({
+    name: mergedConfig.name,
+    level: mergedConfig.level,
+    transport,
+    formatters: {
+      level: (label) => ({ level: label })
+    },
+    timestamp: pino.stdTimeFunctions.isoTime
+  });
+}
+var logger = createLogger();
+
+// src/core/server.ts
+var defaultConfig2 = {
+  port: parseInt(process.env.PORT || "3000", 10),
+  host: process.env.HOST || "0.0.0.0",
+  trustProxy: true,
+  bodyLimit: 1048576,
+  // 1MB
+  requestTimeout: 3e4
+  // 30s
+};
+var Server = class {
+  app;
+  config;
+  logger;
+  isShuttingDown = false;
+  constructor(config2 = {}) {
+    this.config = { ...defaultConfig2, ...config2 };
+    this.logger = this.config.logger || logger;
+    const fastifyOptions = {
+      logger: this.logger,
+      trustProxy: this.config.trustProxy,
+      bodyLimit: this.config.bodyLimit,
+      requestTimeout: this.config.requestTimeout
+    };
+    this.app = Fastify(fastifyOptions);
+    this.setupHealthCheck();
+    this.setupGracefulShutdown();
+  }
+  get instance() {
+    return this.app;
+  }
+  setupHealthCheck() {
+    this.app.get("/health", async (_request, reply) => {
+      const healthcheck = {
+        status: "ok",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        uptime: process.uptime(),
+        memory: process.memoryUsage(),
+        version: process.env.npm_package_version || "0.1.0"
+      };
+      return reply.status(200).send(healthcheck);
+    });
+    this.app.get("/ready", async (_request, reply) => {
+      if (this.isShuttingDown) {
+        return reply.status(503).send({ status: "shutting_down" });
+      }
+      return reply.status(200).send({ status: "ready" });
+    });
+  }
+  setupGracefulShutdown() {
+    const signals = ["SIGINT", "SIGTERM", "SIGQUIT"];
+    signals.forEach((signal) => {
+      process.on(signal, async () => {
+        this.logger.info(`Received ${signal}, starting graceful shutdown...`);
+        await this.shutdown();
+      });
+    });
+    process.on("uncaughtException", async (error2) => {
+      this.logger.error({ err: error2 }, "Uncaught exception");
+      await this.shutdown(1);
+    });
+    process.on("unhandledRejection", async (reason) => {
+      this.logger.error({ err: reason }, "Unhandled rejection");
+      await this.shutdown(1);
+    });
+  }
+  async shutdown(exitCode = 0) {
+    if (this.isShuttingDown) {
+      return;
+    }
+    this.isShuttingDown = true;
+    this.logger.info("Graceful shutdown initiated...");
+    const shutdownTimeout = setTimeout(() => {
+      this.logger.error("Graceful shutdown timeout, forcing exit");
+      process.exit(1);
+    }, 3e4);
+    try {
+      await this.app.close();
+      this.logger.info("Server closed successfully");
+      clearTimeout(shutdownTimeout);
+      process.exit(exitCode);
+    } catch (error2) {
+      this.logger.error({ err: error2 }, "Error during shutdown");
+      clearTimeout(shutdownTimeout);
+      process.exit(1);
+    }
+  }
+  async start() {
+    try {
+      await this.app.listen({
+        port: this.config.port,
+        host: this.config.host
+      });
+      this.logger.info(`Server listening on ${this.config.host}:${this.config.port}`);
+    } catch (error2) {
+      this.logger.error({ err: error2 }, "Failed to start server");
+      throw error2;
+    }
+  }
+};
+function createServer(config2 = {}) {
+  return new Server(config2);
+}
+
+// src/utils/errors.ts
+var AppError = class _AppError extends Error {
+  statusCode;
+  isOperational;
+  errors;
+  constructor(message, statusCode = 500, isOperational = true, errors) {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    this.errors = errors;
+    Object.setPrototypeOf(this, _AppError.prototype);
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var NotFoundError = class extends AppError {
+  constructor(resource = "Resource") {
+    super(`${resource} not found`, 404);
+  }
+};
+var UnauthorizedError = class extends AppError {
+  constructor(message = "Unauthorized") {
+    super(message, 401);
+  }
+};
+var ForbiddenError = class extends AppError {
+  constructor(message = "Forbidden") {
+    super(message, 403);
+  }
+};
+var BadRequestError = class extends AppError {
+  constructor(message = "Bad request", errors) {
+    super(message, 400, true, errors);
+  }
+};
+var ConflictError = class extends AppError {
+  constructor(message = "Resource already exists") {
+    super(message, 409);
+  }
+};
+var ValidationError = class extends AppError {
+  constructor(errors) {
+    super("Validation failed", 422, true, errors);
+  }
+};
+function isAppError(error2) {
+  return error2 instanceof AppError;
+}
+
+// src/config/env.ts
+import { z } from "zod";
+import dotenv from "dotenv";
+dotenv.config();
+var envSchema = z.object({
+  // Server
+  NODE_ENV: z.enum(["development", "staging", "production", "test"]).default("development"),
+  PORT: z.string().transform(Number).default("3000"),
+  HOST: z.string().default("0.0.0.0"),
+  // Database
+  DATABASE_URL: z.string().optional(),
+  // JWT
+  JWT_SECRET: z.string().min(32).optional(),
+  JWT_ACCESS_EXPIRES_IN: z.string().default("15m"),
+  JWT_REFRESH_EXPIRES_IN: z.string().default("7d"),
+  // Security
+  CORS_ORIGIN: z.string().default("*"),
+  RATE_LIMIT_MAX: z.string().transform(Number).default("100"),
+  RATE_LIMIT_WINDOW_MS: z.string().transform(Number).default("60000"),
+  // Email
+  SMTP_HOST: z.string().optional(),
+  SMTP_PORT: z.string().transform(Number).optional(),
+  SMTP_USER: z.string().optional(),
+  SMTP_PASS: z.string().optional(),
+  SMTP_FROM: z.string().optional(),
+  // Redis (optional)
+  REDIS_URL: z.string().optional(),
+  // Swagger/OpenAPI
+  SWAGGER_ENABLED: z.union([z.literal("true"), z.literal("false")]).default("true").transform((val) => val === "true"),
+  SWAGGER_ROUTE: z.string().default("/docs"),
+  SWAGGER_TITLE: z.string().default("Servcraft API"),
+  SWAGGER_DESCRIPTION: z.string().default("API documentation"),
+  SWAGGER_VERSION: z.string().default("1.0.0"),
+  // Logging
+  LOG_LEVEL: z.enum(["fatal", "error", "warn", "info", "debug", "trace"]).default("info")
+});
+function validateEnv() {
+  const parsed = envSchema.safeParse(process.env);
+  if (!parsed.success) {
+    logger.error({ errors: parsed.error.flatten().fieldErrors }, "Invalid environment variables");
+    throw new Error("Invalid environment variables");
+  }
+  return parsed.data;
+}
+var env = validateEnv();
+function isProduction() {
+  return env.NODE_ENV === "production";
+}
+
+// src/config/index.ts
+function parseCorsOrigin(origin) {
+  if (origin === "*") return "*";
+  if (origin.includes(",")) {
+    return origin.split(",").map((o) => o.trim());
+  }
+  return origin;
+}
+function createConfig() {
+  return {
+    env,
+    server: {
+      port: env.PORT,
+      host: env.HOST
+    },
+    jwt: {
+      secret: env.JWT_SECRET || "change-me-in-production-please-32chars",
+      accessExpiresIn: env.JWT_ACCESS_EXPIRES_IN,
+      refreshExpiresIn: env.JWT_REFRESH_EXPIRES_IN
+    },
+    security: {
+      corsOrigin: parseCorsOrigin(env.CORS_ORIGIN),
+      rateLimit: {
+        max: env.RATE_LIMIT_MAX,
+        windowMs: env.RATE_LIMIT_WINDOW_MS
+      }
+    },
+    email: {
+      host: env.SMTP_HOST,
+      port: env.SMTP_PORT,
+      user: env.SMTP_USER,
+      pass: env.SMTP_PASS,
+      from: env.SMTP_FROM
+    },
+    database: {
+      url: env.DATABASE_URL
+    },
+    redis: {
+      url: env.REDIS_URL
+    },
+    swagger: {
+      enabled: env.SWAGGER_ENABLED,
+      route: env.SWAGGER_ROUTE,
+      title: env.SWAGGER_TITLE,
+      description: env.SWAGGER_DESCRIPTION,
+      version: env.SWAGGER_VERSION
+    }
+  };
+}
+var config = createConfig();
+
+// src/middleware/error-handler.ts
+function registerErrorHandler(app) {
+  app.setErrorHandler(
+    (error2, request, reply) => {
+      logger.error(
+        {
+          err: error2,
+          requestId: request.id,
+          method: request.method,
+          url: request.url
+        },
+        "Request error"
+      );
+      if (isAppError(error2)) {
+        return reply.status(error2.statusCode).send({
+          success: false,
+          message: error2.message,
+          errors: error2.errors,
+          ...isProduction() ? {} : { stack: error2.stack }
+        });
+      }
+      if ("validation" in error2 && error2.validation) {
+        const errors = {};
+        for (const err of error2.validation) {
+          const field = err.instancePath?.replace("/", "") || "body";
+          if (!errors[field]) {
+            errors[field] = [];
+          }
+          errors[field].push(err.message || "Invalid value");
+        }
+        return reply.status(400).send({
+          success: false,
+          message: "Validation failed",
+          errors
+        });
+      }
+      if ("statusCode" in error2 && typeof error2.statusCode === "number") {
+        return reply.status(error2.statusCode).send({
+          success: false,
+          message: error2.message,
+          ...isProduction() ? {} : { stack: error2.stack }
+        });
+      }
+      return reply.status(500).send({
+        success: false,
+        message: isProduction() ? "Internal server error" : error2.message,
+        ...isProduction() ? {} : { stack: error2.stack }
+      });
+    }
+  );
+  app.setNotFoundHandler((request, reply) => {
+    return reply.status(404).send({
+      success: false,
+      message: `Route ${request.method} ${request.url} not found`
+    });
+  });
+}
+
+// src/middleware/security.ts
+import helmet from "@fastify/helmet";
+import cors from "@fastify/cors";
+import rateLimit from "@fastify/rate-limit";
+var defaultOptions = {
+  helmet: true,
+  cors: true,
+  rateLimit: true
+};
+async function registerSecurity(app, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  if (opts.helmet) {
+    await app.register(helmet, {
+      contentSecurityPolicy: {
+        directives: {
+          defaultSrc: ["'self'"],
+          styleSrc: ["'self'", "'unsafe-inline'"],
+          scriptSrc: ["'self'"],
+          imgSrc: ["'self'", "data:", "https:"]
+        }
+      },
+      crossOriginEmbedderPolicy: false
+    });
+    logger.debug("Helmet security headers enabled");
+  }
+  if (opts.cors) {
+    await app.register(cors, {
+      origin: config.security.corsOrigin,
+      credentials: true,
+      methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+      allowedHeaders: ["Content-Type", "Authorization", "X-Requested-With"],
+      exposedHeaders: ["X-Total-Count", "X-Page", "X-Limit"],
+      maxAge: 86400
+      // 24 hours
+    });
+    logger.debug({ origin: config.security.corsOrigin }, "CORS enabled");
+  }
+  if (opts.rateLimit) {
+    await app.register(rateLimit, {
+      max: config.security.rateLimit.max,
+      timeWindow: config.security.rateLimit.windowMs,
+      errorResponseBuilder: (_request, context) => ({
+        success: false,
+        message: "Too many requests, please try again later",
+        retryAfter: context.after
+      }),
+      keyGenerator: (request) => {
+        return request.headers["x-forwarded-for"]?.toString().split(",")[0] || request.ip || "unknown";
+      }
+    });
+    logger.debug(
+      {
+        max: config.security.rateLimit.max,
+        windowMs: config.security.rateLimit.windowMs
+      },
+      "Rate limiting enabled"
+    );
+  }
+}
+
+// src/modules/swagger/swagger.service.ts
+import swagger from "@fastify/swagger";
+import swaggerUi from "@fastify/swagger-ui";
+var defaultConfig3 = {
+  enabled: true,
+  route: "/docs",
+  title: "Servcraft API",
+  description: "API documentation generated by Servcraft",
+  version: "1.0.0",
+  tags: [
+    { name: "Auth", description: "Authentication endpoints" },
+    { name: "Users", description: "User management endpoints" },
+    { name: "Health", description: "Health check endpoints" }
+  ]
+};
+async function registerSwagger(app, customConfig) {
+  const swaggerConfig = { ...defaultConfig3, ...customConfig };
+  if (swaggerConfig.enabled === false) {
+    logger.info("Swagger documentation disabled");
+    return;
+  }
+  await app.register(swagger, {
+    openapi: {
+      openapi: "3.0.3",
+      info: {
+        title: swaggerConfig.title,
+        description: swaggerConfig.description,
+        version: swaggerConfig.version,
+        contact: swaggerConfig.contact,
+        license: swaggerConfig.license
+      },
+      servers: swaggerConfig.servers || [
+        {
+          url: `http://localhost:${config.server.port}`,
+          description: "Development server"
+        }
+      ],
+      tags: swaggerConfig.tags,
+      components: {
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer",
+            bearerFormat: "JWT",
+            description: "Enter your JWT token"
+          }
+        }
+      }
+    }
+  });
+  await app.register(swaggerUi, {
+    routePrefix: swaggerConfig.route || "/docs",
+    uiConfig: {
+      docExpansion: "list",
+      deepLinking: true,
+      displayRequestDuration: true,
+      filter: true,
+      showExtensions: true,
+      showCommonExtensions: true
+    },
+    staticCSP: true,
+    transformStaticCSP: (header) => header
+  });
+  logger.info("Swagger documentation registered at /docs");
+}
+var commonResponses = {
+  success: {
+    type: "object",
+    properties: {
+      success: { type: "boolean", example: true },
+      data: { type: "object" }
+    }
+  },
+  error: {
+    type: "object",
+    properties: {
+      success: { type: "boolean", example: false },
+      message: { type: "string" },
+      errors: {
+        type: "object",
+        additionalProperties: {
+          type: "array",
+          items: { type: "string" }
+        }
+      }
+    }
+  },
+  unauthorized: {
+    type: "object",
+    properties: {
+      success: { type: "boolean", example: false },
+      message: { type: "string", example: "Unauthorized" }
+    }
+  },
+  notFound: {
+    type: "object",
+    properties: {
+      success: { type: "boolean", example: false },
+      message: { type: "string", example: "Resource not found" }
+    }
+  },
+  paginated: {
+    type: "object",
+    properties: {
+      success: { type: "boolean", example: true },
+      data: {
+        type: "object",
+        properties: {
+          data: { type: "array", items: { type: "object" } },
+          meta: {
+            type: "object",
+            properties: {
+              total: { type: "number" },
+              page: { type: "number" },
+              limit: { type: "number" },
+              totalPages: { type: "number" },
+              hasNextPage: { type: "boolean" },
+              hasPrevPage: { type: "boolean" }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+var paginationQuery = {
+  type: "object",
+  properties: {
+    page: { type: "integer", minimum: 1, default: 1, description: "Page number" },
+    limit: { type: "integer", minimum: 1, maximum: 100, default: 20, description: "Items per page" },
+    sortBy: { type: "string", description: "Field to sort by" },
+    sortOrder: { type: "string", enum: ["asc", "desc"], default: "asc", description: "Sort order" },
+    search: { type: "string", description: "Search query" }
+  }
+};
+var idParam = {
+  type: "object",
+  properties: {
+    id: { type: "string", format: "uuid", description: "Resource ID" }
+  },
+  required: ["id"]
+};
+
+// src/modules/auth/index.ts
+import jwt from "@fastify/jwt";
+import cookie from "@fastify/cookie";
+
+// src/modules/auth/auth.service.ts
+import bcrypt from "bcryptjs";
+var tokenBlacklist = /* @__PURE__ */ new Set();
+var AuthService = class {
+  app;
+  SALT_ROUNDS = 12;
+  constructor(app) {
+    this.app = app;
+  }
+  async hashPassword(password) {
+    return bcrypt.hash(password, this.SALT_ROUNDS);
+  }
+  async verifyPassword(password, hash) {
+    return bcrypt.compare(password, hash);
+  }
+  generateTokenPair(user) {
+    const accessPayload = {
+      sub: user.id,
+      email: user.email,
+      role: user.role,
+      type: "access"
+    };
+    const refreshPayload = {
+      sub: user.id,
+      email: user.email,
+      role: user.role,
+      type: "refresh"
+    };
+    const accessToken = this.app.jwt.sign(accessPayload, {
+      expiresIn: config.jwt.accessExpiresIn
+    });
+    const refreshToken = this.app.jwt.sign(refreshPayload, {
+      expiresIn: config.jwt.refreshExpiresIn
+    });
+    const expiresIn = this.parseExpiration(config.jwt.accessExpiresIn);
+    return { accessToken, refreshToken, expiresIn };
+  }
+  parseExpiration(expiration) {
+    const match = expiration.match(/^(\d+)([smhd])$/);
+    if (!match) return 900;
+    const value = parseInt(match[1] || "0", 10);
+    const unit = match[2];
+    switch (unit) {
+      case "s":
+        return value;
+      case "m":
+        return value * 60;
+      case "h":
+        return value * 3600;
+      case "d":
+        return value * 86400;
+      default:
+        return 900;
+    }
+  }
+  async verifyAccessToken(token) {
+    try {
+      if (this.isTokenBlacklisted(token)) {
+        throw new UnauthorizedError("Token has been revoked");
+      }
+      const payload = this.app.jwt.verify(token);
+      if (payload.type !== "access") {
+        throw new UnauthorizedError("Invalid token type");
+      }
+      return payload;
+    } catch (error2) {
+      if (error2 instanceof UnauthorizedError) throw error2;
+      logger.debug({ err: error2 }, "Token verification failed");
+      throw new UnauthorizedError("Invalid or expired token");
+    }
+  }
+  async verifyRefreshToken(token) {
+    try {
+      if (this.isTokenBlacklisted(token)) {
+        throw new UnauthorizedError("Token has been revoked");
+      }
+      const payload = this.app.jwt.verify(token);
+      if (payload.type !== "refresh") {
+        throw new UnauthorizedError("Invalid token type");
+      }
+      return payload;
+    } catch (error2) {
+      if (error2 instanceof UnauthorizedError) throw error2;
+      logger.debug({ err: error2 }, "Refresh token verification failed");
+      throw new UnauthorizedError("Invalid or expired refresh token");
+    }
+  }
+  blacklistToken(token) {
+    tokenBlacklist.add(token);
+    logger.debug("Token blacklisted");
+  }
+  isTokenBlacklisted(token) {
+    return tokenBlacklist.has(token);
+  }
+  // Clear expired tokens from blacklist periodically
+  cleanupBlacklist() {
+    tokenBlacklist.clear();
+    logger.debug("Token blacklist cleared");
+  }
+};
+function createAuthService(app) {
+  return new AuthService(app);
+}
+
+// src/modules/auth/schemas.ts
+import { z as z2 } from "zod";
+var loginSchema = z2.object({
+  email: z2.string().email("Invalid email address"),
+  password: z2.string().min(1, "Password is required")
+});
+var registerSchema = z2.object({
+  email: z2.string().email("Invalid email address"),
+  password: z2.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number"),
+  name: z2.string().min(2, "Name must be at least 2 characters").optional()
+});
+var refreshTokenSchema = z2.object({
+  refreshToken: z2.string().min(1, "Refresh token is required")
+});
+var passwordResetRequestSchema = z2.object({
+  email: z2.string().email("Invalid email address")
+});
+var passwordResetConfirmSchema = z2.object({
+  token: z2.string().min(1, "Token is required"),
+  password: z2.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number")
+});
+var changePasswordSchema = z2.object({
+  currentPassword: z2.string().min(1, "Current password is required"),
+  newPassword: z2.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number")
+});
+
+// src/utils/response.ts
+function success3(reply, data, statusCode = 200) {
+  const response = {
+    success: true,
+    data
+  };
+  return reply.status(statusCode).send(response);
+}
+function created(reply, data) {
+  return success3(reply, data, 201);
+}
+function noContent(reply) {
+  return reply.status(204).send();
+}
+
+// src/modules/validation/validator.ts
+import { z as z3 } from "zod";
+function validateBody(schema, data) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new ValidationError(formatZodErrors(result.error));
+  }
+  return result.data;
+}
+function validateQuery(schema, data) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new ValidationError(formatZodErrors(result.error));
+  }
+  return result.data;
+}
+function formatZodErrors(error2) {
+  const errors = {};
+  for (const issue of error2.issues) {
+    const path6 = issue.path.join(".") || "root";
+    if (!errors[path6]) {
+      errors[path6] = [];
+    }
+    errors[path6].push(issue.message);
+  }
+  return errors;
+}
+var idParamSchema = z3.object({
+  id: z3.string().uuid("Invalid ID format")
+});
+var paginationSchema = z3.object({
+  page: z3.string().transform(Number).optional().default("1"),
+  limit: z3.string().transform(Number).optional().default("20"),
+  sortBy: z3.string().optional(),
+  sortOrder: z3.enum(["asc", "desc"]).optional().default("asc")
+});
+var searchSchema = z3.object({
+  q: z3.string().min(1, "Search query is required").optional(),
+  search: z3.string().min(1).optional()
+});
+var emailSchema = z3.string().email("Invalid email address");
+var passwordSchema = z3.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number").regex(/[^A-Za-z0-9]/, "Password must contain at least one special character");
+var urlSchema = z3.string().url("Invalid URL format");
+var phoneSchema = z3.string().regex(
+  /^\+?[1-9]\d{1,14}$/,
+  "Invalid phone number format"
+);
+var dateSchema = z3.coerce.date();
+var futureDateSchema = z3.coerce.date().refine(
+  (date) => date > /* @__PURE__ */ new Date(),
+  "Date must be in the future"
+);
+var pastDateSchema = z3.coerce.date().refine(
+  (date) => date < /* @__PURE__ */ new Date(),
+  "Date must be in the past"
+);
+
+// src/modules/auth/auth.controller.ts
+var AuthController = class {
+  constructor(authService, userService) {
+    this.authService = authService;
+    this.userService = userService;
+  }
+  async register(request, reply) {
+    const data = validateBody(registerSchema, request.body);
+    const existingUser = await this.userService.findByEmail(data.email);
+    if (existingUser) {
+      throw new BadRequestError("Email already registered");
+    }
+    const hashedPassword = await this.authService.hashPassword(data.password);
+    const user = await this.userService.create({
+      email: data.email,
+      password: hashedPassword,
+      name: data.name
+    });
+    const tokens = this.authService.generateTokenPair({
+      id: user.id,
+      email: user.email,
+      role: user.role
+    });
+    created(reply, {
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        role: user.role
+      },
+      ...tokens
+    });
+  }
+  async login(request, reply) {
+    const data = validateBody(loginSchema, request.body);
+    const user = await this.userService.findByEmail(data.email);
+    if (!user) {
+      throw new UnauthorizedError("Invalid credentials");
+    }
+    if (user.status !== "active") {
+      throw new UnauthorizedError("Account is not active");
+    }
+    const isValidPassword = await this.authService.verifyPassword(data.password, user.password);
+    if (!isValidPassword) {
+      throw new UnauthorizedError("Invalid credentials");
+    }
+    await this.userService.updateLastLogin(user.id);
+    const tokens = this.authService.generateTokenPair({
+      id: user.id,
+      email: user.email,
+      role: user.role
+    });
+    success3(reply, {
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        role: user.role
+      },
+      ...tokens
+    });
+  }
+  async refresh(request, reply) {
+    const data = validateBody(refreshTokenSchema, request.body);
+    const payload = await this.authService.verifyRefreshToken(data.refreshToken);
+    const user = await this.userService.findById(payload.sub);
+    if (!user || user.status !== "active") {
+      throw new UnauthorizedError("User not found or inactive");
+    }
+    this.authService.blacklistToken(data.refreshToken);
+    const tokens = this.authService.generateTokenPair({
+      id: user.id,
+      email: user.email,
+      role: user.role
+    });
+    success3(reply, tokens);
+  }
+  async logout(request, reply) {
+    const authHeader = request.headers.authorization;
+    if (authHeader?.startsWith("Bearer ")) {
+      const token = authHeader.substring(7);
+      this.authService.blacklistToken(token);
+    }
+    success3(reply, { message: "Logged out successfully" });
+  }
+  async me(request, reply) {
+    const authRequest = request;
+    const user = await this.userService.findById(authRequest.user.id);
+    if (!user) {
+      throw new UnauthorizedError("User not found");
+    }
+    success3(reply, {
+      id: user.id,
+      email: user.email,
+      name: user.name,
+      role: user.role,
+      status: user.status,
+      createdAt: user.createdAt
+    });
+  }
+  async changePassword(request, reply) {
+    const authRequest = request;
+    const data = validateBody(changePasswordSchema, request.body);
+    const user = await this.userService.findById(authRequest.user.id);
+    if (!user) {
+      throw new UnauthorizedError("User not found");
+    }
+    const isValidPassword = await this.authService.verifyPassword(
+      data.currentPassword,
+      user.password
+    );
+    if (!isValidPassword) {
+      throw new BadRequestError("Current password is incorrect");
+    }
+    const hashedPassword = await this.authService.hashPassword(data.newPassword);
+    await this.userService.updatePassword(user.id, hashedPassword);
+    success3(reply, { message: "Password changed successfully" });
+  }
+};
+function createAuthController(authService, userService) {
+  return new AuthController(authService, userService);
+}
+
+// src/modules/auth/auth.middleware.ts
+function createAuthMiddleware(authService) {
+  return async function authenticate(request, reply) {
+    const authHeader = request.headers.authorization;
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      throw new UnauthorizedError("Missing or invalid authorization header");
+    }
+    const token = authHeader.substring(7);
+    const payload = await authService.verifyAccessToken(token);
+    request.user = {
+      id: payload.sub,
+      email: payload.email,
+      role: payload.role
+    };
+  };
+}
+function createRoleMiddleware(allowedRoles) {
+  return async function authorize(request, _reply) {
+    const user = request.user;
+    if (!user) {
+      throw new UnauthorizedError("Authentication required");
+    }
+    if (!allowedRoles.includes(user.role)) {
+      throw new ForbiddenError("Insufficient permissions");
+    }
+  };
+}
+
+// src/modules/auth/auth.routes.ts
+var credentialsBody = {
+  type: "object",
+  required: ["email", "password"],
+  properties: {
+    email: { type: "string", format: "email" },
+    password: { type: "string", minLength: 8 }
+  }
+};
+var changePasswordBody = {
+  type: "object",
+  required: ["currentPassword", "newPassword"],
+  properties: {
+    currentPassword: { type: "string", minLength: 8 },
+    newPassword: { type: "string", minLength: 8 }
+  }
+};
+function registerAuthRoutes(app, controller, authService) {
+  const authenticate = createAuthMiddleware(authService);
+  app.post("/auth/register", {
+    schema: {
+      tags: ["Auth"],
+      summary: "Register a new user",
+      body: credentialsBody,
+      response: {
+        201: commonResponses.success,
+        400: commonResponses.error,
+        409: commonResponses.error
+      }
+    },
+    handler: controller.register.bind(controller)
+  });
+  app.post("/auth/login", {
+    schema: {
+      tags: ["Auth"],
+      summary: "Login and obtain tokens",
+      body: credentialsBody,
+      response: {
+        200: commonResponses.success,
+        400: commonResponses.error,
+        401: commonResponses.unauthorized
+      }
+    },
+    handler: controller.login.bind(controller)
+  });
+  app.post("/auth/refresh", {
+    schema: {
+      tags: ["Auth"],
+      summary: "Refresh access token",
+      body: {
+        type: "object",
+        required: ["refreshToken"],
+        properties: {
+          refreshToken: { type: "string" }
+        }
+      },
+      response: {
+        200: commonResponses.success,
+        401: commonResponses.unauthorized
+      }
+    },
+    handler: controller.refresh.bind(controller)
+  });
+  app.post("/auth/logout", {
+    preHandler: [authenticate],
+    schema: {
+      tags: ["Auth"],
+      summary: "Logout current user",
+      security: [{ bearerAuth: [] }],
+      response: {
+        200: commonResponses.success,
+        401: commonResponses.unauthorized
+      }
+    },
+    handler: controller.logout.bind(controller)
+  });
+  app.get("/auth/me", {
+    preHandler: [authenticate],
+    schema: {
+      tags: ["Auth"],
+      summary: "Get current user profile",
+      security: [{ bearerAuth: [] }],
+      response: {
+        200: commonResponses.success,
+        401: commonResponses.unauthorized
+      }
+    },
+    handler: controller.me.bind(controller)
+  });
+  app.post("/auth/change-password", {
+    preHandler: [authenticate],
+    schema: {
+      tags: ["Auth"],
+      summary: "Change current user password",
+      security: [{ bearerAuth: [] }],
+      body: changePasswordBody,
+      response: {
+        200: commonResponses.success,
+        400: commonResponses.error,
+        401: commonResponses.unauthorized
+      }
+    },
+    handler: controller.changePassword.bind(controller)
+  });
+}
+
+// src/modules/user/user.repository.ts
+import { randomUUID } from "crypto";
+
+// src/utils/pagination.ts
+var DEFAULT_PAGE = 1;
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 100;
+function parsePaginationParams(query) {
+  const page = Math.max(1, parseInt(String(query.page || DEFAULT_PAGE), 10));
+  const limit = Math.min(MAX_LIMIT, Math.max(1, parseInt(String(query.limit || DEFAULT_LIMIT), 10)));
+  const sortBy = typeof query.sortBy === "string" ? query.sortBy : void 0;
+  const sortOrder = query.sortOrder === "desc" ? "desc" : "asc";
+  return { page, limit, sortBy, sortOrder };
+}
+function createPaginatedResult(data, total, params) {
+  const totalPages = Math.ceil(total / params.limit);
+  return {
+    data,
+    meta: {
+      total,
+      page: params.page,
+      limit: params.limit,
+      totalPages,
+      hasNextPage: params.page < totalPages,
+      hasPrevPage: params.page > 1
+    }
+  };
+}
+function getSkip(params) {
+  return (params.page - 1) * params.limit;
+}
+
+// src/modules/user/user.repository.ts
+var users = /* @__PURE__ */ new Map();
+var UserRepository = class {
+  async findById(id) {
+    return users.get(id) || null;
+  }
+  async findByEmail(email) {
+    for (const user of users.values()) {
+      if (user.email.toLowerCase() === email.toLowerCase()) {
+        return user;
+      }
+    }
+    return null;
+  }
+  async findMany(params, filters) {
+    let filteredUsers = Array.from(users.values());
+    if (filters) {
+      if (filters.status) {
+        filteredUsers = filteredUsers.filter((u) => u.status === filters.status);
+      }
+      if (filters.role) {
+        filteredUsers = filteredUsers.filter((u) => u.role === filters.role);
+      }
+      if (filters.emailVerified !== void 0) {
+        filteredUsers = filteredUsers.filter((u) => u.emailVerified === filters.emailVerified);
+      }
+      if (filters.search) {
+        const search = filters.search.toLowerCase();
+        filteredUsers = filteredUsers.filter(
+          (u) => u.email.toLowerCase().includes(search) || u.name?.toLowerCase().includes(search)
+        );
+      }
+    }
+    if (params.sortBy) {
+      const sortKey = params.sortBy;
+      filteredUsers.sort((a, b) => {
+        const aVal = a[sortKey];
+        const bVal = b[sortKey];
+        if (aVal === void 0 || bVal === void 0) return 0;
+        if (aVal < bVal) return params.sortOrder === "desc" ? 1 : -1;
+        if (aVal > bVal) return params.sortOrder === "desc" ? -1 : 1;
+        return 0;
+      });
+    }
+    const total = filteredUsers.length;
+    const skip = getSkip(params);
+    const data = filteredUsers.slice(skip, skip + params.limit);
+    return createPaginatedResult(data, total, params);
+  }
+  async create(data) {
+    const now = /* @__PURE__ */ new Date();
+    const user = {
+      id: randomUUID(),
+      email: data.email,
+      password: data.password,
+      name: data.name,
+      role: data.role || "user",
+      status: "active",
+      emailVerified: false,
+      createdAt: now,
+      updatedAt: now
+    };
+    users.set(user.id, user);
+    return user;
+  }
+  async update(id, data) {
+    const user = users.get(id);
+    if (!user) return null;
+    const updatedUser = {
+      ...user,
+      ...data,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    users.set(id, updatedUser);
+    return updatedUser;
+  }
+  async updatePassword(id, password) {
+    const user = users.get(id);
+    if (!user) return null;
+    const updatedUser = {
+      ...user,
+      password,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    users.set(id, updatedUser);
+    return updatedUser;
+  }
+  async updateLastLogin(id) {
+    const user = users.get(id);
+    if (!user) return null;
+    const updatedUser = {
+      ...user,
+      lastLoginAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    users.set(id, updatedUser);
+    return updatedUser;
+  }
+  async delete(id) {
+    return users.delete(id);
+  }
+  async count(filters) {
+    let count = 0;
+    for (const user of users.values()) {
+      if (filters) {
+        if (filters.status && user.status !== filters.status) continue;
+        if (filters.role && user.role !== filters.role) continue;
+        if (filters.emailVerified !== void 0 && user.emailVerified !== filters.emailVerified)
+          continue;
+      }
+      count++;
+    }
+    return count;
+  }
+  // Helper to clear all users (for testing)
+  async clear() {
+    users.clear();
+  }
+};
+function createUserRepository() {
+  return new UserRepository();
+}
+
+// src/modules/user/types.ts
+var DEFAULT_ROLE_PERMISSIONS = {
+  user: ["profile:read", "profile:update"],
+  moderator: [
+    "profile:read",
+    "profile:update",
+    "users:read",
+    "content:read",
+    "content:update",
+    "content:delete"
+  ],
+  admin: [
+    "profile:read",
+    "profile:update",
+    "users:read",
+    "users:update",
+    "users:delete",
+    "content:manage",
+    "settings:read"
+  ],
+  super_admin: ["*:manage"]
+  // All permissions
+};
+
+// src/modules/user/user.service.ts
+var UserService = class {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async findById(id) {
+    return this.repository.findById(id);
+  }
+  async findByEmail(email) {
+    return this.repository.findByEmail(email);
+  }
+  async findMany(params, filters) {
+    const result = await this.repository.findMany(params, filters);
+    return {
+      ...result,
+      data: result.data.map(({ password, ...user }) => user)
+    };
+  }
+  async create(data) {
+    const existing = await this.repository.findByEmail(data.email);
+    if (existing) {
+      throw new ConflictError("User with this email already exists");
+    }
+    const user = await this.repository.create(data);
+    logger.info({ userId: user.id, email: user.email }, "User created");
+    return user;
+  }
+  async update(id, data) {
+    const user = await this.repository.findById(id);
+    if (!user) {
+      throw new NotFoundError("User");
+    }
+    if (data.email && data.email !== user.email) {
+      const existing = await this.repository.findByEmail(data.email);
+      if (existing) {
+        throw new ConflictError("Email already in use");
+      }
+    }
+    const updatedUser = await this.repository.update(id, data);
+    if (!updatedUser) {
+      throw new NotFoundError("User");
+    }
+    logger.info({ userId: id }, "User updated");
+    return updatedUser;
+  }
+  async updatePassword(id, hashedPassword) {
+    const user = await this.repository.updatePassword(id, hashedPassword);
+    if (!user) {
+      throw new NotFoundError("User");
+    }
+    logger.info({ userId: id }, "User password updated");
+    return user;
+  }
+  async updateLastLogin(id) {
+    const user = await this.repository.updateLastLogin(id);
+    if (!user) {
+      throw new NotFoundError("User");
+    }
+    return user;
+  }
+  async delete(id) {
+    const user = await this.repository.findById(id);
+    if (!user) {
+      throw new NotFoundError("User");
+    }
+    await this.repository.delete(id);
+    logger.info({ userId: id }, "User deleted");
+  }
+  async suspend(id) {
+    return this.update(id, { status: "suspended" });
+  }
+  async ban(id) {
+    return this.update(id, { status: "banned" });
+  }
+  async activate(id) {
+    return this.update(id, { status: "active" });
+  }
+  async verifyEmail(id) {
+    return this.update(id, { emailVerified: true });
+  }
+  async changeRole(id, role) {
+    return this.update(id, { role });
+  }
+  // RBAC helpers
+  hasPermission(role, permission) {
+    const permissions = DEFAULT_ROLE_PERMISSIONS[role] || [];
+    if (permissions.includes("*:manage")) {
+      return true;
+    }
+    if (permissions.includes(permission)) {
+      return true;
+    }
+    const [resource, action] = permission.split(":");
+    const managePermission = `${resource}:manage`;
+    if (permissions.includes(managePermission)) {
+      return true;
+    }
+    return false;
+  }
+  getPermissions(role) {
+    return DEFAULT_ROLE_PERMISSIONS[role] || [];
+  }
+};
+function createUserService(repository) {
+  return new UserService(repository || createUserRepository());
+}
+
+// src/modules/auth/index.ts
+async function registerAuthModule(app) {
+  await app.register(jwt, {
+    secret: config.jwt.secret,
+    sign: {
+      algorithm: "HS256"
+    }
+  });
+  await app.register(cookie, {
+    secret: config.jwt.secret,
+    hook: "onRequest"
+  });
+  const authService = createAuthService(app);
+  const userService = createUserService();
+  const authController = createAuthController(authService, userService);
+  registerAuthRoutes(app, authController, authService);
+  logger.info("Auth module registered");
+  return authService;
+}
+
+// src/modules/user/schemas.ts
+import { z as z4 } from "zod";
+var userStatusEnum = z4.enum(["active", "inactive", "suspended", "banned"]);
+var userRoleEnum = z4.enum(["user", "admin", "moderator", "super_admin"]);
+var createUserSchema = z4.object({
+  email: z4.string().email("Invalid email address"),
+  password: z4.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number"),
+  name: z4.string().min(2, "Name must be at least 2 characters").optional(),
+  role: userRoleEnum.optional().default("user")
+});
+var updateUserSchema = z4.object({
+  email: z4.string().email("Invalid email address").optional(),
+  name: z4.string().min(2, "Name must be at least 2 characters").optional(),
+  role: userRoleEnum.optional(),
+  status: userStatusEnum.optional(),
+  emailVerified: z4.boolean().optional(),
+  metadata: z4.record(z4.unknown()).optional()
+});
+var updateProfileSchema = z4.object({
+  name: z4.string().min(2, "Name must be at least 2 characters").optional(),
+  metadata: z4.record(z4.unknown()).optional()
+});
+var userQuerySchema = z4.object({
+  page: z4.string().transform(Number).optional(),
+  limit: z4.string().transform(Number).optional(),
+  sortBy: z4.string().optional(),
+  sortOrder: z4.enum(["asc", "desc"]).optional(),
+  status: userStatusEnum.optional(),
+  role: userRoleEnum.optional(),
+  search: z4.string().optional(),
+  emailVerified: z4.string().transform((val) => val === "true").optional()
+});
+
+// src/modules/user/user.controller.ts
+var UserController = class {
+  constructor(userService) {
+    this.userService = userService;
+  }
+  async list(request, reply) {
+    const query = validateQuery(userQuerySchema, request.query);
+    const pagination = parsePaginationParams(query);
+    const filters = {
+      status: query.status,
+      role: query.role,
+      search: query.search,
+      emailVerified: query.emailVerified
+    };
+    const result = await this.userService.findMany(pagination, filters);
+    success3(reply, result);
+  }
+  async getById(request, reply) {
+    const user = await this.userService.findById(request.params.id);
+    if (!user) {
+      return reply.status(404).send({
+        success: false,
+        message: "User not found"
+      });
+    }
+    const { password, ...userData } = user;
+    success3(reply, userData);
+  }
+  async update(request, reply) {
+    const data = validateBody(updateUserSchema, request.body);
+    const user = await this.userService.update(request.params.id, data);
+    const { password, ...userData } = user;
+    success3(reply, userData);
+  }
+  async delete(request, reply) {
+    const authRequest = request;
+    if (authRequest.user.id === request.params.id) {
+      throw new ForbiddenError("Cannot delete your own account");
+    }
+    await this.userService.delete(request.params.id);
+    noContent(reply);
+  }
+  async suspend(request, reply) {
+    const authRequest = request;
+    if (authRequest.user.id === request.params.id) {
+      throw new ForbiddenError("Cannot suspend your own account");
+    }
+    const user = await this.userService.suspend(request.params.id);
+    const { password, ...userData } = user;
+    success3(reply, userData);
+  }
+  async ban(request, reply) {
+    const authRequest = request;
+    if (authRequest.user.id === request.params.id) {
+      throw new ForbiddenError("Cannot ban your own account");
+    }
+    const user = await this.userService.ban(request.params.id);
+    const { password, ...userData } = user;
+    success3(reply, userData);
+  }
+  async activate(request, reply) {
+    const user = await this.userService.activate(request.params.id);
+    const { password, ...userData } = user;
+    success3(reply, userData);
+  }
+  // Profile routes (for authenticated user)
+  async getProfile(request, reply) {
+    const authRequest = request;
+    const user = await this.userService.findById(authRequest.user.id);
+    if (!user) {
+      return reply.status(404).send({
+        success: false,
+        message: "User not found"
+      });
+    }
+    const { password, ...userData } = user;
+    success3(reply, userData);
+  }
+  async updateProfile(request, reply) {
+    const authRequest = request;
+    const data = validateBody(updateProfileSchema, request.body);
+    const user = await this.userService.update(authRequest.user.id, data);
+    const { password, ...userData } = user;
+    success3(reply, userData);
+  }
+};
+function createUserController(userService) {
+  return new UserController(userService);
+}
+
+// src/modules/user/user.routes.ts
+var userTag = "Users";
+var userResponse = {
+  type: "object",
+  properties: {
+    success: { type: "boolean", example: true },
+    data: { type: "object" }
+  }
+};
+function registerUserRoutes(app, controller, authService) {
+  const authenticate = createAuthMiddleware(authService);
+  const isAdmin = createRoleMiddleware(["admin", "super_admin"]);
+  const isModerator = createRoleMiddleware(["moderator", "admin", "super_admin"]);
+  app.get(
+    "/profile",
+    {
+      preHandler: [authenticate],
+      schema: {
+        tags: [userTag],
+        summary: "Get current user profile",
+        security: [{ bearerAuth: [] }],
+        response: {
+          200: userResponse,
+          401: commonResponses.unauthorized
+        }
+      }
+    },
+    controller.getProfile.bind(controller)
+  );
+  app.patch(
+    "/profile",
+    {
+      preHandler: [authenticate],
+      schema: {
+        tags: [userTag],
+        summary: "Update current user profile",
+        security: [{ bearerAuth: [] }],
+        body: { type: "object" },
+        response: {
+          200: userResponse,
+          401: commonResponses.unauthorized,
+          400: commonResponses.error
+        }
+      }
+    },
+    controller.updateProfile.bind(controller)
+  );
+  app.get(
+    "/users",
+    {
+      preHandler: [authenticate, isModerator],
+      schema: {
+        tags: [userTag],
+        summary: "List users",
+        security: [{ bearerAuth: [] }],
+        querystring: {
+          ...paginationQuery,
+          properties: {
+            ...paginationQuery.properties,
+            status: { type: "string", enum: ["active", "inactive", "suspended", "banned"] },
+            role: { type: "string", enum: ["user", "admin", "moderator", "super_admin"] },
+            search: { type: "string" },
+            emailVerified: { type: "boolean" }
+          }
+        },
+        response: {
+          200: commonResponses.paginated,
+          401: commonResponses.unauthorized
+        }
+      }
+    },
+    controller.list.bind(controller)
+  );
+  app.get(
+    "/users/:id",
+    {
+      preHandler: [authenticate, isModerator],
+      schema: {
+        tags: [userTag],
+        summary: "Get user by id",
+        security: [{ bearerAuth: [] }],
+        params: idParam,
+        response: {
+          200: userResponse,
+          401: commonResponses.unauthorized,
+          404: commonResponses.notFound
+        }
+      }
+    },
+    controller.getById.bind(controller)
+  );
+  app.patch(
+    "/users/:id",
+    {
+      preHandler: [authenticate, isAdmin],
+      schema: {
+        tags: [userTag],
+        summary: "Update user",
+        security: [{ bearerAuth: [] }],
+        params: idParam,
+        body: { type: "object" },
+        response: {
+          200: userResponse,
+          401: commonResponses.unauthorized,
+          404: commonResponses.notFound
+        }
+      }
+    },
+    controller.update.bind(controller)
+  );
+  app.delete(
+    "/users/:id",
+    {
+      preHandler: [authenticate, isAdmin],
+      schema: {
+        tags: [userTag],
+        summary: "Delete user",
+        security: [{ bearerAuth: [] }],
+        params: idParam,
+        response: {
+          204: { description: "User deleted" },
+          401: commonResponses.unauthorized,
+          404: commonResponses.notFound
+        }
+      }
+    },
+    controller.delete.bind(controller)
+  );
+  app.post(
+    "/users/:id/suspend",
+    {
+      preHandler: [authenticate, isAdmin],
+      schema: {
+        tags: [userTag],
+        summary: "Suspend user",
+        security: [{ bearerAuth: [] }],
+        params: idParam,
+        response: {
+          200: userResponse,
+          401: commonResponses.unauthorized,
+          404: commonResponses.notFound
+        }
+      }
+    },
+    controller.suspend.bind(controller)
+  );
+  app.post(
+    "/users/:id/ban",
+    {
+      preHandler: [authenticate, isAdmin],
+      schema: {
+        tags: [userTag],
+        summary: "Ban user",
+        security: [{ bearerAuth: [] }],
+        params: idParam,
+        response: {
+          200: userResponse,
+          401: commonResponses.unauthorized,
+          404: commonResponses.notFound
+        }
+      }
+    },
+    controller.ban.bind(controller)
+  );
+  app.post(
+    "/users/:id/activate",
+    {
+      preHandler: [authenticate, isAdmin],
+      schema: {
+        tags: [userTag],
+        summary: "Activate user",
+        security: [{ bearerAuth: [] }],
+        params: idParam,
+        response: {
+          200: userResponse,
+          401: commonResponses.unauthorized,
+          404: commonResponses.notFound
+        }
+      }
+    },
+    controller.activate.bind(controller)
+  );
+}
+
+// src/modules/user/index.ts
+async function registerUserModule(app, authService) {
+  const repository = createUserRepository();
+  const userService = createUserService(repository);
+  const userController = createUserController(userService);
+  registerUserRoutes(app, userController, authService);
+  logger.info("User module registered");
+}
+
+// src/cli/utils/docs-generator.ts
+async function generateDocs(outputPath = "openapi.json", silent = false) {
+  const spinner = silent ? null : ora2("Generating OpenAPI documentation...").start();
+  try {
+    const server = createServer({
+      port: config.server.port,
+      host: config.server.host
+    });
+    const app = server.instance;
+    registerErrorHandler(app);
+    await registerSecurity(app);
+    await registerSwagger(app, {
+      enabled: true,
+      route: config.swagger.route,
+      title: config.swagger.title,
+      description: config.swagger.description,
+      version: config.swagger.version
+    });
+    const authService = await registerAuthModule(app);
+    await registerUserModule(app, authService);
+    await app.ready();
+    const spec = app.swagger();
+    const absoluteOutput = path3.resolve(outputPath);
+    await fs3.mkdir(path3.dirname(absoluteOutput), { recursive: true });
+    await fs3.writeFile(absoluteOutput, JSON.stringify(spec, null, 2), "utf8");
+    spinner?.succeed(`OpenAPI spec generated at ${absoluteOutput}`);
+    await app.close();
+    return absoluteOutput;
+  } catch (error2) {
+    spinner?.fail("Failed to generate OpenAPI documentation");
+    throw error2;
+  }
+}
+
+// src/cli/commands/generate.ts
+var generateCommand = new Command2("generate").alias("g").description("Generate resources (module, controller, service, etc.)");
+generateCommand.command("module <name> [fields...]").alias("m").description("Generate a complete module with controller, service, repository, types, schemas, and routes").option("--no-routes", "Skip routes generation").option("--no-repository", "Skip repository generation").option("--prisma", "Generate Prisma model suggestion").option("--validator <type>", "Validator type: zod, joi, yup", "zod").option("-i, --interactive", "Interactive mode to define fields").action(async (name, fieldsArgs, options) => {
+  let fields = [];
+  if (options.interactive) {
+    fields = await promptForFields();
+  } else if (fieldsArgs.length > 0) {
+    fields = parseFields(fieldsArgs.join(" "));
+  }
+  const spinner = ora3("Generating module...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const pluralName = pluralize(kebabName);
+    const tableName = pluralize(kebabName.replace(/-/g, "_"));
+    const validatorType = options.validator || "zod";
+    const moduleDir = path4.join(getModulesDir(), kebabName);
+    if (await fileExists(moduleDir)) {
+      spinner.stop();
+      error(`Module "${kebabName}" already exists`);
+      return;
+    }
+    const hasFields = fields.length > 0;
+    const files = [
+      {
+        name: `${kebabName}.types.ts`,
+        content: hasFields ? dynamicTypesTemplate(kebabName, pascalName, fields) : typesTemplate(kebabName, pascalName)
+      },
+      {
+        name: `${kebabName}.schemas.ts`,
+        content: hasFields ? dynamicSchemasTemplate(kebabName, pascalName, camelName, fields, validatorType) : schemasTemplate(kebabName, pascalName, camelName)
+      },
+      { name: `${kebabName}.service.ts`, content: serviceTemplate(kebabName, pascalName, camelName) },
+      { name: `${kebabName}.controller.ts`, content: controllerTemplate(kebabName, pascalName, camelName) },
+      { name: "index.ts", content: moduleIndexTemplate(kebabName, pascalName, camelName) }
+    ];
+    if (options.repository !== false) {
+      files.push({
+        name: `${kebabName}.repository.ts`,
+        content: repositoryTemplate(kebabName, pascalName, camelName, pluralName)
+      });
+    }
+    if (options.routes !== false) {
+      files.push({
+        name: `${kebabName}.routes.ts`,
+        content: routesTemplate(kebabName, pascalName, camelName, pluralName, fields)
+      });
+    }
+    for (const file of files) {
+      await writeFile(path4.join(moduleDir, file.name), file.content);
+    }
+    spinner.succeed(`Module "${pascalName}" generated successfully!`);
+    if (options.prisma || hasFields) {
+      console.log("\n" + "\u2500".repeat(50));
+      info("Prisma model suggestion:");
+      if (hasFields) {
+        console.log(dynamicPrismaTemplate(pascalName, tableName, fields));
+      } else {
+        console.log(prismaModelTemplate(kebabName, pascalName, tableName));
+      }
+    }
+    if (hasFields) {
+      console.log("\n\u{1F4CB} Fields defined:");
+      fields.forEach((f) => {
+        const opts = [];
+        if (f.isOptional) opts.push("optional");
+        if (f.isArray) opts.push("array");
+        if (f.isUnique) opts.push("unique");
+        const optsStr = opts.length > 0 ? ` (${opts.join(", ")})` : "";
+        success(`  ${f.name}: ${f.type}${optsStr}`);
+      });
+    }
+    console.log("\n\u{1F4C1} Files created:");
+    files.forEach((f) => success(`  src/modules/${kebabName}/${f.name}`));
+    console.log("\n\u{1F4CC} Next steps:");
+    if (!hasFields) {
+      info(`  1. Update the types in ${kebabName}.types.ts`);
+      info(`  2. Update the schemas in ${kebabName}.schemas.ts`);
+      info("  3. Register the module in your app");
+    } else {
+      info("  1. Review generated types and schemas");
+      info("  2. Register the module in your app");
+    }
+    if (options.prisma || hasFields) {
+      info(`  ${hasFields ? "3" : "4"}. Add the Prisma model to schema.prisma`);
+      info(`  ${hasFields ? "4" : "5"}. Run: npm run db:migrate`);
+    }
+    const { generateDocsNow } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "generateDocsNow",
+        message: "Generate Swagger/OpenAPI documentation now?",
+        default: true
+      }
+    ]);
+    if (generateDocsNow) {
+      await generateDocs("openapi.json", true);
+    }
+  } catch (err) {
+    spinner.fail("Failed to generate module");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+generateCommand.command("controller <name>").alias("c").description("Generate a controller").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+  const spinner = ora3("Generating controller...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
+    const moduleDir = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.controller.ts`);
+    if (await fileExists(filePath)) {
+      spinner.stop();
+      error(`Controller "${kebabName}" already exists`);
+      return;
+    }
+    await writeFile(filePath, controllerTemplate(kebabName, pascalName, camelName));
+    spinner.succeed(`Controller "${pascalName}Controller" generated!`);
+    success(`  src/modules/${moduleName}/${kebabName}.controller.ts`);
+  } catch (err) {
+    spinner.fail("Failed to generate controller");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+generateCommand.command("service <name>").alias("s").description("Generate a service").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+  const spinner = ora3("Generating service...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
+    const moduleDir = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.service.ts`);
+    if (await fileExists(filePath)) {
+      spinner.stop();
+      error(`Service "${kebabName}" already exists`);
+      return;
+    }
+    await writeFile(filePath, serviceTemplate(kebabName, pascalName, camelName));
+    spinner.succeed(`Service "${pascalName}Service" generated!`);
+    success(`  src/modules/${moduleName}/${kebabName}.service.ts`);
+  } catch (err) {
+    spinner.fail("Failed to generate service");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+generateCommand.command("repository <name>").alias("r").description("Generate a repository").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+  const spinner = ora3("Generating repository...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const pluralName = pluralize(kebabName);
+    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
+    const moduleDir = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.repository.ts`);
+    if (await fileExists(filePath)) {
+      spinner.stop();
+      error(`Repository "${kebabName}" already exists`);
+      return;
+    }
+    await writeFile(filePath, repositoryTemplate(kebabName, pascalName, camelName, pluralName));
+    spinner.succeed(`Repository "${pascalName}Repository" generated!`);
+    success(`  src/modules/${moduleName}/${kebabName}.repository.ts`);
+  } catch (err) {
+    spinner.fail("Failed to generate repository");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+generateCommand.command("types <name>").alias("t").description("Generate types/interfaces").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+  const spinner = ora3("Generating types...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
+    const moduleDir = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.types.ts`);
+    if (await fileExists(filePath)) {
+      spinner.stop();
+      error(`Types file "${kebabName}.types.ts" already exists`);
+      return;
+    }
+    await writeFile(filePath, typesTemplate(kebabName, pascalName));
+    spinner.succeed(`Types for "${pascalName}" generated!`);
+    success(`  src/modules/${moduleName}/${kebabName}.types.ts`);
+  } catch (err) {
+    spinner.fail("Failed to generate types");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+generateCommand.command("schema <name>").alias("v").description("Generate validation schemas").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+  const spinner = ora3("Generating schemas...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
+    const moduleDir = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.schemas.ts`);
+    if (await fileExists(filePath)) {
+      spinner.stop();
+      error(`Schemas file "${kebabName}.schemas.ts" already exists`);
+      return;
+    }
+    await writeFile(filePath, schemasTemplate(kebabName, pascalName, camelName));
+    spinner.succeed(`Schemas for "${pascalName}" generated!`);
+    success(`  src/modules/${moduleName}/${kebabName}.schemas.ts`);
+  } catch (err) {
+    spinner.fail("Failed to generate schemas");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+generateCommand.command("routes <name>").description("Generate routes").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+  const spinner = ora3("Generating routes...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const pluralName = pluralize(kebabName);
+    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
+    const moduleDir = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.routes.ts`);
+    if (await fileExists(filePath)) {
+      spinner.stop();
+      error(`Routes file "${kebabName}.routes.ts" already exists`);
+      return;
+    }
+    await writeFile(filePath, routesTemplate(kebabName, pascalName, camelName, pluralName));
+    spinner.succeed(`Routes for "${pascalName}" generated!`);
+    success(`  src/modules/${moduleName}/${kebabName}.routes.ts`);
+  } catch (err) {
+    spinner.fail("Failed to generate routes");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+async function promptForFields() {
+  const fields = [];
+  console.log("\n\u{1F4DD} Define your model fields (press Enter with empty name to finish)\n");
+  const fieldTypes = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "datetime",
+    "text",
+    "email",
+    "url",
+    "uuid",
+    "int",
+    "float",
+    "decimal",
+    "json"
+  ];
+  let addMore = true;
+  while (addMore) {
+    const answers = await inquirer2.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Field name (empty to finish):"
+      }
+    ]);
+    if (!answers.name) {
+      addMore = false;
+      continue;
+    }
+    const fieldDetails = await inquirer2.prompt([
+      {
+        type: "list",
+        name: "type",
+        message: `Type for "${answers.name}":`,
+        choices: fieldTypes,
+        default: "string"
+      },
+      {
+        type: "confirm",
+        name: "isOptional",
+        message: "Is optional?",
+        default: false
+      },
+      {
+        type: "confirm",
+        name: "isUnique",
+        message: "Is unique?",
+        default: false
+      },
+      {
+        type: "confirm",
+        name: "isArray",
+        message: "Is array?",
+        default: false
+      }
+    ]);
+    fields.push({
+      name: answers.name,
+      type: fieldDetails.type,
+      isOptional: fieldDetails.isOptional,
+      isUnique: fieldDetails.isUnique,
+      isArray: fieldDetails.isArray
+    });
+    console.log(`  \u2713 Added: ${answers.name}: ${fieldDetails.type}
+`);
+  }
+  return fields;
+}
+
+// src/cli/commands/add-module.ts
+import { Command as Command3 } from "commander";
+import path5 from "path";
+import ora4 from "ora";
+import chalk3 from "chalk";
+var AVAILABLE_MODULES = {
+  auth: {
+    name: "Authentication",
+    description: "JWT authentication with access/refresh tokens",
+    files: ["auth.service", "auth.controller", "auth.routes", "auth.middleware", "auth.schemas", "auth.types", "index"]
+  },
+  users: {
+    name: "User Management",
+    description: "User CRUD with RBAC (roles & permissions)",
+    files: ["user.service", "user.controller", "user.repository", "user.routes", "user.schemas", "user.types", "index"]
+  },
+  email: {
+    name: "Email Service",
+    description: "SMTP email with templates (Handlebars)",
+    files: ["email.service", "email.templates", "email.types", "index"]
+  },
+  audit: {
+    name: "Audit Logs",
+    description: "Activity logging and audit trail",
+    files: ["audit.service", "audit.types", "index"]
+  },
+  upload: {
+    name: "File Upload",
+    description: "File upload with local/S3 storage",
+    files: ["upload.service", "upload.controller", "upload.routes", "upload.types", "index"]
+  },
+  cache: {
+    name: "Redis Cache",
+    description: "Redis caching service",
+    files: ["cache.service", "cache.types", "index"]
+  },
+  notifications: {
+    name: "Notifications",
+    description: "In-app and push notifications",
+    files: ["notification.service", "notification.types", "index"]
+  },
+  settings: {
+    name: "Settings",
+    description: "Application settings management",
+    files: ["settings.service", "settings.controller", "settings.routes", "settings.types", "index"]
+  }
+};
+var addModuleCommand = new Command3("add").description("Add a pre-built module to your project").argument("[module]", "Module to add (auth, users, email, audit, upload, cache, notifications, settings)").option("-l, --list", "List available modules").action(async (moduleName, options) => {
+  if (options?.list || !moduleName) {
+    console.log(chalk3.bold("\n\u{1F4E6} Available Modules:\n"));
+    for (const [key, mod] of Object.entries(AVAILABLE_MODULES)) {
+      console.log(`  ${chalk3.cyan(key.padEnd(15))} ${mod.name}`);
+      console.log(`  ${" ".repeat(15)} ${chalk3.gray(mod.description)}
+`);
+    }
+    console.log(chalk3.bold("Usage:"));
+    console.log(`  ${chalk3.yellow("servcraft add auth")}      Add authentication module`);
+    console.log(`  ${chalk3.yellow("servcraft add users")}     Add user management module`);
+    console.log(`  ${chalk3.yellow("servcraft add email")}     Add email service module
+`);
+    return;
+  }
+  const module = AVAILABLE_MODULES[moduleName];
+  if (!module) {
+    error(`Unknown module: ${moduleName}`);
+    info('Run "servcraft add --list" to see available modules');
+    return;
+  }
+  const spinner = ora4(`Adding ${module.name} module...`).start();
+  try {
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    if (await fileExists(moduleDir)) {
+      spinner.stop();
+      warn(`Module "${moduleName}" already exists`);
+      return;
+    }
+    await ensureDir(moduleDir);
+    switch (moduleName) {
+      case "auth":
+        await generateAuthModule(moduleDir);
+        break;
+      case "users":
+        await generateUsersModule(moduleDir);
+        break;
+      case "email":
+        await generateEmailModule(moduleDir);
+        break;
+      case "audit":
+        await generateAuditModule(moduleDir);
+        break;
+      case "upload":
+        await generateUploadModule(moduleDir);
+        break;
+      case "cache":
+        await generateCacheModule(moduleDir);
+        break;
+      default:
+        await generateGenericModule(moduleDir, moduleName);
+    }
+    spinner.succeed(`${module.name} module added successfully!`);
+    console.log("\n\u{1F4C1} Files created:");
+    module.files.forEach((f) => success(`  src/modules/${moduleName}/${f}.ts`));
+    console.log("\n\u{1F4CC} Next steps:");
+    info("  1. Register the module in your main app file");
+    info("  2. Configure any required environment variables");
+    info("  3. Run database migrations if needed");
+  } catch (err) {
+    spinner.fail("Failed to add module");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+async function generateAuthModule(dir) {
+  const files = {
+    "auth.types.ts": `export interface JwtPayload {
+  sub: string;
+  email: string;
+  role: string;
+  type: 'access' | 'refresh';
+}
+
+export interface TokenPair {
+  accessToken: string;
+  refreshToken: string;
+  expiresIn: number;
+}
+
+export interface AuthUser {
+  id: string;
+  email: string;
+  role: string;
+}
+`,
+    "auth.schemas.ts": `import { z } from 'zod';
+
+export const loginSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(1),
+});
+
+export const registerSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  name: z.string().min(2).optional(),
+});
+
+export const refreshTokenSchema = z.object({
+  refreshToken: z.string().min(1),
+});
+`,
+    "index.ts": `export * from './auth.types.js';
+export * from './auth.schemas.js';
+// Export services, controllers, etc.
+`
+  };
+  for (const [name, content] of Object.entries(files)) {
+    await writeFile(path5.join(dir, name), content);
+  }
+}
+async function generateUsersModule(dir) {
+  const files = {
+    "user.types.ts": `export type UserStatus = 'active' | 'inactive' | 'suspended' | 'banned';
+export type UserRole = 'user' | 'admin' | 'moderator' | 'super_admin';
+
+export interface User {
+  id: string;
+  email: string;
+  password: string;
+  name?: string;
+  role: UserRole;
+  status: UserStatus;
+  createdAt: Date;
+  updatedAt: Date;
+}
+`,
+    "user.schemas.ts": `import { z } from 'zod';
+
+export const createUserSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  name: z.string().min(2).optional(),
+  role: z.enum(['user', 'admin', 'moderator']).optional(),
+});
+
+export const updateUserSchema = z.object({
+  email: z.string().email().optional(),
+  name: z.string().min(2).optional(),
+  role: z.enum(['user', 'admin', 'moderator', 'super_admin']).optional(),
+  status: z.enum(['active', 'inactive', 'suspended', 'banned']).optional(),
+});
+`,
+    "index.ts": `export * from './user.types.js';
+export * from './user.schemas.js';
+`
+  };
+  for (const [name, content] of Object.entries(files)) {
+    await writeFile(path5.join(dir, name), content);
+  }
+}
+async function generateEmailModule(dir) {
+  const files = {
+    "email.types.ts": `export interface EmailOptions {
+  to: string | string[];
+  subject: string;
+  html?: string;
+  text?: string;
+  template?: string;
+  data?: Record<string, unknown>;
+}
+
+export interface EmailResult {
+  success: boolean;
+  messageId?: string;
+  error?: string;
+}
+`,
+    "email.service.ts": `import nodemailer from 'nodemailer';
+import type { EmailOptions, EmailResult } from './email.types.js';
+
+export class EmailService {
+  private transporter;
+
+  constructor() {
+    this.transporter = nodemailer.createTransport({
+      host: process.env.SMTP_HOST,
+      port: parseInt(process.env.SMTP_PORT || '587', 10),
+      auth: {
+        user: process.env.SMTP_USER,
+        pass: process.env.SMTP_PASS,
+      },
+    });
+  }
+
+  async send(options: EmailOptions): Promise<EmailResult> {
+    try {
+      const result = await this.transporter.sendMail({
+        from: process.env.SMTP_FROM,
+        ...options,
+      });
+      return { success: true, messageId: result.messageId };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+}
+
+export const emailService = new EmailService();
+`,
+    "index.ts": `export * from './email.types.js';
+export { EmailService, emailService } from './email.service.js';
+`
+  };
+  for (const [name, content] of Object.entries(files)) {
+    await writeFile(path5.join(dir, name), content);
+  }
+}
+async function generateAuditModule(dir) {
+  const files = {
+    "audit.types.ts": `export interface AuditLogEntry {
+  userId?: string;
+  action: string;
+  resource: string;
+  resourceId?: string;
+  oldValue?: Record<string, unknown>;
+  newValue?: Record<string, unknown>;
+  ipAddress?: string;
+  userAgent?: string;
+  createdAt: Date;
+}
+`,
+    "audit.service.ts": `import type { AuditLogEntry } from './audit.types.js';
+
+const logs: AuditLogEntry[] = [];
+
+export class AuditService {
+  async log(entry: Omit<AuditLogEntry, 'createdAt'>): Promise<void> {
+    logs.push({ ...entry, createdAt: new Date() });
+    console.log('[AUDIT]', entry.action, entry.resource);
+  }
+
+  async query(filters: Partial<AuditLogEntry>): Promise<AuditLogEntry[]> {
+    return logs.filter((log) => {
+      for (const [key, value] of Object.entries(filters)) {
+        if (log[key as keyof AuditLogEntry] !== value) return false;
+      }
+      return true;
+    });
+  }
+}
+
+export const auditService = new AuditService();
+`,
+    "index.ts": `export * from './audit.types.js';
+export { AuditService, auditService } from './audit.service.js';
+`
+  };
+  for (const [name, content] of Object.entries(files)) {
+    await writeFile(path5.join(dir, name), content);
+  }
+}
+async function generateUploadModule(dir) {
+  const files = {
+    "upload.types.ts": `export interface UploadedFile {
+  id: string;
+  filename: string;
+  originalName: string;
+  mimetype: string;
+  size: number;
+  path: string;
+  url: string;
+  createdAt: Date;
+}
+
+export interface UploadOptions {
+  maxSize?: number;
+  allowedTypes?: string[];
+  destination?: string;
+}
+`,
+    "index.ts": `export * from './upload.types.js';
+`
+  };
+  for (const [name, content] of Object.entries(files)) {
+    await writeFile(path5.join(dir, name), content);
+  }
+}
+async function generateCacheModule(dir) {
+  const files = {
+    "cache.types.ts": `export interface CacheOptions {
+  ttl?: number;
+  prefix?: string;
+}
+`,
+    "cache.service.ts": `import type { CacheOptions } from './cache.types.js';
+
+// In-memory cache (replace with Redis in production)
+const cache = new Map<string, { value: unknown; expiry: number }>();
+
+export class CacheService {
+  async get<T>(key: string): Promise<T | null> {
+    const item = cache.get(key);
+    if (!item) return null;
+    if (Date.now() > item.expiry) {
+      cache.delete(key);
+      return null;
+    }
+    return item.value as T;
+  }
+
+  async set(key: string, value: unknown, ttl = 3600): Promise<void> {
+    cache.set(key, { value, expiry: Date.now() + ttl * 1000 });
+  }
+
+  async del(key: string): Promise<void> {
+    cache.delete(key);
+  }
+
+  async clear(): Promise<void> {
+    cache.clear();
+  }
+}
+
+export const cacheService = new CacheService();
+`,
+    "index.ts": `export * from './cache.types.js';
+export { CacheService, cacheService } from './cache.service.js';
+`
+  };
+  for (const [name, content] of Object.entries(files)) {
+    await writeFile(path5.join(dir, name), content);
+  }
+}
+async function generateGenericModule(dir, name) {
+  const files = {
+    [`${name}.types.ts`]: `// ${name} types
+export interface ${name.charAt(0).toUpperCase() + name.slice(1)}Data {
+  // Define your types here
+}
+`,
+    "index.ts": `export * from './${name}.types.js';
+`
+  };
+  for (const [fileName, content] of Object.entries(files)) {
+    await writeFile(path5.join(dir, fileName), content);
+  }
+}
+
+// src/cli/commands/db.ts
+import { Command as Command4 } from "commander";
+import { execSync as execSync2, spawn } from "child_process";
+import ora5 from "ora";
+import chalk4 from "chalk";
+var dbCommand = new Command4("db").description("Database management commands");
+dbCommand.command("migrate").description("Run database migrations").option("-n, --name <name>", "Migration name").action(async (options) => {
+  const spinner = ora5("Running migrations...").start();
+  try {
+    const cmd = options.name ? `npx prisma migrate dev --name ${options.name}` : "npx prisma migrate dev";
+    execSync2(cmd, { stdio: "inherit" });
+    spinner.succeed("Migrations completed!");
+  } catch (err) {
+    spinner.fail("Migration failed");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+dbCommand.command("push").description("Push schema changes to database (no migration)").action(async () => {
+  const spinner = ora5("Pushing schema...").start();
+  try {
+    execSync2("npx prisma db push", { stdio: "inherit" });
+    spinner.succeed("Schema pushed successfully!");
+  } catch (err) {
+    spinner.fail("Push failed");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+dbCommand.command("generate").description("Generate Prisma client").action(async () => {
+  const spinner = ora5("Generating Prisma client...").start();
+  try {
+    execSync2("npx prisma generate", { stdio: "inherit" });
+    spinner.succeed("Prisma client generated!");
+  } catch (err) {
+    spinner.fail("Generation failed");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+dbCommand.command("studio").description("Open Prisma Studio").action(async () => {
+  info("Opening Prisma Studio...");
+  const studio = spawn("npx", ["prisma", "studio"], {
+    stdio: "inherit",
+    shell: true
+  });
+  studio.on("close", (code) => {
+    if (code !== 0) {
+      error("Prisma Studio closed with error");
+    }
+  });
+});
+dbCommand.command("seed").description("Run database seed").action(async () => {
+  const spinner = ora5("Seeding database...").start();
+  try {
+    execSync2("npx prisma db seed", { stdio: "inherit" });
+    spinner.succeed("Database seeded!");
+  } catch (err) {
+    spinner.fail("Seeding failed");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+dbCommand.command("reset").description("Reset database (drop all data and re-run migrations)").option("-f, --force", "Skip confirmation").action(async (options) => {
+  if (!options.force) {
+    console.log(chalk4.yellow("\n\u26A0\uFE0F  WARNING: This will delete all data in your database!\n"));
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question("Are you sure you want to continue? (y/N) ", resolve);
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "y") {
+      info("Operation cancelled");
+      return;
+    }
+  }
+  const spinner = ora5("Resetting database...").start();
+  try {
+    execSync2("npx prisma migrate reset --force", { stdio: "inherit" });
+    spinner.succeed("Database reset completed!");
+  } catch (err) {
+    spinner.fail("Reset failed");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+dbCommand.command("status").description("Show migration status").action(async () => {
+  try {
+    execSync2("npx prisma migrate status", { stdio: "inherit" });
+  } catch (err) {
+    error("Failed to get migration status");
+  }
+});
+
+// src/cli/commands/docs.ts
+import { Command as Command5 } from "commander";
+var docsCommand = new Command5("docs").description("Generate Swagger/OpenAPI documentation").option("-o, --output <path>", "Output file path", "openapi.json").action(async (options) => {
+  try {
+    const outputPath = await generateDocs(options.output);
+    success(`Documentation written to ${outputPath}`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  }
+});
+
+// src/cli/index.ts
+var program = new Command6();
+program.name("servcraft").description("Servcraft - A modular Node.js backend framework CLI").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(generateCommand);
+program.addCommand(addModuleCommand);
+program.addCommand(dbCommand);
+program.addCommand(docsCommand);
+program.parse();
+//# sourceMappingURL=index.js.map