@gravito/scaffold 4.0.0 → 4.1.2

package/dist/index.js

@@ -1008,6 +1008,118 @@ export default {
 }
 `;
   }
+  /**
+   * Generate workers configuration for job queue system
+   */
+  static generateWorkersConfig(level = "basic") {
+    switch (level) {
+      case "advanced":
+        return this.generateAdvancedWorkersConfig();
+      case "production":
+        return this.generateProductionWorkersConfig();
+      default:
+        return this.generateBasicWorkersConfig();
+    }
+  }
+  /**
+   * Generate basic workers configuration
+   */
+  static generateBasicWorkersConfig() {
+    return `  /**
+   * Workers Configuration
+   *
+   * Manages job execution in isolated worker threads.
+   * Automatically selects best available runtime (Bun or Node.js).
+   */
+  workers: {
+    // Runtime environment: 'auto' | 'bun' | 'node'
+    runtime: process.env.WORKERS_RUNTIME as 'auto' | 'bun' | 'node' ?? 'auto',
+
+    pool: {
+      poolSize: Number.parseInt(process.env.WORKERS_POOL_SIZE ?? '4', 10),
+      minWorkers: Number.parseInt(process.env.WORKERS_MIN_WORKERS ?? '0', 10),
+      healthCheckInterval: 30000,
+    },
+
+    execution: {
+      maxExecutionTime: Number.parseInt(process.env.WORKERS_MAX_EXECUTION_TIME ?? '30000', 10),
+      maxMemory: Number.parseInt(process.env.WORKERS_MAX_MEMORY ?? '0', 10),
+      idleTimeout: Number.parseInt(process.env.WORKERS_IDLE_TIMEOUT ?? '60000', 10),
+      isolateContexts: process.env.WORKERS_ISOLATE_CONTEXTS === 'true',
+    },
+  },`;
+  }
+  /**
+   * Generate advanced workers configuration with Bun optimizations
+   */
+  static generateAdvancedWorkersConfig() {
+    return `  /**
+   * Workers Configuration (Advanced)
+   *
+   * Manages job execution in isolated worker threads.
+   * Includes Bun-specific optimizations for enhanced performance.
+   *
+   * Performance characteristics:
+   * - Bun: 2-241x faster message passing, 20-30% less memory (smol mode)
+   * - Node.js: Stable, widely tested, compatible
+   */
+  workers: {
+    runtime: process.env.WORKERS_RUNTIME as 'auto' | 'bun' | 'node' ?? 'auto',
+
+    pool: {
+      poolSize: Number.parseInt(process.env.WORKERS_POOL_SIZE ?? '4', 10),
+      minWorkers: Number.parseInt(process.env.WORKERS_MIN_WORKERS ?? '1', 10),
+      healthCheckInterval: 30000,
+    },
+
+    execution: {
+      maxExecutionTime: Number.parseInt(process.env.WORKERS_MAX_EXECUTION_TIME ?? '30000', 10),
+      maxMemory: Number.parseInt(process.env.WORKERS_MAX_MEMORY ?? '0', 10),
+      idleTimeout: Number.parseInt(process.env.WORKERS_IDLE_TIMEOUT ?? '60000', 10),
+      isolateContexts: process.env.WORKERS_ISOLATE_CONTEXTS === 'true',
+    },
+
+    // Bun-specific optimizations
+    bun: {
+      smol: process.env.WORKERS_BUN_SMOL === 'true',
+      preload: process.env.WORKERS_BUN_PRELOAD
+        ? process.env.WORKERS_BUN_PRELOAD.split(',').map((p) => p.trim())
+        : undefined,
+      inspectPort: process.env.WORKERS_BUN_INSPECT_PORT
+        ? Number.parseInt(process.env.WORKERS_BUN_INSPECT_PORT, 10)
+        : undefined,
+    },
+  },`;
+  }
+  /**
+   * Generate production-optimized workers configuration
+   */
+  static generateProductionWorkersConfig() {
+    return `  /**
+   * Workers Configuration (Production Optimized)
+   */
+  workers: {
+    runtime: 'auto' as const,
+
+    pool: {
+      poolSize: Number.parseInt(process.env.WORKERS_POOL_SIZE ?? '8', 10),
+      minWorkers: 2,
+      healthCheckInterval: 30000,
+    },
+
+    execution: {
+      maxExecutionTime: 30000,
+      maxMemory: Number.parseInt(process.env.WORKERS_MAX_MEMORY ?? '512', 10),
+      idleTimeout: 60000,
+      isolateContexts: false,
+    },
+
+    bun: {
+      smol: true,
+      preload: process.env.WORKERS_BUN_PRELOAD?.split(',').map((p) => p.trim()),
+    },
+  },`;
+  }
 };
 
 // src/utils/ServiceProviderGenerator.ts
@@ -2020,235 +2132,2462 @@ Created with \u2764\uFE0F using Gravito Framework
   }
 };
 
-// src/generators/ddd/BootstrapGenerator.ts
-var BootstrapGenerator = class {
-  context = null;
-  generate(context) {
-    this.context = context;
-    return {
-      type: "directory",
-      name: "Bootstrap",
-      children: [
-        { type: "file", name: "app.ts", content: this.generateBootstrapApp(context) },
-        { type: "file", name: "providers.ts", content: this.generateProvidersRegistry(context) },
-        { type: "file", name: "events.ts", content: this.generateEventsRegistry() },
-        { type: "file", name: "routes.ts", content: this.generateRoutesRegistry(context) }
-      ]
-    };
-  }
-  generateConfigDirectory(context) {
-    this.context = context;
+// src/generators/ddd/AdvancedModuleGenerator.ts
+var AdvancedModuleGenerator = class {
+  /**
+   * 生成進階 DDD 模組結構（Event Sourcing）
+   *
+   * 生成檔案：
+   * - Domain/AggregateRoots/{Name}.ts
+   * - Domain/Events/{Name}*Event.ts（3 個事件示例）
+   * - Domain/Services/{Name}EventApplier.ts
+   * - Domain/Repositories/I{Name}EventStore.ts
+   * - Domain/ValueObjects/{Name}Status.ts
+   * - Infrastructure/EventStore/InMemory{Name}EventStore.ts
+   * - Infrastructure/EventStore/Database{Name}EventStore.ts
+   * - Infrastructure/EventStore/{Name}EventDeserializer.ts
+   * - Application/Services/Create{Name}Service.ts
+   * - 完整的測試框架
+   */
+  generate(moduleName, _context) {
     return {
       type: "directory",
-      name: "config",
+      name: moduleName,
       children: [
-        { type: "file", name: "app.ts", content: this.generateAppConfig(context) },
-        { type: "file", name: "database.ts", content: this.generateDatabaseConfig() },
-        { type: "file", name: "modules.ts", content: this.generateModulesConfig() },
-        { type: "file", name: "cache.ts", content: this.generateCacheConfig() },
-        { type: "file", name: "logging.ts", content: this.generateLoggingConfig() }
+        // Domain Layer
+        {
+          type: "directory",
+          name: "Domain",
+          children: [
+            // Aggregate Root
+            {
+              type: "directory",
+              name: "AggregateRoots",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}.ts`,
+                  content: this.generateAggregateRoot(moduleName)
+                }
+              ]
+            },
+            // Events
+            {
+              type: "directory",
+              name: "Events",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}CreatedEvent.ts`,
+                  content: this.generateEvent(moduleName, "Created")
+                },
+                {
+                  type: "file",
+                  name: `${moduleName}UpdatedEvent.ts`,
+                  content: this.generateEvent(moduleName, "Updated")
+                },
+                {
+                  type: "file",
+                  name: `${moduleName}DeletedEvent.ts`,
+                  content: this.generateEvent(moduleName, "Deleted")
+                }
+              ]
+            },
+            // Value Objects
+            {
+              type: "directory",
+              name: "ValueObjects",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}Status.ts`,
+                  content: this.generateStatusValueObject(moduleName)
+                },
+                {
+                  type: "file",
+                  name: `${moduleName}Id.ts`,
+                  content: this.generateIdValueObject(moduleName)
+                }
+              ]
+            },
+            // Event Applier
+            {
+              type: "directory",
+              name: "Services",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}EventApplier.ts`,
+                  content: this.generateEventApplier(moduleName)
+                }
+              ]
+            },
+            // Repositories
+            {
+              type: "directory",
+              name: "Repositories",
+              children: [
+                {
+                  type: "file",
+                  name: `I${moduleName}EventStore.ts`,
+                  content: this.generateEventStoreInterface(moduleName)
+                }
+              ]
+            }
+          ]
+        },
+        // Application Layer
+        {
+          type: "directory",
+          name: "Application",
+          children: [
+            {
+              type: "directory",
+              name: "Services",
+              children: [
+                {
+                  type: "file",
+                  name: `Create${moduleName}Service.ts`,
+                  content: this.generateApplicationService(moduleName)
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "DTOs",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}DTO.ts`,
+                  content: this.generateDTO(moduleName)
+                }
+              ]
+            }
+          ]
+        },
+        // Infrastructure Layer
+        {
+          type: "directory",
+          name: "Infrastructure",
+          children: [
+            {
+              type: "directory",
+              name: "EventStore",
+              children: [
+                {
+                  type: "file",
+                  name: `InMemory${moduleName}EventStore.ts`,
+                  content: this.generateInMemoryEventStore(moduleName)
+                },
+                {
+                  type: "file",
+                  name: `Database${moduleName}EventStore.ts`,
+                  content: this.generateDatabaseEventStore(moduleName)
+                },
+                {
+                  type: "file",
+                  name: `${moduleName}EventDeserializer.ts`,
+                  content: this.generateEventDeserializer(moduleName)
+                }
+              ]
+            }
+          ]
+        },
+        // Presentation Layer
+        {
+          type: "directory",
+          name: "Presentation",
+          children: [
+            {
+              type: "directory",
+              name: "Controllers",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}Controller.ts`,
+                  content: this.generateController(moduleName)
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Routes",
+              children: [
+                {
+                  type: "file",
+                  name: `${this.toKebabCase(moduleName)}.routes.ts`,
+                  content: this.generateRoutes(moduleName)
+                }
+              ]
+            }
+          ]
+        },
+        // Module Export
+        {
+          type: "file",
+          name: "index.ts",
+          content: this.generateModuleIndex(moduleName)
+        }
       ]
     };
   }
-  generateMainEntry(_context) {
-    return `/**
- * Application Entry Point
+  // ─────────────────────────────────────────────────────────────────
+  // 域層代碼生成
+  // ─────────────────────────────────────────────────────────────────
+  generateAggregateRoot(name) {
+    return `import { AggregateRoot } from '@/Shared/Domain/AggregateRoot'
+import { DomainEvent } from '@/Shared/Domain/DomainEvent'
+import { ${name}Status } from '../ValueObjects/${name}Status'
+import { ${name}Id } from '../ValueObjects/${name}Id'
+import {
+  ${name}CreatedEvent,
+  ${name}UpdatedEvent,
+  ${name}DeletedEvent,
+} from '../Events'
+
+/**
+ * ${name} \u805A\u5408\u6839
  *
- * Start the HTTP server.
+ * Event Sourcing \u5BE6\u73FE\uFF1A\u72C0\u614B\u5B8C\u5168\u7531\u4E8B\u4EF6\u6D41\u6C7A\u5B9A
+ *
+ * \u751F\u547D\u9031\u671F\uFF1A
+ * CREATED \u2192 (UPDATED*) \u2192 DELETED
  */
+export class ${name} extends AggregateRoot {
+  private id: ${name}Id | null = null
+  private status: ${name}Status | null = null
+  private name: string = ''
+  private description: string = ''
+  private createdAt: Date = new Date()
+  private updatedAt: Date = new Date()
+
+  // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // \u5DE5\u5EE0\u65B9\u6CD5 - \u5EFA\u7ACB\u65B0\u805A\u5408
+  // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
 
-import { createApp } from './Bootstrap/app'
+  /**
+   * \u5DE5\u5EE0\u65B9\u6CD5\uFF1A\u5EFA\u7ACB\u65B0 ${name}
+   */
+  static create(id: ${name}Id, name: string, description?: string): ${name} {
+    const instance = new ${name}()
+
+    instance.raiseEvent(
+      new ${name}CreatedEvent(id.value, {
+        name,
+        description: description || '',
+      })
+    )
 
-const app = await createApp()
+    return instance
+  }
 
-export default app.liftoff()
-`;
+  /**
+   * \u5F9E\u4E8B\u4EF6\u6D41\u91CD\u5EFA ${name}
+   */
+  static fromEvents(events: DomainEvent[]): ${name} {
+    const instance = new ${name}()
+
+    for (const event of events) {
+      instance.applyEvent(event)
+    }
+
+    return instance
   }
-  generateBootstrapApp(_context) {
-    return `/**
- * Application Bootstrap
- *
- * Central configuration and initialization using the ServiceProvider pattern.
- *
- * Lifecycle:
- * 1. Configure: Load app config and orbits
- * 2. Boot: Initialize PlanetCore
- * 3. Register Providers: Bind services to container
- * 4. Bootstrap: Boot all providers
- */
 
-import { defineConfig, PlanetCore } from '@gravito/core'
-import { OrbitAtlas } from '@gravito/atlas'
-import appConfig from '../../config/app'
-import { registerProviders } from './providers'
-import { registerRoutes } from './routes'
+  // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // \u547D\u4EE4\u65B9\u6CD5 - \u72C0\u614B\u8F49\u79FB
+  // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
 
-export async function createApp(): Promise<PlanetCore> {
-  // 1. Configure
-  const config = defineConfig({
-    config: appConfig,
-    orbits: [
-      new OrbitAtlas() as unknown as import('@gravito/core').GravitoOrbit,
-    ],
-  })
+  update(name: string, description?: string): void {
+    if (!this.id) {
+      throw new Error('${name} \u672A\u521D\u59CB\u5316')
+    }
 
-  // 2. Boot Core
-  const core = await PlanetCore.boot(config)
-  core.registerGlobalErrorHandlers()
+    if (this.status?.isDeleted()) {
+      throw new Error('${name} \u5DF2\u522A\u9664')
+    }
 
-  // 3. Register Providers
-  await registerProviders(core)
+    this.raiseEvent(
+      new ${name}UpdatedEvent(this.id.value, {
+        name,
+        description: description || '',
+      })
+    )
+  }
 
-  // 4. Bootstrap All Providers
-  await core.bootstrap()
+  delete(): void {
+    if (!this.id) {
+      throw new Error('${name} \u672A\u521D\u59CB\u5316')
+    }
 
-  // Register routes after bootstrap
-  registerRoutes(core.router)
+    if (this.status?.isDeleted()) {
+      throw new Error('${name} \u5DF2\u522A\u9664')
+    }
 
-  return core
-}
-`;
+    this.raiseEvent(new ${name}DeletedEvent(this.id.value))
   }
-  generateProvidersRegistry(_context) {
-    return `/**
- * Service Providers Registry
- *
- * Register all service providers here.
- * Include both global and module-specific providers.
- */
 
+  // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // \u4E8B\u4EF6\u61C9\u7528 - \u72C0\u614B\u66F4\u65B0
+  // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+  applyEvent(event: DomainEvent): void {
+    switch (event.eventType) {
+      case '${this.toKebabCase(name)}.created':
+        this.onCreated(event)
+        break
+      case '${this.toKebabCase(name)}.updated':
+        this.onUpdated(event)
+        break
+      case '${this.toKebabCase(name)}.deleted':
+        this.onDeleted(event)
+        break
+      default:
+        throw new Error(\`Unknown event type: \${event.eventType}\`)
+    }
+  }
+
+  private onCreated(event: DomainEvent): void {
+    this.id = new ${name}Id(event.aggregateId)
+    this.status = new ${name}Status('created')
+    this.name = event.data.name as string
+    this.description = event.data.description as string
+    this.createdAt = event.occurredAt
+    this.updatedAt = event.occurredAt
+  }
+
+  private onUpdated(event: DomainEvent): void {
+    this.name = event.data.name as string
+    this.description = event.data.description as string
+    this.updatedAt = event.occurredAt
+  }
+
+  private onDeleted(event: DomainEvent): void {
+    this.status = new ${name}Status('deleted')
+    this.updatedAt = event.occurredAt
+  }
+
+  // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // \u8B80\u53D6\u65B9\u6CD5 - \u53D6\u5F97\u72C0\u614B
+  // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+  getId(): ${name}Id {
+    if (!this.id) throw new Error('ID \u672A\u521D\u59CB\u5316')
+    return this.id
+  }
+
+  getStatus(): ${name}Status {
+    if (!this.status) throw new Error('Status \u672A\u521D\u59CB\u5316')
+    return this.status
+  }
+
+  getName(): string {
+    return this.name
+  }
+
+  getDescription(): string {
+    return this.description
+  }
+
+  getCreatedAt(): Date {
+    return this.createdAt
+  }
+
+  getUpdatedAt(): Date {
+    return this.updatedAt
+  }
+}
+`;
+  }
+  generateEvent(name, action) {
+    return `import { DomainEvent } from '@/Shared/Domain/DomainEvent'
+
+export interface ${name}${action}Data {
+  name: string
+  description?: string
+  // TODO: \u65B0\u589E\u5176\u4ED6\u4E8B\u4EF6\u8CC7\u6599
+}
+
+/**
+ * ${name}${action}Event
+ *
+ * \u4E8B\u4EF6\u5305\u542B\u6240\u6709\u5FC5\u8981\u8CC7\u8A0A\u4EE5\u91CD\u5EFA\u805A\u5408\u72C0\u614B
+ * \u4E8B\u4EF6\u662F\u4E0D\u53EF\u8B8A\u7684
+ */
+export class ${name}${action}Event extends DomainEvent {
+  constructor(
+    aggregateId: string,
+    payload: ${name}${action}Data,
+    version?: number,
+    occurredAt?: Date
+  ) {
+    super(
+      aggregateId,
+      '${this.toKebabCase(name)}.${this.toKebabCase(action)}',
+      {
+        name: payload.name,
+        description: payload.description || '',
+        // TODO: \u65B0\u589E\u5176\u4ED6\u5C6C\u6027
+      },
+      version,
+      occurredAt
+    )
+  }
+
+  /**
+   * \u5411\u5F8C\u76F8\u5BB9\u6027\u652F\u63F4
+   * \u7576\u4E8B\u4EF6\u7D50\u69CB\u8B8A\u5316\u6642\uFF0C\u8986\u84CB\u6B64\u65B9\u6CD5
+   */
+  getSchemaVersion(): string {
+    return '1.0.0'
+  }
+
+  toJSON() {
+    return {
+      eventId: this.eventId,
+      aggregateId: this.aggregateId,
+      eventType: this.eventType,
+      occurredAt: this.occurredAt,
+      version: this.version,
+      data: this.data,
+    }
+  }
+}
+`;
+  }
+  generateStatusValueObject(name) {
+    return `import { ValueObject } from '@/Shared/Domain/ValueObject'
+
+export type ${name}StatusValue = 'created' | 'updated' | 'deleted'
+
+/**
+ * ${name}Status - \u72C0\u614B\u503C\u7269\u4EF6
+ *
+ * \u4E0D\u53EF\u8B8A\u7684\u72C0\u614B\u503C
+ */
+export class ${name}Status extends ValueObject {
+  constructor(readonly value: ${name}StatusValue) {
+    super()
+    this.validate()
+  }
+
+  private validate(): void {
+    const validStatuses: ${name}StatusValue[] = ['created', 'updated', 'deleted']
+    if (!validStatuses.includes(this.value)) {
+      throw new Error(\`Invalid ${name} status: \${this.value}\`)
+    }
+  }
+
+  isCreated(): boolean {
+    return this.value === 'created'
+  }
+
+  isUpdated(): boolean {
+    return this.value === 'updated'
+  }
+
+  isDeleted(): boolean {
+    return this.value === 'deleted'
+  }
+
+  equals(other: ValueObject): boolean {
+    if (!(other instanceof ${name}Status)) return false
+    return this.value === other.value
+  }
+
+  toString(): string {
+    return this.value
+  }
+}
+`;
+  }
+  generateIdValueObject(name) {
+    return `import { ValueObject } from '@/Shared/Domain/ValueObject'
+
+/**
+ * ${name}Id - ID \u503C\u7269\u4EF6
+ *
+ * \u78BA\u4FDD ID \u7684\u6709\u6548\u6027
+ */
+export class ${name}Id extends ValueObject {
+  constructor(readonly value: string) {
+    super()
+    this.validate()
+  }
+
+  private validate(): void {
+    if (!this.value || this.value.trim() === '') {
+      throw new Error(\`Invalid ${name} ID: \${this.value}\`)
+    }
+  }
+
+  equals(other: ValueObject): boolean {
+    if (!(other instanceof ${name}Id)) return false
+    return this.value === other.value
+  }
+
+  toString(): string {
+    return this.value
+  }
+}
+`;
+  }
+  generateEventApplier(name) {
+    return `import { DomainEvent } from '@/Shared/Domain/DomainEvent'
+
+/**
+ * ${name}EventApplier - \u7D14\u51FD\u5F0F\u4E8B\u4EF6\u61C9\u7528\u5668
+ *
+ * \u8A2D\u8A08\u539F\u5247\uFF1A
+ * 1. \u7121\u526F\u4F5C\u7528\uFF1A\u76F8\u540C\u8F38\u5165 \u2192 \u76F8\u540C\u8F38\u51FA
+ * 2. \u4E0D\u53EF\u8B8A\u6027\uFF1A\u4E0D\u4FEE\u6539\u8F38\u5165\u72C0\u614B
+ * 3. \u5931\u6557\u5FEB\u901F\uFF1A\u7121\u6548\u4E8B\u4EF6\u7ACB\u5373\u62CB\u51FA
+ */
+
+export interface ${name}State {
+  readonly id: string
+  readonly status: string
+  readonly name: string
+  readonly description: string
+  readonly createdAt: Date
+  readonly updatedAt: Date
+}
+
+export class ${name}EventApplier {
+  /**
+   * \u61C9\u7528\u55AE\u500B\u4E8B\u4EF6\u5230\u72C0\u614B
+   *
+   * @param state \u76EE\u524D\u72C0\u614B\uFF08null \u8868\u793A\u65B0\u805A\u5408\uFF09
+   * @param event \u8981\u61C9\u7528\u7684\u4E8B\u4EF6
+   * @returns \u65B0\u72C0\u614B\uFF08state \u4E0D\u53EF\u8B8A\uFF09
+   */
+  static apply(state: ${name}State | null, event: DomainEvent): ${name}State {
+    // \u521D\u59CB\u5316\u4E8B\u4EF6
+    if (event.eventType === '${this.toKebabCase(name)}.created') {
+      if (state !== null) {
+        throw new Error('${name} \u5DF2\u5B58\u5728\uFF0C\u7121\u6CD5\u518D\u6B21\u5EFA\u7ACB')
+      }
+      return this.applyCreated(event)
+    }
+
+    // \u975E\u521D\u59CB\u5316\u4E8B\u4EF6
+    if (state === null) {
+      throw new Error(\`Event \${event.eventType} \u8981\u6C42 state \u975E null\`)
+    }
+
+    switch (event.eventType) {
+      case '${this.toKebabCase(name)}.updated':
+        return this.applyUpdated(state, event)
+      case '${this.toKebabCase(name)}.deleted':
+        return this.applyDeleted(state, event)
+      default:
+        throw new Error(\`Unknown event type: \${event.eventType}\`)
+    }
+  }
+
+  private static applyCreated(event: DomainEvent): ${name}State {
+    return {
+      id: event.aggregateId,
+      status: 'created',
+      name: event.data.name as string,
+      description: event.data.description as string,
+      createdAt: event.occurredAt,
+      updatedAt: event.occurredAt,
+    }
+  }
+
+  private static applyUpdated(state: ${name}State, event: DomainEvent): ${name}State {
+    return {
+      ...state,
+      name: event.data.name as string,
+      description: event.data.description as string,
+      updatedAt: event.occurredAt,
+    }
+  }
+
+  private static applyDeleted(state: ${name}State, event: DomainEvent): ${name}State {
+    return {
+      ...state,
+      status: 'deleted',
+      updatedAt: event.occurredAt,
+    }
+  }
+}
+`;
+  }
+  generateEventStoreInterface(name) {
+    return `import { ${name} } from '../AggregateRoots/${name}'
+
+/**
+ * I${name}EventStore - \u4E8B\u4EF6\u5B58\u5132\u4ECB\u9762
+ *
+ * \u8CA0\u8CAC\u4E8B\u4EF6\u7684\u6301\u4E45\u5316\u548C\u91CD\u5EFA
+ */
+export interface I${name}EventStore {
+  /**
+   * \u4FDD\u5B58\u805A\u5408\uFF08\u6301\u4E45\u5316\u65B0\u4E8B\u4EF6\uFF09
+   */
+  save(aggregate: ${name}): Promise<void>
+
+  /**
+   * \u6839\u64DA ID \u67E5\u8A62\u805A\u5408
+   */
+  findById(id: string): Promise<${name} | null>
+
+  /**
+   * \u53D6\u5F97\u6240\u6709\u4E8B\u4EF6\uFF08\u7528\u65BC\u91CD\u5EFA\uFF09
+   */
+  getEvents(aggregateId: string): Promise<Event[]>
+}
+`;
+  }
+  generateInMemoryEventStore(name) {
+    return `import type { DomainEvent } from '@/Shared/Domain/DomainEvent'
+import type { I${name}EventStore } from '../../Domain/Repositories/I${name}EventStore'
+import { ${name} } from '../../Domain/AggregateRoots/${name}'
+
+/**
+ * InMemory${name}EventStore - \u8A18\u61B6\u9AD4\u5BE6\u73FE
+ *
+ * \u7528\u9014\uFF1A
+ * - \u55AE\u5143\u6E2C\u8A66\uFF08\u5FEB\u901F\uFF0C\u7121 I/O\uFF09
+ * - \u958B\u767C\u74B0\u5883\uFF08\u7C21\u55AE\uFF0C\u7121\u9700 DB\uFF09
+ * - \u539F\u578B\u8A2D\u8A08
+ */
+export class InMemory${name}EventStore implements I${name}EventStore {
+  private events = new Map<string, DomainEvent[]>()
+
+  async save(aggregate: ${name}): Promise<void> {
+    const id = aggregate.getId().value
+    const uncommittedEvents = aggregate.getUncommittedEvents()
+
+    if (uncommittedEvents.length === 0) return
+
+    if (!this.events.has(id)) {
+      this.events.set(id, [...uncommittedEvents])
+    } else {
+      this.events.get(id)!.push(...uncommittedEvents)
+    }
+
+    aggregate.markEventsAsCommitted()
+  }
+
+  async findById(id: string): Promise<${name} | null> {
+    const events = this.events.get(id)
+    if (!events || events.length === 0) return null
+
+    return ${name}.fromEvents(events)
+  }
+
+  async getEvents(aggregateId: string): Promise<DomainEvent[]> {
+    return this.events.get(aggregateId) || []
+  }
+
+  // \u6E2C\u8A66\u8F14\u52A9\u65B9\u6CD5
+  clear(): void {
+    this.events.clear()
+  }
+
+  getAllEvents(): DomainEvent[] {
+    return Array.from(this.events.values()).flat()
+  }
+}
+`;
+  }
+  generateDatabaseEventStore(name) {
+    return `import type { DomainEvent } from '@/Shared/Domain/DomainEvent'
+import type { I${name}EventStore } from '../../Domain/Repositories/I${name}EventStore'
+import { ${name} } from '../../Domain/AggregateRoots/${name}'
+import { ${name}EventDeserializer } from './${name}EventDeserializer'
+
+/**
+ * Database${name}EventStore - \u8CC7\u6599\u5EAB\u5BE6\u73FE
+ *
+ * \u7528\u9014\uFF1A
+ * - \u751F\u7522\u74B0\u5883\uFF08\u6301\u4E45\u5316\uFF0C\u53EF\u9760\uFF09
+ * - \u5B8C\u6574\u6B77\u53F2\u8A18\u9304\uFF08\u6240\u6709\u4E8B\u4EF6\uFF09
+ * - \u4E8B\u4EF6\u91CD\u653E
+ *
+ * \u8868\u7D50\u69CB\uFF1A
+ * ${this.toSnakeCase(name)}_events (
+ *   aggregate_id VARCHAR(255),
+ *   event_type VARCHAR(255),
+ *   payload JSON,
+ *   version INT,
+ *   occurred_at TIMESTAMP
+ * )
+ */
+export class Database${name}EventStore implements I${name}EventStore {
+  // TODO: \u6CE8\u5165 DB \u9023\u63A5\uFF08\u4F7F\u7528 @gravito/atlas\uFF09
+  // constructor(private db: Database) {}
+
+  async save(aggregate: ${name}): Promise<void> {
+    const id = aggregate.getId().value
+    const uncommittedEvents = aggregate.getUncommittedEvents()
+
+    if (uncommittedEvents.length === 0) return
+
+    // TODO: \u63D2\u5165\u4E8B\u4EF6\u5230\u8CC7\u6599\u5EAB
+    // for (const event of uncommittedEvents) {
+    //   await this.db.table('${this.toSnakeCase(name)}_events').insert({
+    //     aggregate_id: id,
+    //     event_type: event.eventType,
+    //     payload: JSON.stringify(event.data),
+    //     version: event.version,
+    //     occurred_at: event.occurredAt.toISOString()
+    //   })
+    // }
+
+    aggregate.markEventsAsCommitted()
+  }
+
+  async findById(id: string): Promise<${name} | null> {
+    // TODO: \u5F9E\u8CC7\u6599\u5EAB\u67E5\u8A62\u4E8B\u4EF6
+    // const rows = await this.db
+    //   .table('${this.toSnakeCase(name)}_events')
+    //   .where('aggregate_id', id)
+    //   .orderBy('version', 'asc')
+    //   .select()
+
+    // if (!rows || rows.length === 0) return null
+
+    // const events = rows.map(row =>
+    //   ${name}EventDeserializer.fromDatabaseRow(row)
+    // )
+
+    // return ${name}.fromEvents(events)
+
+    return null
+  }
+
+  async getEvents(aggregateId: string): Promise<DomainEvent[]> {
+    // TODO: \u67E5\u8A62\u6240\u6709\u4E8B\u4EF6\uFF08\u7528\u65BC\u91CD\u653E\uFF09
+    return []
+  }
+}
+`;
+  }
+  generateEventDeserializer(name) {
+    return `import type { DomainEvent } from '@/Shared/Domain/DomainEvent'
 import {
-  ServiceProvider,
-  type Container,
-  type PlanetCore,
-  bodySizeLimit,
-  securityHeaders,
-} from '@gravito/core'
-import { OrderingServiceProvider } from '../Modules/Ordering/Infrastructure/Providers/OrderingServiceProvider'
-import { CatalogServiceProvider } from '../Modules/Catalog/Infrastructure/Providers/CatalogServiceProvider'
+  ${name}CreatedEvent,
+  ${name}UpdatedEvent,
+  ${name}DeletedEvent,
+} from '../../Domain/Events'
+
+/**
+ * ${name}EventDeserializer - \u4E8B\u4EF6\u53CD\u5E8F\u5217\u5316\u5668
+ *
+ * \u8CAC\u4EFB\uFF1A
+ * 1. \u5F9E JSON payload \u91CD\u5EFA DomainEvent \u5B50\u985E
+ * 2. \u652F\u63F4\u4E8B\u4EF6\u7248\u672C\u9077\u79FB
+ * 3. \u6642\u9593\u6233\u8F49\u63DB
+ */
+export class ${name}EventDeserializer {
+  static deserialize(
+    eventType: string,
+    payload: Record<string, unknown>,
+    aggregateId: string,
+    occurredAt: Date,
+    version: number
+  ): DomainEvent {
+    switch (eventType) {
+      case '${this.toKebabCase(name)}.created':
+        return new ${name}CreatedEvent(
+          aggregateId,
+          {
+            name: payload.name as string,
+            description: payload.description as string,
+          },
+          version,
+          occurredAt
+        )
+
+      case '${this.toKebabCase(name)}.updated':
+        return new ${name}UpdatedEvent(
+          aggregateId,
+          {
+            name: payload.name as string,
+            description: payload.description as string,
+          },
+          version,
+          occurredAt
+        )
+
+      case '${this.toKebabCase(name)}.deleted':
+        return new ${name}DeletedEvent(aggregateId, {}, version, occurredAt)
+
+      default:
+        throw new Error(\`Unknown event type: \${eventType}\`)
+    }
+  }
+
+  static fromDatabaseRow(row: any): DomainEvent {
+    const payload = typeof row.payload === 'string'
+      ? JSON.parse(row.payload)
+      : row.payload
+    const occurredAt = new Date(row.occurred_at)
+
+    return this.deserialize(
+      row.event_type,
+      payload,
+      row.aggregate_id,
+      occurredAt,
+      row.version
+    )
+  }
+}
+`;
+  }
+  generateApplicationService(name) {
+    return `import type { I${name}EventStore } from '../../Domain/Repositories/I${name}EventStore'
+import { ${name} } from '../../Domain/AggregateRoots/${name}'
+import { ${name}Id } from '../../Domain/ValueObjects/${name}Id'
+import { ${name}DTO } from '../DTOs/${name}DTO'
+
+/**
+ * Create${name}Service - \u5EFA\u7ACB ${name} \u7684\u61C9\u7528\u670D\u52D9
+ *
+ * \u8CAC\u4EFB\uFF1A
+ * 1. \u5354\u8ABF\u9818\u57DF\u908F\u8F2F
+ * 2. \u7BA1\u7406\u4E8B\u52D9
+ * 3. \u8F49\u63DB DTO
+ */
+export class Create${name}Service {
+  constructor(private eventStore: I${name}EventStore) {}
+
+  async execute(input: { name: string; description?: string }): Promise<${name}DTO> {
+    // TODO: \u9A57\u8B49\u8F38\u5165
+    // if (!input.name || input.name.trim() === '') {
+    //   throw new Error('Name \u4E0D\u80FD\u70BA\u7A7A')
+    // }
+
+    // \u5EFA\u7ACB\u805A\u5408
+    const id = new ${name}Id(\`${this.toKebabCase(name)}-\${crypto.randomUUID()}\`)
+    const aggregate = ${name}.create(id, input.name, input.description)
+
+    // \u6301\u4E45\u5316\u4E8B\u4EF6
+    await this.eventStore.save(aggregate)
+
+    // \u8F49\u63DB\u70BA DTO
+    return ${name}DTO.fromEntity(aggregate)
+  }
+}
+`;
+  }
+  generateDTO(name) {
+    return `import { ${name} } from '../../Domain/AggregateRoots/${name}'
+
+/**
+ * ${name}DTO - \u8CC7\u6599\u8F49\u79FB\u7269\u4EF6
+ *
+ * \u7528\u9014\uFF1A
+ * - \u8DE8\u5C64\u8F49\u79FB\u8CC7\u6599
+ * - API \u97FF\u61C9\u683C\u5F0F\u5316
+ * - \u96B1\u85CF\u5167\u90E8\u7D30\u7BC0
+ */
+export class ${name}DTO {
+  id!: string
+  status!: string
+  name!: string
+  description!: string
+  createdAt!: Date
+  updatedAt!: Date
+
+  static fromEntity(entity: ${name}): ${name}DTO {
+    const dto = new ${name}DTO()
+    dto.id = entity.getId().value
+    dto.status = entity.getStatus().value
+    dto.name = entity.getName()
+    dto.description = entity.getDescription()
+    dto.createdAt = entity.getCreatedAt()
+    dto.updatedAt = entity.getUpdatedAt()
+    return dto
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      status: this.status,
+      name: this.name,
+      description: this.description,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+    }
+  }
+}
+`;
+  }
+  generateController(name) {
+    return `import type { IModuleRouter } from '@/Shared/Presentation/IModuleRouter'
+import { Create${name}Service } from '../../Application/Services/Create${name}Service'
+import type { I${name}EventStore } from '../../Domain/Repositories/I${name}EventStore'
+
+/**
+ * ${name}Controller - HTTP \u8655\u7406\u5668
+ *
+ * \u8CAC\u4EFB\uFF1A
+ * 1. \u89E3\u6790 HTTP \u8ACB\u6C42
+ * 2. \u8ABF\u7528\u61C9\u7528\u670D\u52D9
+ * 3. \u683C\u5F0F\u5316\u97FF\u61C9
+ */
+export class ${name}Controller {
+  private createService: Create${name}Service
+
+  constructor(eventStore: I${name}EventStore) {
+    this.createService = new Create${name}Service(eventStore)
+  }
+
+  async create(ctx: any) {
+    try {
+      // TODO: \u89E3\u6790 request body
+      const input = {
+        name: 'TODO',
+        description: 'TODO',
+      }
+
+      const result = await this.createService.execute(input)
+      return ctx.json(result, 201)
+    } catch (error) {
+      return ctx.json({ error: (error as Error).message }, 400)
+    }
+  }
+
+  // TODO: \u65B0\u589E\u5176\u4ED6\u8DEF\u7531\u8655\u7406\u5668
+  // async update(ctx) { ... }
+  // async delete(ctx) { ... }
+}
+`;
+  }
+  generateRoutes(name) {
+    const kebabName = this.toKebabCase(name);
+    return `import type { IModuleRouter } from '@/Shared/Presentation/IModuleRouter'
+import { ${name}Controller } from '../Controllers/${name}Controller'
+import type { I${name}EventStore } from '../../Domain/Repositories/I${name}EventStore'
+
+/**
+ * register${name}Routes - \u8DEF\u7531\u8A3B\u518A
+ *
+ * \u652F\u63F4\uFF1A
+ * POST   /api/${kebabName}          - \u5EFA\u7ACB
+ * GET    /api/${kebabName}/:id      - \u53D6\u5F97\u8A73\u60C5
+ * PUT    /api/${kebabName}/:id      - \u66F4\u65B0
+ * DELETE /api/${kebabName}/:id      - \u522A\u9664
+ */
+export function register${name}Routes(
+  router: IModuleRouter,
+  eventStore: I${name}EventStore
+): void {
+  const controller = new ${name}Controller(eventStore)
+
+  router.post('/api/${kebabName}', (ctx) => controller.create(ctx))
+
+  // TODO: \u65B0\u589E\u5176\u4ED6\u8DEF\u7531
+  // router.get('/api/${kebabName}/:id', (ctx) => controller.getById(ctx))
+  // router.put('/api/${kebabName}/:id', (ctx) => controller.update(ctx))
+  // router.delete('/api/${kebabName}/:id', (ctx) => controller.delete(ctx))
+}
+`;
+  }
+  generateModuleIndex(name) {
+    return `/**
+ * ${name} \u6A21\u7D44\u5C0E\u51FA
+ *
+ * \u516C\u958B API
+ */
+
+// Domain
+export { ${name} } from './Domain/AggregateRoots/${name}'
+export { ${name}Id } from './Domain/ValueObjects/${name}Id'
+export { ${name}Status } from './Domain/ValueObjects/${name}Status'
+export {
+  ${name}CreatedEvent,
+  ${name}UpdatedEvent,
+  ${name}DeletedEvent,
+} from './Domain/Events'
+export { ${name}EventApplier } from './Domain/Services/${name}EventApplier'
+export type { I${name}EventStore } from './Domain/Repositories/I${name}EventStore'
+
+// Application
+export { Create${name}Service } from './Application/Services/Create${name}Service'
+export { ${name}DTO } from './Application/DTOs/${name}DTO'
+
+// Infrastructure
+export { InMemory${name}EventStore } from './Infrastructure/EventStore/InMemory${name}EventStore'
+export { Database${name}EventStore } from './Infrastructure/EventStore/Database${name}EventStore'
+export { ${name}EventDeserializer } from './Infrastructure/EventStore/${name}EventDeserializer'
+
+// Presentation
+export { ${name}Controller } from './Presentation/Controllers/${name}Controller'
+export { register${name}Routes } from './Presentation/Routes/${this.toKebabCase(name)}.routes'
+`;
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // 工具方法
+  // ─────────────────────────────────────────────────────────────────
+  toKebabCase(str) {
+    return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+  }
+  toSnakeCase(str) {
+    return str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+  }
+};
+
+// src/generators/ddd/BootstrapGenerator.ts
+var BootstrapGenerator = class {
+  context = null;
+  generate(context) {
+    this.context = context;
+    return {
+      type: "directory",
+      name: "Bootstrap",
+      children: [
+        { type: "file", name: "app.ts", content: this.generateBootstrapApp(context) },
+        { type: "file", name: "providers.ts", content: this.generateProvidersRegistry(context) },
+        { type: "file", name: "events.ts", content: this.generateEventsRegistry() },
+        { type: "file", name: "routes.ts", content: this.generateRoutesRegistry(context) },
+        { type: "file", name: "auto-di.ts", content: this.generateAutoDiBootstrap() }
+      ]
+    };
+  }
+  generateConfigDirectory(context) {
+    this.context = context;
+    return {
+      type: "directory",
+      name: "config",
+      children: [
+        { type: "file", name: "app.ts", content: this.generateAppConfig(context) },
+        { type: "file", name: "database.ts", content: this.generateDatabaseConfig() },
+        { type: "file", name: "modules.ts", content: this.generateModulesConfig() },
+        { type: "file", name: "cache.ts", content: this.generateCacheConfig() },
+        { type: "file", name: "logging.ts", content: this.generateLoggingConfig() }
+      ]
+    };
+  }
+  generateMainEntry(_context) {
+    return `/**
+ * Application Entry Point
+ *
+ * Start the HTTP server.
+ */
+
+import { createApp } from './Bootstrap/app'
+
+const app = await createApp()
+
+export default app.liftoff()
+`;
+  }
+  generateBootstrapApp(_context) {
+    return `/**
+ * Application Bootstrap
+ *
+ * Central configuration and initialization using the ServiceProvider pattern.
+ *
+ * Lifecycle:
+ * 1. Configure: Load app config and orbits
+ * 2. Boot: Initialize PlanetCore
+ * 3. Auto-discover and register services via AutoDiBootstrap
+ * 4. Bootstrap: Boot all providers
+ * 5. Register routes: Auto-register module routes
+ */
+
+import { defineConfig, PlanetCore } from '@gravito/core'
+import { OrbitAtlas } from '@gravito/atlas'
+import appConfig from '../../config/app'
+import { AutoDiBootstrap } from '../../Bootstrap/auto-di'
+import { registerProviders } from './providers'
+import { registerRoutes } from './routes'
+
+export async function createApp(): Promise<PlanetCore> {
+  // 1. Configure
+  const config = defineConfig({
+    config: appConfig,
+    orbits: [
+      new OrbitAtlas() as unknown as import('@gravito/core').GravitoOrbit,
+    ],
+  })
+
+  // 2. Boot Core
+  const core = await PlanetCore.boot(config)
+  core.registerGlobalErrorHandlers()
+
+  // 3. Auto-discover and register services (OPTIONAL)
+  // \u53D6\u6D88\u4E0B\u5217\u8A3B\u89E3\u4EE5\u555F\u7528\u81EA\u52D5 DI \u6383\u63CF
+  // \u512A\u9EDE\uFF1A\u7121\u9700\u624B\u52D5\u4FEE\u6539 registerProviders()
+  // \u7F3A\u9EDE\uFF1A\u6383\u63CF\u9700\u8981\u6642\u9593\uFF08~100ms\uFF09
+  // await AutoDiBootstrap.scanAndRegisterServices(core.container)
+
+  // 3b. \u6216\u4F7F\u7528\u50B3\u7D71\u7684\u986F\u5F0F\u63D0\u4F9B\u8005\u8A3B\u518A\uFF08\u63A8\u85A6\u7528\u65BC\u751F\u7522\uFF09
+  await registerProviders(core)
+
+  // 4. Bootstrap All Providers
+  await core.bootstrap()
+
+  // 5. Auto-register module routes (OPTIONAL)
+  // await AutoDiBootstrap.scanAndRegisterRoutes(core)
+
+  // 5b. \u6216\u4F7F\u7528\u50B3\u7D71\u7684\u8DEF\u7531\u8A3B\u518A
+  registerRoutes(core.router)
+
+  return core
+}
+`;
+  }
+  generateProvidersRegistry(_context) {
+    return `/**
+ * Service Providers Registry
+ *
+ * Register all service providers here.
+ * Include both global and module-specific providers.
+ */
+
+import {
+  ServiceProvider,
+  type Container,
+  type PlanetCore,
+  bodySizeLimit,
+  securityHeaders,
+} from '@gravito/core'
+import { OrderingServiceProvider } from '../Modules/Ordering/Infrastructure/Providers/OrderingServiceProvider'
+import { CatalogServiceProvider } from '../Modules/Catalog/Infrastructure/Providers/CatalogServiceProvider'
+
+/**
+ * Middleware Provider - Global middleware registration
+ */
+export class MiddlewareProvider extends ServiceProvider {
+  register(_container: Container): void {}
+
+  boot(core: PlanetCore): void {
+    const isDev = process.env.NODE_ENV !== 'production'
+
+    core.adapter.use('*', securityHeaders({
+      contentSecurityPolicy: isDev ? false : undefined,
+    }))
+
+    core.adapter.use('*', bodySizeLimit(10 * 1024 * 1024))
+
+    core.logger.info('\u{1F6E1}\uFE0F Global middleware registered')
+  }
+}
+
+export async function registerProviders(core: PlanetCore): Promise<void> {
+  // Global Providers
+  core.register(new MiddlewareProvider())
+
+  // Module Providers
+  core.register(new OrderingServiceProvider())
+  core.register(new CatalogServiceProvider())
+
+  // Add more providers as needed
+}
+`;
+  }
+  generateEventsRegistry() {
+    return `/**
+ * Domain Events Registry
+ *
+ * Register all domain event handlers here.
+ */
+
+import { EventDispatcher } from '../Shared/Infrastructure/EventBus/EventDispatcher'
+
+export function registerEvents(dispatcher: EventDispatcher): void {
+    // Register event handlers
+    // dispatcher.subscribe('ordering.created', async (event) => { ... })
+}
+`;
+  }
+  generateRoutesRegistry(_context) {
+    return `/**
+ * Routes Registry
+ *
+ * Register all module routes here.
+ */
+
+export function registerRoutes(router: any): void {
+    // Health check
+    router.get('/health', (c: any) => c.json({ status: 'healthy' }))
+
+    // Ordering module
+    router.get('/api/orders', (c: any) => c.json({ message: 'Order list' }))
+    router.post('/api/orders', (c: any) => c.json({ message: 'Order created' }, 201))
+
+    // Catalog module
+    router.get('/api/products', (c: any) => c.json({ message: 'Product list' }))
+}
+`;
+  }
+  generateModulesConfig() {
+    return `/**
+ * Modules Configuration
+ *
+ * Define module boundaries and their dependencies.
+ */
+
+export default {
+    modules: {
+        ordering: {
+            name: 'Ordering',
+            description: 'Order management module',
+            prefix: '/api/orders',
+        },
+        catalog: {
+            name: 'Catalog',
+            description: 'Product catalog module',
+            prefix: '/api/products',
+        },
+    },
+
+    // Module dependencies
+    dependencies: {
+        ordering: ['catalog'], // Ordering depends on Catalog
+    },
+}
+`;
+  }
+  generateAppConfig(context) {
+    return `export default {
+  name: process.env.APP_NAME ?? '${context.name}',
+  env: process.env.APP_ENV ?? 'development',
+  port: Number.parseInt(process.env.PORT ?? '3000', 10),
+  VIEW_DIR: process.env.VIEW_DIR ?? 'src/views',
+  debug: process.env.APP_DEBUG === 'true',
+  url: process.env.APP_URL ?? 'http://localhost:3000',
+}
+`;
+  }
+  generateDatabaseConfig() {
+    const driver = this.context?.profileConfig?.drivers?.database ?? "none";
+    return ConfigGenerator.generateDatabaseConfig(driver);
+  }
+  generateCacheConfig() {
+    return `export default {
+  default: process.env.CACHE_DRIVER ?? 'memory',
+  stores: { memory: { driver: 'memory' } },
+}
+`;
+  }
+  generateLoggingConfig() {
+    return `export default {
+  default: 'console',
+  channels: { console: { driver: 'console', level: 'debug' } },
+}
+`;
+  }
+  generateAutoDiBootstrap() {
+    return `/**
+ * AutoDiBootstrap - \u81EA\u52D5\u4F9D\u8CF4\u6CE8\u5165\u5F15\u5C0E\u5C64
+ *
+ * \u529F\u80FD\uFF1A
+ * 1. \u81EA\u52D5\u6383\u63CF\u6A21\u7D44\u76EE\u9304\u767C\u73FE\u670D\u52D9
+ * 2. \u81EA\u52D5\u8A3B\u518A\u5230 DI \u5BB9\u5668
+ * 3. \u81EA\u52D5\u8A3B\u518A\u8DEF\u7531
+ *
+ * \u4F7F\u7528\u65B9\u5F0F\uFF1A
+ * \u5728 app.ts \u4E2D\u53D6\u6D88\u4E0B\u5217\u8A3B\u89E3\uFF1A
+ * await AutoDiBootstrap.scanAndRegisterServices(core.container)
+ * await AutoDiBootstrap.scanAndRegisterRoutes(core)
+ *
+ * \u6CE8\u610F\uFF1A\u81EA\u52D5\u6383\u63CF\u6703\u589E\u52A0\u555F\u52D5\u6642\u9593\uFF08~100ms\uFF09
+ * \u751F\u7522\u74B0\u5883\u5EFA\u8B70\u4F7F\u7528\u624B\u52D5\u8A3B\u518A\uFF08registerProviders\uFF09
+ */
+
+import type { Container, PlanetCore } from '@gravito/core'
+import { glob } from 'bun'
+
+interface DiscoveredService {
+  type: 'domain-service' | 'application-service' | 'repository' | 'event-subscriber'
+  filePath: string
+  moduleName: string
+  className: string
+}
+
+interface DiscoveredRoute {
+  moduleName: string
+  routeFilePath: string
+  functionName: string
+}
+
+export class AutoDiBootstrap {
+  /**
+   * \u6383\u63CF\u4E26\u81EA\u52D5\u8A3B\u518A\u6240\u6709\u6A21\u7D44\u670D\u52D9
+   */
+  static async scanAndRegisterServices(
+    container: Container,
+    projectRoot = process.cwd(),
+  ): Promise<void> {
+    const services = await this.discoverServices(projectRoot)
+    console.log(\`\u{1F50D} \u767C\u73FE \${services.length} \u500B\u670D\u52D9\`)
+
+    for (const service of services) {
+      await this.registerService(container, service)
+    }
+
+    console.log(\`\u2705 \u5DF2\u8A3B\u518A \${services.length} \u500B\u670D\u52D9\u5230 DI \u5BB9\u5668\`)
+  }
+
+  /**
+   * \u6383\u63CF\u4E26\u81EA\u52D5\u8A3B\u518A\u6240\u6709\u6A21\u7D44\u8DEF\u7531
+   */
+  static async scanAndRegisterRoutes(core: PlanetCore, projectRoot = process.cwd()): Promise<void> {
+    const routes = await this.discoverRoutes(projectRoot)
+    console.log(\`\u{1F6E3}\uFE0F  \u767C\u73FE \${routes.length} \u500B\u8DEF\u7531\u6A21\u7D44\`)
+
+    for (const route of routes) {
+      try {
+        const moduleUrl = new URL(\`file://\${route.routeFilePath}\`)
+        const routeModule = await import(moduleUrl.href)
+        const registerFunction = routeModule[route.functionName] || routeModule.default
+
+        if (typeof registerFunction === 'function') {
+          registerFunction(core)
+          console.log(\`  \u2713 \${route.moduleName} \u8DEF\u7531\u5DF2\u8A3B\u518A\`)
+        }
+      } catch (error) {
+        console.error(\`  \u2717 \u7121\u6CD5\u8F09\u5165 \${route.routeFilePath}:\`, error)
+      }
+    }
+
+    console.log(\`\u2705 \u5DF2\u8A3B\u518A \${routes.length} \u500B\u8DEF\u7531\`)
+  }
+
+  private static async discoverServices(projectRoot: string): Promise<DiscoveredService[]> {
+    const services: DiscoveredService[] = []
+
+    // \u6383\u63CF\u6240\u6709 Service \u548C Repository
+    const patterns = [
+      'src/Modules/*/Domain/Services/*Service.ts',
+      'src/Modules/*/Application/Services/*Service.ts',
+      'src/Modules/*/Infrastructure/Repositories/*Repository.ts',
+      'src/Modules/*/Infrastructure/Subscribers/*Subscriber.ts',
+    ]
+
+    for (const pattern of patterns) {
+      const files = await glob({ cwd: projectRoot, pattern })
+      for (const filePath of files) {
+        const moduleName = this.extractModuleName(filePath)
+        const className = this.extractClassName(filePath)
+        const type = this.inferServiceType(filePath) as DiscoveredService['type']
+
+        services.push({ type, filePath, moduleName, className })
+      }
+    }
+
+    return services
+  }
+
+  private static async discoverRoutes(projectRoot: string): Promise<DiscoveredRoute[]> {
+    const routeFiles = await glob({
+      cwd: projectRoot,
+      pattern: 'src/Modules/*/Presentation/Routes/*.routes.ts',
+    })
+
+    return routeFiles.map((filePath) => {
+      const moduleName = this.extractModuleName(filePath)
+      return {
+        moduleName,
+        routeFilePath: \`\${projectRoot}/\${filePath}\`,
+        functionName: \`register\${moduleName}Routes\`,
+      }
+    })
+  }
+
+  private static async registerService(container: Container, service: DiscoveredService): Promise<void> {
+    try {
+      const moduleUrl = new URL(\`file://\${process.cwd()}/\${service.filePath}\`)
+      const module = await import(moduleUrl.href)
+      const ServiceClass = module[service.className] || module.default
+
+      if (!ServiceClass) {
+        console.warn(\`  \u26A0\uFE0F  \u7121\u6CD5\u627E\u5230 \${service.className} \u5728 \${service.filePath}\`)
+        return
+      }
+
+      const serviceKey = this.generateServiceKey(service.className)
+      container.singleton(serviceKey, () => new ServiceClass())
+
+      console.log(\`  \u2713 \${serviceKey}\`)
+    } catch (error) {
+      console.error(\`  \u2717 \u7121\u6CD5\u8F09\u5165 \${service.filePath}:\`, error)
+    }
+  }
+
+  private static extractModuleName(filePath: string): string {
+    const match = filePath.match(/Modules\\/([^\\/]+)/)
+    return match ? match[1] : 'Unknown'
+  }
+
+  private static extractClassName(filePath: string): string {
+    const fileName = filePath.split('/').pop() || ''
+    return fileName.replace('.ts', '')
+  }
+
+  private static inferServiceType(filePath: string): string {
+    if (filePath.includes('/Domain/Services/')) return 'domain-service'
+    if (filePath.includes('/Application/Services/')) return 'application-service'
+    if (filePath.includes('/Infrastructure/Repositories/')) return 'repository'
+    if (filePath.includes('/Infrastructure/Subscribers/')) return 'event-subscriber'
+    return 'unknown'
+  }
+
+  private static generateServiceKey(className: string): string {
+    let name = className
+    if (name.startsWith('I') && name.length > 1) name = name.slice(1)
+    if (name.endsWith('Service')) name = name.slice(0, -7)
+    if (name.endsWith('Repository')) name = name.slice(0, -10)
+    return this.toKebabCase(name)
+  }
+
+  private static toKebabCase(str: string): string {
+    return str
+      .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+      .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+      .toLowerCase()
+  }
+}
+`;
+  }
+};
+
+// src/generators/ddd/CQRSQueryModuleGenerator.ts
+var CQRSQueryModuleGenerator = class {
+  /**
+   * 生成 CQRS 查詢側模組結構
+   *
+   * 生成檔案：
+   * - Domain/ReadModels/{Name}ReadModel.ts
+   * - Domain/Projectors/{Name}EventProjector.ts
+   * - Application/Services/Query{Name}Service.ts
+   * - Application/DTOs/{Name}ReadDTO.ts
+   * - Infrastructure/Subscribers/{Name}ProjectionSubscriber.ts
+   * - Infrastructure/Cache/{Name}ReadModelCache.ts
+   * - Presentation/Controllers/{Name}QueryController.ts
+   * - index.ts
+   *
+   * @param moduleName - 模組名稱（例：'Wallet'）
+   * @param _context - 生成器上下文（當前未使用，預留供未來擴展）
+   * @returns 模組目錄結構
+   */
+  generate(moduleName, _context) {
+    return {
+      type: "directory",
+      name: moduleName,
+      children: [
+        // Domain Layer
+        {
+          type: "directory",
+          name: "Domain",
+          children: [
+            // Read Models
+            {
+              type: "directory",
+              name: "ReadModels",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}ReadModel.ts`,
+                  content: this.generateReadModel(moduleName)
+                }
+              ]
+            },
+            // Projectors
+            {
+              type: "directory",
+              name: "Projectors",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}EventProjector.ts`,
+                  content: this.generateProjector(moduleName)
+                }
+              ]
+            },
+            // Repositories
+            {
+              type: "directory",
+              name: "Repositories",
+              children: [
+                {
+                  type: "file",
+                  name: `I${moduleName}ReadModelRepository.ts`,
+                  content: this.generateRepositoryInterface(moduleName)
+                }
+              ]
+            }
+          ]
+        },
+        // Application Layer
+        {
+          type: "directory",
+          name: "Application",
+          children: [
+            {
+              type: "directory",
+              name: "Services",
+              children: [
+                {
+                  type: "file",
+                  name: `Query${moduleName}Service.ts`,
+                  content: this.generateQueryService(moduleName)
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "DTOs",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}ReadDTO.ts`,
+                  content: this.generateQueryDTO(moduleName)
+                }
+              ]
+            }
+          ]
+        },
+        // Infrastructure Layer
+        {
+          type: "directory",
+          name: "Infrastructure",
+          children: [
+            {
+              type: "directory",
+              name: "Repositories",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}ReadModelRepository.ts`,
+                  content: this.generateRepositoryImplementation(moduleName)
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Subscribers",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}ProjectionSubscriber.ts`,
+                  content: this.generateSubscriber(moduleName)
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Cache",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}ReadModelCache.ts`,
+                  content: this.generateCache(moduleName)
+                }
+              ]
+            }
+          ]
+        },
+        // Presentation Layer
+        {
+          type: "directory",
+          name: "Presentation",
+          children: [
+            {
+              type: "directory",
+              name: "Controllers",
+              children: [
+                {
+                  type: "file",
+                  name: `${moduleName}QueryController.ts`,
+                  content: this.generateController(moduleName)
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Routes",
+              children: [
+                {
+                  type: "file",
+                  name: `${this.toKebabCase(moduleName)}.routes.ts`,
+                  content: this.generateRoutes(moduleName)
+                }
+              ]
+            }
+          ]
+        },
+        // Module index
+        {
+          type: "file",
+          name: "index.ts",
+          content: this.generateIndex(moduleName)
+        }
+      ]
+    };
+  }
+  /**
+   * 生成讀模型檔案
+   */
+  generateReadModel(moduleName) {
+    return `/**
+ * ${moduleName}ReadModel - \u67E5\u8A62\u512A\u5316\u7684\u8B80\u6A21\u578B
+ *
+ * \u8B80\u6A21\u578B\u662F\u5F9E\u4E8B\u4EF6\u6295\u5F71\u800C\u4F86\u7684\u975E\u898F\u7BC4\u5316\u6578\u64DA\u7D50\u69CB\uFF0C
+ * \u91DD\u5C0D\u7279\u5B9A\u67E5\u8A62\u5834\u666F\u9032\u884C\u512A\u5316\u3002
+ *
+ * \u8207 Aggregate Root \u4E0D\u540C\uFF1A
+ * - Aggregate Root\uFF1A\u898F\u7BC4\u5316\uFF0C\u55AE\u4E00\u4F86\u6E90\uFF08\u4E8B\u4EF6\uFF09\uFF0C\u5F37\u4E00\u81F4\u6027
+ * - ReadModel\uFF1A\u53CD\u898F\u7BC4\u5316\uFF0C\u4F9B\u67E5\u8A62\u4F7F\u7528\uFF0C\u6700\u7D42\u4E00\u81F4\u6027
+ *
+ * \u8A2D\u8A08\u539F\u5247\uFF1A
+ * 1. \u4E0D\u53EF\u8B8A\u6027\uFF1A\u8B80\u6A21\u578B\u5B57\u6BB5\u901A\u904E\u6295\u5F71\u5668\u552F\u8B80\u4FEE\u6539
+ * 2. \u6E05\u6670\u6027\uFF1A\u5B57\u6BB5\u540D\u7A31\u76F4\u89C0\u53CD\u6620\u67E5\u8A62\u9700\u6C42
+ * 3. \u6027\u80FD\uFF1A\u5305\u542B\u9810\u8A08\u7B97\u5B57\u6BB5\uFF08\u5982\u7E3D\u984D\u3001\u8A08\u6578\uFF09
+ * 4. \u7248\u672C\u63A7\u5236\uFF1A\u652F\u6301\u6295\u5F71\u5668\u7248\u672C\u9077\u79FB
+ */
+
+import type { DomainEvent } from '@/Shared/Domain/DomainEvent'
+
+/**
+ * ${moduleName} \u8B80\u6A21\u578B\u4ECB\u9762
+ * \u4EE3\u8868\u512A\u5316\u7528\u65BC\u67E5\u8A62\u7684\u6578\u64DA\u7D50\u69CB
+ */
+export interface ${moduleName}ReadModel {
+  // TODO: \u6839\u64DA\u67E5\u8A62\u9700\u6C42\u6DFB\u52A0\u5B57\u6BB5
+  // \u793A\u4F8B\uFF1A
+  // id: string
+  // customerId: string
+  // totalAmount: string (decimal as string for precision)
+  // transactionCount: number
+  // lastUpdated: Date
+  // status: string
+
+  // \u6295\u5F71\u5143\u6578\u64DA
+  /** \u6700\u5F8C\u8655\u7406\u7684\u4E8B\u4EF6 ID\uFF08\u7528\u65BC\u51AA\u7B49\u6027\uFF09 */
+  lastProcessedEventId?: string
+  /** \u6295\u5F71\u5668\u7248\u672C */
+  projectionVersion: number
+}
+
+/**
+ * \u5DE5\u5EE0\u65B9\u6CD5\uFF1A\u5275\u5EFA\u65B0\u7684\u8B80\u6A21\u578B
+ */
+export function create${moduleName}ReadModel(data: Partial<${moduleName}ReadModel>): ${moduleName}ReadModel {
+  return {
+    ...data,
+    projectionVersion: 1,
+  } as ${moduleName}ReadModel
+}
+
+/**
+ * \u9A57\u8B49\u8B80\u6A21\u578B\u6578\u64DA\u5B8C\u6574\u6027
+ */
+export function validate${moduleName}ReadModel(data: any): boolean {
+  // TODO: \u6DFB\u52A0\u9A57\u8B49\u908F\u8F2F
+  // - \u5FC5\u586B\u5B57\u6BB5\u6AA2\u67E5
+  // - \u985E\u578B\u9A57\u8B49
+  // - \u696D\u52D9\u898F\u5247\u9A57\u8B49
+  return typeof data === 'object' && data !== null
+}
+
+/**
+ * \u5F9E\u8B80\u6A21\u578B\u63D0\u53D6\u67E5\u8A62\u4FE1\u606F
+ * \u7528\u65BC DTO \u8F49\u63DB\u548C\u5E8F\u5217\u5316
+ */
+export function extract${moduleName}Data(model: ${moduleName}ReadModel): Record<string, any> {
+  return {
+    // TODO: \u63D0\u53D6\u76F8\u95DC\u5B57\u6BB5\u7528\u65BC DTO \u8F49\u63DB
+    projectionVersion: model.projectionVersion,
+  }
+}
+`;
+  }
+  /**
+   * 生成事件投影器檔案
+   */
+  generateProjector(moduleName) {
+    return `/**
+ * ${moduleName}EventProjector - \u4E8B\u4EF6\u6295\u5F71\u5668
+ *
+ * \u6295\u5F71\u5668\u662F\u7D14\u51FD\u6578\uFF0C\u8CA0\u8CAC\u5C07\u9818\u57DF\u4E8B\u4EF6\u8F49\u5316\u70BA\u8B80\u6A21\u578B\u3002
+ * \u8A2D\u8A08\u70BA\u51AA\u7B49\u64CD\u4F5C\uFF1A\u540C\u4E00\u4E8B\u4EF6\u6295\u5F71\u591A\u6B21\u7D50\u679C\u76F8\u540C\u3002
+ *
+ * \u6838\u5FC3\u8077\u8CAC\uFF1A
+ * 1. \u76E3\u807D\u7279\u5B9A\u7684\u9818\u57DF\u4E8B\u4EF6
+ * 2. \u6839\u64DA\u4E8B\u4EF6\u5167\u5BB9\u66F4\u65B0\u8B80\u6A21\u578B
+ * 3. \u78BA\u4FDD\u64CD\u4F5C\u51AA\u7B49\uFF08\u9632\u6B62\u91CD\u8907\u8655\u7406\uFF09
+ * 4. \u8A18\u9304\u6295\u5F71\u5BE9\u8A08\u4FE1\u606F
+ *
+ * \u512A\u52E2\uFF1A
+ * - \u7D14\u51FD\u6578\u908F\u8F2F\u6613\u65BC\u6E2C\u8A66
+ * - \u652F\u6301\u4E8B\u4EF6\u91CD\u653E\u548C\u6295\u5F71\u91CD\u5EFA
+ * - \u89E3\u8026\u4E8B\u4EF6\u4F86\u6E90\u548C\u6295\u5F71\u76EE\u6A19
+ * - \u6613\u65BC\u65B0\u589E\u65B0\u7684\u8B80\u6A21\u578B\u800C\u7121\u9700\u4FEE\u6539\u805A\u5408\u6839
+ */
+
+import type { DomainEvent } from '@/Shared/Domain/DomainEvent'
+import type { I${moduleName}ReadModelRepository } from '../Repositories/I${moduleName}ReadModelRepository'
+import type { ${moduleName}ReadModel } from '../ReadModels/${moduleName}ReadModel'
+
+/**
+ * ${moduleName} \u4E8B\u4EF6\u6295\u5F71\u5668
+ *
+ * \u8CA0\u8CAC\u8A02\u95B1\u9818\u57DF\u4E8B\u4EF6\u4E26\u6295\u5F71\u5230\u8B80\u6A21\u578B
+ */
+export class ${moduleName}EventProjector {
+  constructor(private repository: I${moduleName}ReadModelRepository) {}
+
+  /**
+   * \u6295\u5F71\u4E8B\u4EF6\u5230\u8B80\u6A21\u578B
+   *
+   * \u5DE5\u4F5C\u6D41\u7A0B\uFF1A
+   * 1. \u6839\u64DA\u4E8B\u4EF6\u985E\u578B\u5206\u6D3E\u5230\u5C0D\u61C9\u7684 handler
+   * 2. \u67E5\u8A62\u6216\u5275\u5EFA\u8B80\u6A21\u578B
+   * 3. \u61C9\u7528\u6295\u5F71\u898F\u5247\u66F4\u65B0\u8B80\u6A21\u578B
+   * 4. \u6AA2\u67E5\u51AA\u7B49\u6027\uFF08\u662F\u5426\u5DF2\u8655\u7406\u904E\uFF09
+   * 5. \u4FDD\u5B58\u66F4\u65B0\u7D50\u679C
+   *
+   * @param event - \u8981\u6295\u5F71\u7684\u9818\u57DF\u4E8B\u4EF6
+   * @throws \u5982\u679C\u4E8B\u4EF6\u8655\u7406\u5931\u6557
+   */
+  async projectEvent(event: DomainEvent): Promise<void> {
+    try {
+      // TODO: \u6839\u64DA\u4E8B\u4EF6\u985E\u578B\u5206\u6D3E
+      // switch (event.constructor.name) {
+      //   case 'SomeEvent':
+      //     await this.handleSomeEvent(event as SomeEvent)
+      //     break
+      //   default:
+      //     console.warn(\`Unknown event type: \${event.constructor.name}\`)
+      // }
+    } catch (error) {
+      console.error(
+        \`Failed to project \${event.constructor.name} in ${moduleName}Projector:\`,
+        error
+      )
+      throw error
+    }
+  }
+
+  /**
+   * TODO: \u70BA\u6BCF\u500B\u8981\u8A02\u95B1\u7684\u4E8B\u4EF6\u6DFB\u52A0 handler \u65B9\u6CD5
+   *
+   * \u793A\u4F8B\uFF1A
+   * private async handleSomeEvent(event: SomeEvent): Promise<void> {
+   *   // 1. \u67E5\u8A62\u73FE\u6709\u8B80\u6A21\u578B\u6216\u5275\u5EFA\u65B0\u7684
+   *   let model = await this.repository.findById(event.aggregateId)
+   *   if (!model) {
+   *     model = createReadModel({ id: event.aggregateId })
+   *   }
+   *
+   *   // 2. \u6AA2\u67E5\u51AA\u7B49\u6027
+   *   if (model.lastProcessedEventId === event.eventId) {
+   *     return // \u5DF2\u8655\u7406\u904E\u6B64\u4E8B\u4EF6
+   *   }
+   *
+   *   // 3. \u61C9\u7528\u6295\u5F71\u898F\u5247\u66F4\u65B0\u5B57\u6BB5
+   *   model = {
+   *     ...model,
+   *     field1: event.data.newValue,
+   *     lastProcessedEventId: event.eventId,
+   *     projectionVersion: model.projectionVersion + 1,
+   *   }
+   *
+   *   // 4. \u4FDD\u5B58\u66F4\u65B0
+   *   await this.repository.save(model)
+   * }
+   */
+
+  /**
+   * \u7372\u53D6\u6B64\u6295\u5F71\u5668\u8A02\u95B1\u7684\u6240\u6709\u4E8B\u4EF6\u985E\u578B
+   *
+   * \u7528\u65BC\u81EA\u52D5\u4E8B\u4EF6\u8A02\u95B1\u8A3B\u518A
+   */
+  getSubscribedEventTypes(): string[] {
+    // TODO: \u8FD4\u56DE\u6B64\u6295\u5F71\u5668\u8A02\u95B1\u7684\u6240\u6709\u4E8B\u4EF6\u985E\u578B\u540D\u7A31
+    return [
+      // 'SomeEvent',
+      // 'AnotherEvent',
+    ]
+  }
+
+  /**
+   * \u5224\u65B7\u6295\u5F71\u5668\u662F\u5426\u652F\u63F4\u67D0\u500B\u4E8B\u4EF6
+   */
+  supportsEvent(eventType: string): boolean {
+    return this.getSubscribedEventTypes().includes(eventType)
+  }
+}
+`;
+  }
+  /**
+   * 生成查詢服務檔案
+   */
+  generateQueryService(moduleName) {
+    return `/**
+ * Query${moduleName}Service - \u67E5\u8A62\u670D\u52D9
+ *
+ * \u61C9\u7528\u5C64\u670D\u52D9\uFF0C\u63D0\u4F9B\u67E5\u8A62\u63A5\u53E3\u3002
+ * \u901A\u904E\u5009\u5EAB\u8A2A\u554F\u8B80\u6A21\u578B\uFF0C\u652F\u6301\u591A\u7A2E\u67E5\u8A62\u65B9\u6CD5\u3002
+ *
+ * \u8A2D\u8A08\u7279\u9EDE\uFF1A
+ * 1. \u7121\u526F\u4F5C\u7528\uFF1A\u53EA\u8B80\u64CD\u4F5C\uFF0C\u4E0D\u4FEE\u6539\u72C0\u614B
+ * 2. \u9AD8\u6548\uFF1A\u76F4\u63A5\u67E5\u8A62\u512A\u5316\u7684\u8B80\u6A21\u578B
+ * 3. \u4E00\u81F4\u6027\uFF1A\u652F\u6301\u7DE9\u5B58\u63A7\u5236
+ * 4. \u932F\u8AA4\u8655\u7406\uFF1A\u9069\u7576\u7684\u7570\u5E38\u8655\u7406\u548C\u65E5\u8A8C
+ */
+
+import type { I${moduleName}ReadModelRepository } from '../../Infrastructure/Repositories/I${moduleName}ReadModelRepository'
+import { ${moduleName}ReadDTO } from '../DTOs/${moduleName}ReadDTO'
+
+/**
+ * \u67E5\u8A62\u904E\u6FFE\u689D\u4EF6
+ */
+export interface QueryFilters {
+  [key: string]: any
+  // TODO: \u6839\u64DA\u67E5\u8A62\u9700\u6C42\u5B9A\u7FA9\u904E\u6FFE\u5B57\u6BB5
+}
+
+/**
+ * ${moduleName} \u67E5\u8A62\u670D\u52D9
+ * \u63D0\u4F9B\u8B80\u6A21\u578B\u7684\u5404\u7A2E\u67E5\u8A62\u65B9\u6CD5
+ */
+export class Query${moduleName}Service {
+  constructor(private repository: I${moduleName}ReadModelRepository) {}
+
+  /**
+   * \u6839\u64DA ID \u67E5\u8A62\u55AE\u500B\u8B80\u6A21\u578B
+   * @param id - \u8B80\u6A21\u578B ID
+   * @returns \u8B80\u6A21\u578B DTO\uFF0C\u5982\u679C\u4E0D\u5B58\u5728\u8FD4\u56DE null
+   */
+  async findById(id: string): Promise<${moduleName}ReadDTO | null> {
+    try {
+      const model = await this.repository.findById(id)
+      return model ? ${moduleName}ReadDTO.fromReadModel(model) : null
+    } catch (error) {
+      console.error(\`Error finding ${moduleName} by ID \${id}:\`, error)
+      throw error
+    }
+  }
+
+  /**
+   * \u67E5\u8A62\u6240\u6709\u8B80\u6A21\u578B
+   * @param filters - \u67E5\u8A62\u904E\u6FFE\u689D\u4EF6\uFF08\u53EF\u9078\uFF09
+   * @returns \u8B80\u6A21\u578B DTO \u5217\u8868
+   */
+  async findAll(filters?: QueryFilters): Promise<${moduleName}ReadDTO[]> {
+    try {
+      const models = await this.repository.findAll(filters)
+      return models.map(model => ${moduleName}ReadDTO.fromReadModel(model))
+    } catch (error) {
+      console.error('Error finding all ${moduleName}:', error)
+      throw error
+    }
+  }
+
+  /**
+   * \u57FA\u65BC\u689D\u4EF6\u641C\u7D22
+   * @param criteria - \u641C\u7D22\u689D\u4EF6
+   * @returns \u5339\u914D\u7684\u8B80\u6A21\u578B DTO \u5217\u8868
+   */
+  async search(criteria: QueryFilters): Promise<${moduleName}ReadDTO[]> {
+    try {
+      // TODO: \u5BE6\u73FE\u81EA\u5B9A\u7FA9\u641C\u7D22\u908F\u8F2F
+      return this.findAll(criteria)
+    } catch (error) {
+      console.error('Error searching ${moduleName}:', error)
+      throw error
+    }
+  }
+
+  /**
+   * \u7372\u53D6\u7D71\u8A08\u4FE1\u606F
+   * @returns \u7D71\u8A08\u6578\u64DA
+   */
+  async getStatistics(): Promise<Record<string, any>> {
+    try {
+      // TODO: \u5BE6\u73FE\u7D71\u8A08\u908F\u8F2F
+      // - \u7E3D\u6578\u91CF
+      // - \u805A\u5408\u5B57\u6BB5\uFF08\u7E3D\u984D\u3001\u5E73\u5747\u503C\u7B49\uFF09
+      // - \u5206\u7D44\u7D71\u8A08
+
+      return {
+        totalCount: 0,
+        // \u66F4\u591A\u7D71\u8A08\u5B57\u6BB5...
+      }
+    } catch (error) {
+      console.error('Error getting ${moduleName} statistics:', error)
+      throw error
+    }
+  }
+}
+`;
+  }
+  /**
+   * 生成查詢 DTO 檔案
+   */
+  generateQueryDTO(moduleName) {
+    return `/**
+ * ${moduleName}ReadDTO - \u67E5\u8A62\u7D50\u679C DTO
+ *
+ * \u6578\u64DA\u50B3\u8F38\u5C0D\u8C61\uFF0C\u7528\u65BC\u5C55\u793A\u5C64\u8207\u61C9\u7528\u5C64\u4E4B\u9593\u7684\u901A\u4FE1\u3002
+ * \u57FA\u65BC\u8B80\u6A21\u578B\u4F46\u53EF\u4EE5\u5305\u542B\u984D\u5916\u7684\u8A08\u7B97\u5B57\u6BB5\u3002
+ */
+
+import { BaseDTO } from '@/Shared/Application/BaseDTO'
+import type { ${moduleName}ReadModel } from '../../Domain/ReadModels/${moduleName}ReadModel'
 
 /**
- * Middleware Provider - Global middleware registration
+ * ${moduleName} \u8B80\u6A21\u578B DTO
  */
-export class MiddlewareProvider extends ServiceProvider {
-  register(_container: Container): void {}
+export class ${moduleName}ReadDTO extends BaseDTO {
+  // TODO: \u6839\u64DA\u67E5\u8A62\u9700\u6C42\u6DFB\u52A0\u5B57\u6BB5
+  // \u793A\u4F8B\uFF1A
+  // id: string
+  // customerId: string
+  // totalAmount: string
+  // transactionCount: number
+  // lastUpdated: Date
 
-  boot(core: PlanetCore): void {
-    const isDev = process.env.NODE_ENV !== 'production'
+  /**
+   * \u5F9E\u8B80\u6A21\u578B\u8F49\u63DB\u70BA DTO
+   */
+  static fromReadModel(model: ${moduleName}ReadModel): ${moduleName}ReadDTO {
+    const dto = new ${moduleName}ReadDTO()
+    // TODO: \u6620\u5C04\u8B80\u6A21\u578B\u5B57\u6BB5\u5230 DTO
+    // dto.id = model.id
+    // dto.customerId = model.customerId
+    // ...
+    return dto
+  }
 
-    core.adapter.use('*', securityHeaders({
-      contentSecurityPolicy: isDev ? false : undefined,
-    }))
+  /**
+   * \u5E8F\u5217\u5316\u70BA JSON
+   */
+  toJSON(): Record<string, any> {
+    return {
+      // TODO: \u8FD4\u56DE DTO \u7684 JSON \u8868\u793A
+      // id: this.id,
+      // customerId: this.customerId,
+      // ...
+    }
+  }
+}
+`;
+  }
+  /**
+   * 生成倉庫介面
+   */
+  generateRepositoryInterface(moduleName) {
+    return `/**
+ * I${moduleName}ReadModelRepository - \u8B80\u6A21\u578B\u5009\u5EAB\u4ECB\u9762
+ *
+ * \u5B9A\u7FA9\u8B80\u6A21\u578B\u5B58\u5132\u548C\u67E5\u8A62\u7684\u63A5\u53E3\u3002
+ * \u5BE6\u73FE\u985E\u8CA0\u8CAC\u8207\u6578\u64DA\u5EAB\u6216\u5FEB\u53D6\u7684\u4EA4\u4E92\u3002
+ */
 
-    core.adapter.use('*', bodySizeLimit(10 * 1024 * 1024))
+import type { ${moduleName}ReadModel } from '../ReadModels/${moduleName}ReadModel'
 
-    core.logger.info('\u{1F6E1}\uFE0F Global middleware registered')
+/**
+ * ${moduleName} \u8B80\u6A21\u578B\u5009\u5EAB\u4ECB\u9762
+ */
+export interface I${moduleName}ReadModelRepository {
+  /**
+   * \u6839\u64DA ID \u67E5\u8A62\u8B80\u6A21\u578B
+   */
+  findById(id: string): Promise<${moduleName}ReadModel | null>
+
+  /**
+   * \u67E5\u8A62\u6240\u6709\u8B80\u6A21\u578B
+   */
+  findAll(filters?: Record<string, any>): Promise<${moduleName}ReadModel[]>
+
+  /**
+   * \u4FDD\u5B58\u8B80\u6A21\u578B\uFF08\u65B0\u589E\u6216\u66F4\u65B0\uFF09
+   */
+  save(model: ${moduleName}ReadModel): Promise<void>
+
+  /**
+   * \u522A\u9664\u8B80\u6A21\u578B
+   */
+  delete(id: string): Promise<void>
+
+  /**
+   * \u6839\u64DA\u81EA\u5B9A\u7FA9\u689D\u4EF6\u67E5\u8A62
+   */
+  query(condition: Record<string, any>): Promise<${moduleName}ReadModel[]>
+
+  /**
+   * \u8A08\u6578
+   */
+  count(condition?: Record<string, any>): Promise<number>
+}
+`;
+  }
+  /**
+   * 生成倉庫實現
+   */
+  generateRepositoryImplementation(moduleName) {
+    return `/**
+ * ${moduleName}ReadModelRepository - \u8B80\u6A21\u578B\u5009\u5EAB\u5BE6\u73FE
+ *
+ * \u5BE6\u73FE\u8B80\u6A21\u578B\u7684\u6301\u4E45\u5316\u548C\u67E5\u8A62\u3002
+ * \u4F7F\u7528 Atlas ORM \u8207\u6578\u64DA\u5EAB\u4EA4\u4E92\u3002
+ */
+
+import type { I${moduleName}ReadModelRepository } from '../Repositories/I${moduleName}ReadModelRepository'
+import type { ${moduleName}ReadModel } from '../../Domain/ReadModels/${moduleName}ReadModel'
+
+/**
+ * ${moduleName} \u8B80\u6A21\u578B\u5009\u5EAB\u5BE6\u73FE
+ * \u4F7F\u7528 Atlas ORM \u8207\u6578\u64DA\u5EAB\u4EA4\u4E92
+ */
+export class ${moduleName}ReadModelRepository implements I${moduleName}ReadModelRepository {
+  private readonly tableName = '${this.toSnakeCase(moduleName)}_read_models'
+
+  /**
+   * \u6839\u64DA ID \u67E5\u8A62\u8B80\u6A21\u578B
+   */
+  async findById(id: string): Promise<${moduleName}ReadModel | null> {
+    try {
+      // TODO: \u4F7F\u7528 Atlas ORM \u67E5\u8A62
+      // const db = getDatabase() // \u5F9E DI \u5BB9\u5668\u7372\u53D6
+      // return await db.table(this.tableName).where('id', id).first()
+      return null
+    } catch (error) {
+      console.error(\`Error finding ${moduleName} by ID \${id}:\`, error)
+      throw error
+    }
+  }
+
+  /**
+   * \u67E5\u8A62\u6240\u6709\u8B80\u6A21\u578B
+   */
+  async findAll(filters?: Record<string, any>): Promise<${moduleName}ReadModel[]> {
+    try {
+      // TODO: \u4F7F\u7528 Atlas ORM \u67E5\u8A62
+      // const db = getDatabase()
+      // let query = db.table(this.tableName)
+      //
+      // if (filters) {
+      //   for (const [key, value] of Object.entries(filters)) {
+      //     query = query.where(key, value)
+      //   }
+      // }
+      //
+      // return await query.get()
+      return []
+    } catch (error) {
+      console.error('Error finding all ${moduleName}:', error)
+      throw error
+    }
+  }
+
+  /**
+   * \u4FDD\u5B58\u8B80\u6A21\u578B
+   */
+  async save(model: ${moduleName}ReadModel): Promise<void> {
+    try {
+      // TODO: \u4F7F\u7528 Atlas ORM \u4FDD\u5B58
+      // const db = getDatabase()
+      // await db.table(this.tableName).updateOrInsert(
+      //   { id: model.id },
+      //   model
+      // )
+    } catch (error) {
+      console.error('Error saving ${moduleName}:', error)
+      throw error
+    }
+  }
+
+  /**
+   * \u522A\u9664\u8B80\u6A21\u578B
+   */
+  async delete(id: string): Promise<void> {
+    try {
+      // TODO: \u4F7F\u7528 Atlas ORM \u522A\u9664
+      // const db = getDatabase()
+      // await db.table(this.tableName).where('id', id).delete()
+    } catch (error) {
+      console.error(\`Error deleting ${moduleName} ID \${id}:\`, error)
+      throw error
+    }
+  }
+
+  /**
+   * \u6839\u64DA\u81EA\u5B9A\u7FA9\u689D\u4EF6\u67E5\u8A62
+   */
+  async query(condition: Record<string, any>): Promise<${moduleName}ReadModel[]> {
+    return this.findAll(condition)
+  }
+
+  /**
+   * \u8A08\u6578
+   */
+  async count(condition?: Record<string, any>): Promise<number> {
+    try {
+      // TODO: \u4F7F\u7528 Atlas ORM \u8A08\u6578
+      // const db = getDatabase()
+      // let query = db.table(this.tableName)
+      //
+      // if (condition) {
+      //   for (const [key, value] of Object.entries(condition)) {
+      //     query = query.where(key, value)
+      //   }
+      // }
+      //
+      // return await query.count()
+      return 0
+    } catch (error) {
+      console.error('Error counting ${moduleName}:', error)
+      throw error
+    }
   }
 }
+`;
+  }
+  /**
+   * 生成事件訂閱器
+   */
+  generateSubscriber(moduleName) {
+    return `/**
+ * ${moduleName}ProjectionSubscriber - \u6295\u5F71\u4E8B\u4EF6\u8A02\u95B1\u5668
+ *
+ * \u8A02\u95B1\u9818\u57DF\u4E8B\u4EF6\u4E26\u8ABF\u7528\u6295\u5F71\u5668\u66F4\u65B0\u8B80\u6A21\u578B\u3002
+ * \u5145\u7576\u4E8B\u4EF6\u6E90\u8207\u67E5\u8A62\u5074\u7684\u6A4B\u6881\u3002
+ *
+ * \u5DE5\u4F5C\u6D41\u7A0B\uFF1A
+ * 1. \u61C9\u7528\u555F\u52D5\u6642\u8A3B\u518A\u5230\u4E8B\u4EF6\u532F\u6D41\u6392
+ * 2. \u63A5\u6536\u76F8\u95DC\u9818\u57DF\u4E8B\u4EF6
+ * 3. \u8ABF\u7528\u6295\u5F71\u5668\u8655\u7406\u4E8B\u4EF6
+ * 4. \u66F4\u65B0\u8B80\u6A21\u578B
+ */
 
-export async function registerProviders(core: PlanetCore): Promise<void> {
-  // Global Providers
-  core.register(new MiddlewareProvider())
+import type { DomainEvent } from '@/Shared/Domain/DomainEvent'
+import { ${moduleName}EventProjector } from '../../Domain/Projectors/${moduleName}EventProjector'
 
-  // Module Providers
-  core.register(new OrderingServiceProvider())
-  core.register(new CatalogServiceProvider())
+/**
+ * ${moduleName} \u6295\u5F71\u4E8B\u4EF6\u8A02\u95B1\u5668
+ * \u76E3\u807D\u4E8B\u4EF6\u4E26\u9A45\u52D5\u8B80\u6A21\u578B\u6295\u5F71
+ */
+export class ${moduleName}ProjectionSubscriber {
+  constructor(private projector: ${moduleName}EventProjector) {}
 
-  // Add more providers as needed
+  /**
+   * \u8655\u7406\u4E8B\u4EF6
+   * @param event - \u63A5\u6536\u5230\u7684\u9818\u57DF\u4E8B\u4EF6
+   */
+  async handle(event: DomainEvent): Promise<void> {
+    try {
+      // \u6AA2\u67E5\u6B64\u8A02\u95B1\u5668\u662F\u5426\u61C9\u8655\u7406\u8A72\u4E8B\u4EF6
+      if (this.projector.supportsEvent(event.constructor.name)) {
+        await this.projector.projectEvent(event)
+      }
+    } catch (error) {
+      console.error(
+        \`${moduleName}ProjectionSubscriber failed to handle \${event.constructor.name}:\`,
+        error
+      )
+      throw error
+    }
+  }
+
+  /**
+   * \u7372\u53D6\u8A02\u95B1\u7684\u4E8B\u4EF6\u985E\u578B\u5217\u8868
+   * \u7528\u65BC\u4E8B\u4EF6\u532F\u6D41\u6392\u8A3B\u518A
+   */
+  getSubscribedEventTypes(): string[] {
+    return this.projector.getSubscribedEventTypes()
+  }
 }
 `;
   }
-  generateEventsRegistry() {
+  /**
+   * 生成快取層
+   */
+  generateCache(moduleName) {
     return `/**
- * Domain Events Registry
+ * ${moduleName}ReadModelCache - \u8B80\u6A21\u578B\u5FEB\u53D6\u5C64
  *
- * Register all domain event handlers here.
+ * \u53EF\u9078\u7684\u5FEB\u53D6\u5C64\uFF0C\u7528\u65BC\u63D0\u9AD8\u67E5\u8A62\u6027\u80FD\u3002
+ * \u652F\u6301\u96D9\u5C64\u5FEB\u53D6\uFF1A\u9032\u7A0B\u5167\u5FEB\u53D6 + Redis \u5FEB\u53D6
  */
 
-import { EventDispatcher } from '../Shared/Infrastructure/EventBus/EventDispatcher'
+import type { ${moduleName}ReadModel } from '../../Domain/ReadModels/${moduleName}ReadModel'
 
-export function registerEvents(dispatcher: EventDispatcher): void {
-    // Register event handlers
-    // dispatcher.subscribe('ordering.created', async (event) => { ... })
+/**
+ * ${moduleName} \u8B80\u6A21\u578B\u5FEB\u53D6
+ */
+export class ${moduleName}ReadModelCache {
+  private memoryCache: Map<string, ${moduleName}ReadModel> = new Map()
+  private readonly cacheTTL = 3600 // 1 \u5C0F\u6642
+
+  /**
+   * \u5F9E\u5FEB\u53D6\u7372\u53D6\u8B80\u6A21\u578B
+   */
+  async get(key: string): Promise<${moduleName}ReadModel | null> {
+    // \u5148\u5617\u8A66\u9032\u7A0B\u8A18\u61B6\u9AD4\u5FEB\u53D6
+    const cached = this.memoryCache.get(key)
+    if (cached) {
+      return cached
+    }
+
+    // TODO: \u5617\u8A66 Redis \u5FEB\u53D6
+    // const redis = getRedisClient()
+    // const cached = await redis.get(\`${moduleName}:\${key}\`)
+    // if (cached) {
+    //   return JSON.parse(cached)
+    // }
+
+    return null
+  }
+
+  /**
+   * \u8A2D\u7F6E\u5FEB\u53D6
+   */
+  async set(key: string, value: ${moduleName}ReadModel, ttl?: number): Promise<void> {
+    // \u8A2D\u7F6E\u9032\u7A0B\u8A18\u61B6\u9AD4\u5FEB\u53D6
+    this.memoryCache.set(key, value)
+
+    // TODO: \u8A2D\u7F6E Redis \u5FEB\u53D6
+    // const redis = getRedisClient()
+    // await redis.setex(
+    //   \`${moduleName}:\${key}\`,
+    //   ttl || this.cacheTTL,
+    //   JSON.stringify(value)
+    // )
+  }
+
+  /**
+   * \u5931\u6548\u5FEB\u53D6
+   */
+  async invalidate(key: string): Promise<void> {
+    // \u6E05\u9664\u9032\u7A0B\u5FEB\u53D6
+    this.memoryCache.delete(key)
+
+    // TODO: \u6E05\u9664 Redis \u5FEB\u53D6
+    // const redis = getRedisClient()
+    // await redis.del(\`${moduleName}:\${key}\`)
+  }
+
+  /**
+   * \u6E05\u7A7A\u6240\u6709\u5FEB\u53D6
+   */
+  async clear(): Promise<void> {
+    this.memoryCache.clear()
+
+    // TODO: \u6E05\u7A7A Redis \u5FEB\u53D6
+    // const redis = getRedisClient()
+    // await redis.del(\`${moduleName}:*\`)
+  }
+}
+`;
+  }
+  /**
+   * 生成 HTTP 控制器
+   */
+  generateController(moduleName) {
+    const kebabName = this.toKebabCase(moduleName);
+    return `/**
+ * ${moduleName}QueryController - \u67E5\u8A62\u7AEF\u9EDE\u63A7\u5236\u5668
+ *
+ * HTTP \u7AEF\u9EDE\uFF0C\u70BA\u5BA2\u6236\u7AEF\u63D0\u4F9B\u8B80\u6A21\u578B\u67E5\u8A62\u63A5\u53E3\u3002
+ * \u8ABF\u7528\u67E5\u8A62\u670D\u52D9\u4E26\u683C\u5F0F\u5316\u97FF\u61C9\u3002
+ */
+
+import type { IHttpContext } from '@/Shared/Http/IHttpContext'
+import { Query${moduleName}Service } from '../../Application/Services/Query${moduleName}Service'
+
+/**
+ * ${moduleName} \u67E5\u8A62\u63A7\u5236\u5668
+ */
+export class ${moduleName}QueryController {
+  constructor(private queryService: Query${moduleName}Service) {}
+
+  /**
+   * GET /${kebabName}/:id
+   * \u6839\u64DA ID \u67E5\u8A62\u55AE\u500B ${moduleName}
+   */
+  async findById(ctx: IHttpContext): Promise<void> {
+    try {
+      const { id } = ctx.request.params as { id: string }
+
+      if (!id) {
+        ctx.response.status = 400
+        ctx.response.json({ error: 'ID is required' })
+        return
+      }
+
+      const dto = await this.queryService.findById(id)
+
+      if (!dto) {
+        ctx.response.status = 404
+        ctx.response.json({ error: '${moduleName} not found' })
+        return
+      }
+
+      ctx.response.status = 200
+      ctx.response.json({ data: dto })
+    } catch (error) {
+      this.handleError(ctx, error)
+    }
+  }
+
+  /**
+   * GET /${kebabName}
+   * \u67E5\u8A62\u6240\u6709 ${moduleName}
+   */
+  async findAll(ctx: IHttpContext): Promise<void> {
+    try {
+      const filters = ctx.request.query as Record<string, any> | undefined
+      const dtos = await this.queryService.findAll(filters)
+
+      ctx.response.status = 200
+      ctx.response.json({
+        data: dtos,
+        meta: { count: dtos.length },
+      })
+    } catch (error) {
+      this.handleError(ctx, error)
+    }
+  }
+
+  /**
+   * GET /${kebabName}/search
+   * \u641C\u7D22 ${moduleName}
+   */
+  async search(ctx: IHttpContext): Promise<void> {
+    try {
+      const criteria = ctx.request.query as Record<string, any> | undefined
+
+      if (!criteria) {
+        ctx.response.status = 400
+        ctx.response.json({ error: 'Search criteria required' })
+        return
+      }
+
+      const dtos = await this.queryService.search(criteria)
+
+      ctx.response.status = 200
+      ctx.response.json({
+        data: dtos,
+        meta: { count: dtos.length },
+      })
+    } catch (error) {
+      this.handleError(ctx, error)
+    }
+  }
+
+  /**
+   * GET /${kebabName}/statistics
+   * \u7372\u53D6\u7D71\u8A08\u4FE1\u606F
+   */
+  async getStatistics(ctx: IHttpContext): Promise<void> {
+    try {
+      const stats = await this.queryService.getStatistics()
+
+      ctx.response.status = 200
+      ctx.response.json({ data: stats })
+    } catch (error) {
+      this.handleError(ctx, error)
+    }
+  }
+
+  /**
+   * \u7D71\u4E00\u932F\u8AA4\u8655\u7406
+   */
+  private handleError(ctx: IHttpContext, error: unknown): void {
+    console.error('${moduleName}QueryController error:', error)
+
+    ctx.response.status = 500
+    ctx.response.json({
+      error: 'Internal server error',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    })
+  }
 }
 `;
   }
-  generateRoutesRegistry(_context) {
+  /**
+   * 生成路由檔案
+   */
+  generateRoutes(moduleName) {
+    const kebabName = this.toKebabCase(moduleName);
+    const functionName = `register${moduleName}QueryRoutes`;
     return `/**
- * Routes Registry
+ * ${kebabName}.routes.ts - ${moduleName} \u67E5\u8A62\u8DEF\u7531
  *
- * Register all module routes here.
+ * \u8A3B\u518A ${moduleName} \u67E5\u8A62\u7AEF\u9EDE\u7684\u8DEF\u7531
  */
 
-export function registerRoutes(router: any): void {
-    // Health check
-    router.get('/health', (c: any) => c.json({ status: 'healthy' }))
-
-    // Ordering module
-    router.get('/api/orders', (c: any) => c.json({ message: 'Order list' }))
-    router.post('/api/orders', (c: any) => c.json({ message: 'Order created' }, 201))
+import type { PlanetCore } from '@gravito/core'
+import { ${moduleName}QueryController } from '../Controllers/${moduleName}QueryController'
 
-    // Catalog module
-    router.get('/api/products', (c: any) => c.json({ message: 'Product list' }))
+/**
+ * \u8A3B\u518A ${moduleName} \u67E5\u8A62\u8DEF\u7531
+ *
+ * \u7AEF\u9EDE\uFF1A
+ * - GET /${kebabName}/:id - \u7372\u53D6\u55AE\u500B ${moduleName}
+ * - GET /${kebabName} - \u5217\u8868\u67E5\u8A62
+ * - GET /${kebabName}/search - \u641C\u7D22
+ * - GET /${kebabName}/statistics - \u7D71\u8A08\u4FE1\u606F
+ */
+export function ${functionName}(core: PlanetCore): void {
+  // TODO: \u5F9E DI \u5BB9\u5668\u7372\u53D6\u4F9D\u8CF4\u4E26\u5275\u5EFA\u63A7\u5236\u5668
+  // const queryService = core.container.make('query-${kebabName}-service')
+  // const controller = new ${moduleName}QueryController(queryService)
+
+  // TODO: \u8A3B\u518A\u8DEF\u7531
+  // core.router.get('/${kebabName}/:id', (ctx) => controller.findById(ctx))
+  // core.router.get('/${kebabName}', (ctx) => controller.findAll(ctx))
+  // core.router.get('/${kebabName}/search', (ctx) => controller.search(ctx))
+  // core.router.get('/${kebabName}/statistics', (ctx) => controller.getStatistics(ctx))
+
+  console.log(\`\u2713 ${moduleName} query routes registered\`)
 }
 `;
   }
-  generateModulesConfig() {
+  /**
+   * 生成模組索引檔案
+   */
+  generateIndex(moduleName) {
     return `/**
- * Modules Configuration
+ * ${moduleName} Query Module
  *
- * Define module boundaries and their dependencies.
+ * CQRS \u67E5\u8A62\u5074\u6A21\u7D44\uFF0C\u63D0\u4F9B\u8B80\u6A21\u578B\u548C\u67E5\u8A62\u670D\u52D9\u3002
+ * \u8A02\u95B1\u4F86\u81EA\u5BEB\u5074\uFF08Event Sourcing\uFF09\u6A21\u7D44\u7684\u4E8B\u4EF6\u3002
  */
 
-export default {
-    modules: {
-        ordering: {
-            name: 'Ordering',
-            description: 'Order management module',
-            prefix: '/api/orders',
-        },
-        catalog: {
-            name: 'Catalog',
-            description: 'Product catalog module',
-            prefix: '/api/products',
-        },
-    },
+// Domain exports
+export type { ${moduleName}ReadModel } from './Domain/ReadModels/${moduleName}ReadModel'
+export { create${moduleName}ReadModel, validate${moduleName}ReadModel } from './Domain/ReadModels/${moduleName}ReadModel'
+export { ${moduleName}EventProjector } from './Domain/Projectors/${moduleName}EventProjector'
+export type { I${moduleName}ReadModelRepository } from './Domain/Repositories/I${moduleName}ReadModelRepository'
 
-    // Module dependencies
-    dependencies: {
-        ordering: ['catalog'], // Ordering depends on Catalog
-    },
-}
-`;
-  }
-  generateAppConfig(context) {
-    return `export default {
-  name: process.env.APP_NAME ?? '${context.name}',
-  env: process.env.APP_ENV ?? 'development',
-  port: Number.parseInt(process.env.PORT ?? '3000', 10),
-  VIEW_DIR: process.env.VIEW_DIR ?? 'src/views',
-  debug: process.env.APP_DEBUG === 'true',
-  url: process.env.APP_URL ?? 'http://localhost:3000',
-}
+// Application exports
+export { Query${moduleName}Service } from './Application/Services/Query${moduleName}Service'
+export { ${moduleName}ReadDTO } from './Application/DTOs/${moduleName}ReadDTO'
+
+// Infrastructure exports
+export { ${moduleName}ReadModelRepository } from './Infrastructure/Repositories/${moduleName}ReadModelRepository'
+export { ${moduleName}ProjectionSubscriber } from './Infrastructure/Subscribers/${moduleName}ProjectionSubscriber'
+export { ${moduleName}ReadModelCache } from './Infrastructure/Cache/${moduleName}ReadModelCache'
+
+// Presentation exports
+export { ${moduleName}QueryController } from './Presentation/Controllers/${moduleName}QueryController'
+export { register${moduleName}QueryRoutes } from './Presentation/Routes/${this.toKebabCase(moduleName)}.routes'
 `;
   }
-  generateDatabaseConfig() {
-    const driver = this.context?.profileConfig?.drivers?.database ?? "none";
-    return ConfigGenerator.generateDatabaseConfig(driver);
-  }
-  generateCacheConfig() {
-    return `export default {
-  default: process.env.CACHE_DRIVER ?? 'memory',
-  stores: { memory: { driver: 'memory' } },
-}
-`;
+  /**
+   * 將字符串轉換為 kebab-case
+   */
+  toKebabCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
   }
-  generateLoggingConfig() {
-    return `export default {
-  default: 'console',
-  channels: { console: { driver: 'console', level: 'debug' } },
-}
-`;
+  /**
+   * 將字符串轉換為 snake_case
+   */
+  toSnakeCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
   }
 };
 
@@ -2395,6 +4734,30 @@ var ModuleGenerator = class {
               ]
             }
           ]
+        },
+        // UserInterface Layer
+        {
+          type: "directory",
+          name: "UserInterface",
+          children: [
+            {
+              type: "directory",
+              name: "Http",
+              children: [
+                {
+                  type: "directory",
+                  name: "Controllers",
+                  children: [
+                    {
+                      type: "file",
+                      name: `${name}Controller.ts`,
+                      content: this.generateController(name)
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
         }
       ]
     };
@@ -2410,17 +4773,13 @@ import { ${name}Created } from '../../Events/${name}Created'
 import { ${name}Status } from './${name}Status'
 
 export interface ${name}Props {
-  // Add properties here
   status: ${name}Status
   createdAt: Date
 }
 
 export class ${name} extends AggregateRoot<Id> {
-  private props: ${name}Props
-
-  private constructor(id: Id, props: ${name}Props) {
+  private constructor(id: Id, private props: ${name}Props) {
     super(id)
-    this.props = props
   }
 
   static create(id: Id): ${name} {
@@ -2438,7 +4797,12 @@ export class ${name} extends AggregateRoot<Id> {
     return this.props.status
   }
 
-  // Add domain methods here
+  /**
+   * Complete the ${name} process
+   */
+  complete(): void {
+    this.props.status = ${name}Status.COMPLETED
+  }
 }
 `;
   }
@@ -2463,17 +4827,13 @@ export enum ${name}Status {
 import { DomainEvent } from '@gravito/enterprise'
 
 export class ${name}Created extends DomainEvent {
-  constructor(public readonly ${name.toLowerCase()}Id: string) {
+  constructor(public readonly aggregateId: string) {
     super()
   }
 
   override get eventName(): string {
     return '${name.toLowerCase()}.created'
   }
-
-  get aggregateId(): string {
-    return this.${name.toLowerCase()}Id
-  }
 }
 `;
   }
@@ -2500,7 +4860,6 @@ import { Command } from '@gravito/enterprise'
 
 export class Create${name}Command extends Command {
   constructor(
-    // Add command properties
     public readonly id?: string
   ) {
     super()
@@ -2555,13 +4914,15 @@ export class Get${name}ByIdQuery extends Query {
 import { QueryHandler } from '@gravito/enterprise'
 import type { I${name}Repository } from '../../../Domain/Repositories/I${name}Repository'
 import type { ${name}DTO } from '../../DTOs/${name}DTO'
+import { Id } from '../../../../../Shared/Domain/ValueObjects/Id'
 import type { Get${name}ByIdQuery } from './Get${name}ByIdQuery'
 
 export class Get${name}ByIdHandler implements QueryHandler<Get${name}ByIdQuery, ${name}DTO | null> {
   constructor(private repository: I${name}Repository) {}
 
   async handle(query: Get${name}ByIdQuery): Promise<${name}DTO | null> {
-    const aggregate = await this.repository.findById(query.id as any) // Simplified for demo
+    const id = Id.from(query.id)
+    const aggregate = await this.repository.findById(id)
     if (!aggregate) return null
 
     return {
@@ -2582,7 +4943,6 @@ import type { ${name}Status } from '../../Domain/Aggregates/${name}/${name}Statu
 export interface ${name}DTO {
   id: string
   status: ${name}Status
-  // Add more fields
 }
 `;
   }
@@ -2593,29 +4953,29 @@ export interface ${name}DTO {
 
 import type { ${name} } from '../../Domain/Aggregates/${name}/${name}'
 import type { I${name}Repository } from '../../Domain/Repositories/I${name}Repository'
-import type { Id } from '../../../../../Shared/Domain/ValueObjects/Id'
-
-const store = new Map<string, ${name}>()
+import { Id } from '../../../../../Shared/Domain/ValueObjects/Id'
 
 export class ${name}Repository implements I${name}Repository {
+  private store = new Map<string, ${name}>()
+
   async findById(id: Id): Promise<${name} | null> {
-    return store.get(id.value) ?? null
+    return this.store.get(id.value) ?? null
   }
 
   async save(aggregate: ${name}): Promise<void> {
-    store.set(aggregate.id.value, aggregate)
+    this.store.set(aggregate.id.value, aggregate)
   }
 
   async delete(id: Id): Promise<void> {
-    store.delete(id.value)
+    this.store.delete(id.value)
   }
 
   async findAll(): Promise<${name}[]> {
-    return Array.from(store.values())
+    return Array.from(this.store.values())
   }
 
   async exists(id: Id): Promise<boolean> {
-    return store.has(id.value)
+    return this.store.has(id.value)
   }
 }
 `;
@@ -2637,6 +4997,37 @@ export class ${name}ServiceProvider extends ServiceProvider {
         console.log('[${name}] Module loaded')
     }
 }
+`;
+  }
+  generateController(name) {
+    return `/**
+ * ${name} Controller
+ */
+
+import type { GravitoContext } from '@gravito/core'
+
+export class ${name}Controller {
+  /**
+   * GET /${name.toLowerCase()}
+   */
+  async index(ctx: GravitoContext) {
+    return ctx.json({
+      success: true,
+      data: []
+    })
+  }
+
+  /**
+   * GET /${name.toLowerCase()}/:id
+   */
+  async show(ctx: GravitoContext) {
+    const id = ctx.req.param('id')
+    return ctx.json({
+      success: true,
+      data: { id }
+    })
+  }
+}
 `;
   }
 };
@@ -2811,24 +5202,39 @@ export class Email extends ValueObject<EmailProps> {
 
 import type { DomainEvent } from '@gravito/enterprise'
 
-type EventHandler = (event: DomainEvent) => void | Promise<void>
+type EventHandler<T extends DomainEvent = any> = (event: T) => void | Promise<void>
 
 export class EventDispatcher {
   private handlers: Map<string, EventHandler[]> = new Map()
 
-  subscribe(eventName: string, handler: EventHandler): void {
+  /**
+   * Subscribe to an event
+   */
+  subscribe<T extends DomainEvent>(eventName: string, handler: EventHandler<T>): void {
     const handlers = this.handlers.get(eventName) ?? []
     handlers.push(handler)
     this.handlers.set(eventName, handlers)
   }
 
+  /**
+   * Dispatch a single event
+   */
   async dispatch(event: DomainEvent): Promise<void> {
     const handlers = this.handlers.get(event.eventName) ?? []
-    for (const handler of handlers) {
-      await handler(event)
-    }
+    const promises = handlers.map(handler => {
+      try {
+        return handler(event)
+      } catch (error) {
+        console.error(\`[EventDispatcher] Error in handler for \${event.eventName}:\`, error)
+      }
+    })
+    
+    await Promise.all(promises)
   }
 
+  /**
+   * Dispatch multiple events sequentially
+   */
   async dispatchAll(events: DomainEvent[]): Promise<void> {
     for (const event of events) {
       await this.dispatch(event)
@@ -2852,24 +5258,38 @@ export function report(error: unknown): void {
 // src/generators/DddGenerator.ts
 var DddGenerator = class extends BaseGenerator {
   moduleGenerator;
+  advancedModuleGenerator;
+  cqrsQueryModuleGenerator;
   sharedKernelGenerator;
   bootstrapGenerator;
+  moduleType = "simple";
   constructor(config) {
     super(config);
     this.moduleGenerator = new ModuleGenerator();
+    this.advancedModuleGenerator = new AdvancedModuleGenerator();
+    this.cqrsQueryModuleGenerator = new CQRSQueryModuleGenerator();
     this.sharedKernelGenerator = new SharedKernelGenerator();
     this.bootstrapGenerator = new BootstrapGenerator();
   }
+  /**
+   * Set the module type for generated modules
+   * @param type - 'simple' for basic CRUD, 'advanced' for Event Sourcing, 'cqrs-query' for CQRS Read Side
+   * @default 'simple'
+   */
+  setModuleType(type) {
+    this.moduleType = type;
+  }
   get architectureType() {
     return "ddd";
   }
   get displayName() {
-    return "Domain-Driven Design (DDD)";
+    return `Domain-Driven Design (DDD)${this.moduleType === "cqrs-query" ? " + CQRS" : ""}`;
   }
   get description() {
     return "Full DDD with Bounded Contexts, Aggregates, and Event-Driven patterns";
   }
   getDirectoryStructure(context) {
+    const moduleGenerator = this.getModuleGenerator();
     return [
       this.bootstrapGenerator.generateConfigDirectory(context),
       {
@@ -2885,8 +5305,8 @@ var DddGenerator = class extends BaseGenerator {
             type: "directory",
             name: "Modules",
             children: [
-              this.moduleGenerator.generate("Ordering", context),
-              this.moduleGenerator.generate("Catalog", context)
+              moduleGenerator === "cqrs-query" ? this.cqrsQueryModuleGenerator.generate("Ordering", context) : moduleGenerator === "advanced" ? this.advancedModuleGenerator.generate("Ordering", context) : this.moduleGenerator.generate("Ordering", context),
+              moduleGenerator === "cqrs-query" ? this.cqrsQueryModuleGenerator.generate("Catalog", context) : moduleGenerator === "advanced" ? this.advancedModuleGenerator.generate("Catalog", context) : this.moduleGenerator.generate("Catalog", context)
             ]
           },
           {
@@ -2942,6 +5362,12 @@ var DddGenerator = class extends BaseGenerator {
       }
     ];
   }
+  /**
+   * Get the active module generator type
+   */
+  getModuleGenerator() {
+    return this.moduleType;
+  }
   /**
    * Override package.json for DDD architecture (uses main.ts instead of bootstrap.ts)
    */
@@ -2981,6 +5407,69 @@ var DddGenerator = class extends BaseGenerator {
 
 This project follows **Domain-Driven Design (DDD)** with strategic and tactical patterns.
 
+${this.moduleType === "cqrs-query" ? `
+## Module Types
+
+This project uses **CQRS Query Module Template** with event projection:
+- **Read Models**: Denormalized, query-optimized data structures
+- **Event Projectors**: Pure functions transforming events to read models
+- **Query Services**: Dedicated read-side use cases
+- **Event Subscribers**: Subscribe to write-side domain events
+- **Optional Caching**: Dual-tier caching (memory + Redis)
+
+See each module's Domain/Projectors/{ModuleName}EventProjector.ts for projection patterns.
+
+## CQRS Architecture
+
+\`\`\`
+Write Side (Command)          Read Side (Query)
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510      \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502 Aggregate Root       \u2502      \u2502 Read Model           \u2502
+\u2502 (Event Sourcing)     \u2502      \u2502 (Denormalized)       \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+        \u2502                              \u25B2
+        \u2502 Domain Events                \u2502
+        \u25BC                              \u2502
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510      \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502 Event Store          \u2502\u2500\u2500\u2500\u2500\u2500\u25B6\u2502 Event Subscriber     \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+                                      \u2502
+                                      \u2502 Projects Events
+                                      \u25BC
+                             \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+                             \u2502 Event Projector      \u2502
+                             \u2502 (Pure Functions)     \u2502
+                             \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+                                      \u2502
+                                      \u25BC
+                             \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+                             \u2502 Read Model DB        \u2502
+                             \u2502 (Eventually Consistent)
+                             \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+\`\`\`
+` : this.moduleType === "advanced" ? `
+## Module Types
+
+This project uses **Advanced Module Template** with Event Sourcing:
+- **Event Sourcing**: Complete event stream as source of truth
+- **Aggregate Roots**: Domain objects managing state through events
+- **Domain Events**: Rich, expressive events capturing domain changes
+- **Event Store**: Persistent event log for state reconstruction
+- **Event Applier**: Pure functions for immutable state transitions
+
+See each module's Domain/Services/{ModuleName}EventApplier.ts for event handling patterns.
+` : `
+## Module Types
+
+This project uses **Simple Module Template** with basic CRUD:
+- **Aggregates**: Standard entity-based domain objects
+- **Repositories**: Data access abstractions
+- **Services**: Domain and application logic
+- **Events**: Optional domain event support
+
+To upgrade a module to Event Sourcing, use the Advanced template when scaffolding new modules.
+`}
+
 ## Service Providers
 
 Service providers are the central place to configure your application and modules. They follow the ServiceProvider pattern with \`register()\` and \`boot()\` lifecycle methods.
@@ -3011,12 +5500,38 @@ Service providers are the central place to configure your application and module
 Each bounded context follows this structure:
 
 \`\`\`
+${this.moduleType === "cqrs-query" ? `
+Context/                     # CQRS Read Side Module
+\u251C\u2500\u2500 Domain/                  # Query domain logic
+\u2502   \u251C\u2500\u2500 ReadModels/         # Denormalized data structures (immutable)
+\u2502   \u251C\u2500\u2500 Projectors/         # Pure functions: Event \u2192 ReadModel
+\u2502   \u2514\u2500\u2500 Repositories/       # Read model access interfaces
+\u251C\u2500\u2500 Application/            # Query use cases
+\u2502   \u251C\u2500\u2500 Services/          # Query services (findById, findAll, search, etc.)
+\u2502   \u2514\u2500\u2500 DTOs/              # Data transfer objects for responses
+\u251C\u2500\u2500 Infrastructure/        # Data access & external services
+\u2502   \u251C\u2500\u2500 Repositories/      # Read model implementations (ORM)
+\u2502   \u251C\u2500\u2500 Subscribers/       # Event subscribers (trigger projections)
+\u2502   \u2514\u2500\u2500 Cache/             # Optional caching layer (memory + Redis)
+\u2514\u2500\u2500 Presentation/          # Entry points
+    \u251C\u2500\u2500 Controllers/       # HTTP query endpoints
+    \u2514\u2500\u2500 Routes/            # Route registration
+\`\`\`
+
+**Key Differences from Write Side:**
+- No Commands (read-only)
+- No EventStore (subscribes to write-side events)
+- Pure projectors (deterministic, testable)
+- Read models optimized for specific queries
+- Eventual consistency (projections may lag behind events)
+` : `
 Context/
 \u251C\u2500\u2500 Domain/              # Core business logic
 \u2502   \u251C\u2500\u2500 Aggregates/     # Aggregate roots + entities
 \u2502   \u251C\u2500\u2500 Events/         # Domain events
 \u2502   \u251C\u2500\u2500 Repositories/   # Repository interfaces
-\u2502   \u2514\u2500\u2500 Services/       # Domain services
+\u2502   \u251C\u2500\u2500 Services/       # Domain services (${this.moduleType === "advanced" ? "EventApplier for Event Sourcing" : "domain logic"})
+\u2502   \u2514\u2500\u2500 ValueObjects/   # Domain value objects
 \u251C\u2500\u2500 Application/        # Use cases
 \u2502   \u251C\u2500\u2500 Commands/       # Write operations
 \u2502   \u251C\u2500\u2500 Queries/        # Read operations
@@ -3024,11 +5539,13 @@ Context/
 \u2502   \u2514\u2500\u2500 DTOs/           # Data transfer objects
 \u251C\u2500\u2500 Infrastructure/     # External concerns
 \u2502   \u251C\u2500\u2500 Persistence/    # Repository implementations
+\u2502   \u251C\u2500\u2500 EventStore/     # ${this.moduleType === "advanced" ? "Event storage and reconstruction" : "(optional) Event storage"}
 \u2502   \u2514\u2500\u2500 Providers/      # DI configuration
 \u2514\u2500\u2500 UserInterface/      # Entry points
     \u251C\u2500\u2500 Http/           # REST controllers
     \u2514\u2500\u2500 Cli/            # CLI commands
 \`\`\`
+`}
 
 ## SharedKernel
 
@@ -3044,6 +5561,10 @@ Contains types shared across contexts:
 2. **Domain Events**: Inter-context communication
 3. **CQRS**: Separate read/write models
 4. **Repository Pattern**: Persistence abstraction
+${this.moduleType === "cqrs-query" ? `5. **Event Projection**: Transforming events to denormalized read models
+6. **Pure Projectors**: Deterministic, testable event handlers
+7. **Eventual Consistency**: Read models eventually consistent with events
+8. **Query Optimization**: Read models optimized for specific use cases` : this.moduleType === "advanced" ? "5. **Event Sourcing**: Event stream as single source of truth\n6. **Event Applier**: Pure functions for state transitions" : ""}
 
 Created with \u2764\uFE0F using Gravito Framework
 `;
@@ -3938,9 +6459,9 @@ var SatelliteGenerator = class extends BaseGenerator {
             children: [
               {
                 type: "directory",
-                name: "Entities",
+                name: "Aggregates",
                 children: [
-                  { type: "file", name: `${name}.ts`, content: this.generateEntity(name) }
+                  { type: "file", name: `${name}.ts`, content: this.generateAggregate(name) }
                 ]
               },
               {
@@ -3954,8 +6475,24 @@ var SatelliteGenerator = class extends BaseGenerator {
                   }
                 ]
               },
-              { type: "directory", name: "ValueObjects", children: [] },
-              { type: "directory", name: "Events", children: [] }
+              {
+                type: "directory",
+                name: "ValueObjects",
+                children: [
+                  { type: "file", name: `${name}Id.ts`, content: this.generateIdValueObject(name) }
+                ]
+              },
+              {
+                type: "directory",
+                name: "Events",
+                children: [
+                  {
+                    type: "file",
+                    name: `${name}Created.ts`,
+                    content: this.generateCreatedEvent(name)
+                  }
+                ]
+              }
             ]
           },
           // Application Layer
@@ -3996,6 +6533,31 @@ var SatelliteGenerator = class extends BaseGenerator {
               }
             ]
           },
+          // Interface Layer (HTTP/API)
+          {
+            type: "directory",
+            name: "Interface",
+            children: [
+              {
+                type: "directory",
+                name: "Http",
+                children: [
+                  {
+                    type: "directory",
+                    name: "Controllers",
+                    children: [
+                      {
+                        type: "file",
+                        name: `${name}Controller.ts`,
+                        content: this.generateController(name)
+                      }
+                    ]
+                  },
+                  { type: "directory", name: "Middleware", children: [] }
+                ]
+              }
+            ]
+          },
           // Entry Point
           { type: "file", name: "index.ts", content: this.generateEntryPoint(name) },
           {
@@ -4013,13 +6575,12 @@ var SatelliteGenerator = class extends BaseGenerator {
           {
             type: "file",
             name: "unit.test.ts",
-            content: `import { describe, it, expect } from "bun:test";
-
-describe("${name}", () => {
-  it("should work", () => {
-    expect(true).toBe(true);
-  });
-});`
+            content: this.generateUnitTest(name)
+          },
+          {
+            type: "file",
+            name: "integration.test.ts",
+            content: this.generateIntegrationTest(name)
           }
         ]
       }
@@ -4028,35 +6589,76 @@ describe("${name}", () => {
   // ─────────────────────────────────────────────────────────────
   // Domain Templates
   // ─────────────────────────────────────────────────────────────
-  generateEntity(name) {
-    return `import { Entity } from '@gravito/enterprise'
+  generateIdValueObject(name) {
+    return `import { ValueObject } from '@gravito/enterprise'
+
+interface IdProps {
+  value: string
+}
+
+export class ${name}Id extends ValueObject<IdProps> {
+  constructor(value: string) {
+    super({ value })
+  }
+
+  static create(): ${name}Id {
+    return new ${name}Id(crypto.randomUUID())
+  }
+
+  get value(): string { return this.props.value }
+}
+`;
+  }
+  generateAggregate(name) {
+    return `import { AggregateRoot } from '@gravito/enterprise'
+import { ${name}Id } from '../ValueObjects/${name}Id'
+import { ${name}Created } from '../Events/${name}Created'
 
 export interface ${name}Props {
   name: string
   createdAt: Date
 }
 
-export class ${name} extends Entity<string> {
-  constructor(id: string, private props: ${name}Props) {
+export class ${name} extends AggregateRoot<${name}Id> {
+  constructor(id: ${name}Id, private props: ${name}Props) {
     super(id)
   }
 
-  static create(id: string, name: string): ${name} {
-    return new ${name}(id, {
+  static create(id: ${name}Id, name: string): ${name} {
+    const aggregate = new ${name}(id, {
       name,
       createdAt: new Date()
     })
+
+    aggregate.addDomainEvent(new ${name}Created(id.value))
+
+    return aggregate
   }
 
   get name() { return this.props.name }
 }
+`;
+  }
+  generateCreatedEvent(name) {
+    return `import { DomainEvent } from '@gravito/enterprise'
+
+export class ${name}Created extends DomainEvent {
+  constructor(public readonly aggregateId: string) {
+    super()
+  }
+
+  get eventName(): string {
+    return '${this.context?.nameKebabCase}.created'
+  }
+}
 `;
   }
   generateRepositoryInterface(name) {
     return `import { Repository } from '@gravito/enterprise'
-import { ${name} } from '../Entities/${name}'
+import { ${name} } from '../Aggregates/${name}'
+import { ${name}Id } from '../ValueObjects/${name}Id'
 
-export interface I${name}Repository extends Repository<${name}, string> {
+export interface I${name}Repository extends Repository<${name}, ${name}Id> {
   // Add custom methods here
 }
 `;
@@ -4067,7 +6669,8 @@ export interface I${name}Repository extends Repository<${name}, string> {
   generateUseCase(name) {
     return `import { UseCase } from '@gravito/enterprise'
 import { I${name}Repository } from '../../Domain/Contracts/I${name}Repository'
-import { ${name} } from '../../Domain/Entities/${name}'
+import { ${name} } from '../../Domain/Aggregates/${name}'
+import { ${name}Id } from '../../Domain/ValueObjects/${name}Id'
 
 export interface Create${name}Input {
   name: string
@@ -4079,12 +6682,12 @@ export class Create${name} extends UseCase<Create${name}Input, string> {
   }
 
   async execute(input: Create${name}Input): Promise<string> {
-    const id = crypto.randomUUID()
+    const id = ${name}Id.create()
     const entity = ${name}.create(id, input.name)
     
     await this.repository.save(entity)
     
-    return id
+    return id.value
   }
 }
 `;
@@ -4094,17 +6697,16 @@ export class Create${name} extends UseCase<Create${name}Input, string> {
   // ─────────────────────────────────────────────────────────────
   generateAtlasRepository(name) {
     return `import { I${name}Repository } from '../../Domain/Contracts/I${name}Repository'
-import { ${name} } from '../../Domain/Entities/${name}'
-import { DB } from '@gravito/atlas'
+import { ${name} } from '../../Domain/Aggregates/${name}'
+import { ${name}Id } from '../../Domain/ValueObjects/${name}Id'
 
 export class Atlas${name}Repository implements I${name}Repository {
   async save(entity: ${name}): Promise<void> {
-    // Dogfooding: Use @gravito/atlas for persistence
-    console.log('[Atlas] Saving entity:', entity.id)
-    // await DB.table('${name.toLowerCase()}s').insert({ ... })
+    // Implementation using @gravito/atlas
+    console.log('[Atlas] Saving aggregate:', entity.id.value)
   }
 
-  async findById(id: string): Promise<${name} | null> {
+  async findById(id: ${name}Id): Promise<${name} | null> {
     return null
   }
 
@@ -4112,12 +6714,77 @@ export class Atlas${name}Repository implements I${name}Repository {
     return []
   }
 
-  async delete(id: string): Promise<void> {}
+  async delete(id: ${name}Id): Promise<void> {}
 
-  async exists(id: string): Promise<boolean> {
+  async exists(id: ${name}Id): Promise<boolean> {
     return false
   }
 }
+`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Test Templates
+  // ─────────────────────────────────────────────────────────────
+  generateUnitTest(name) {
+    return `import { describe, it, expect } from "bun:test";
+import { ${name} } from "../src/Domain/Aggregates/${name}";
+import { ${name}Id } from "../src/Domain/ValueObjects/${name}Id";
+
+describe("${name} Aggregate", () => {
+  it("should create a new aggregate with a domain event", () => {
+    const id = ${name}Id.create();
+    const aggregate = ${name}.create(id, "Test Name");
+
+    expect(aggregate.id).toBe(id);
+    expect(aggregate.name).toBe("Test Name");
+    expect(aggregate.pullDomainEvents()).toHaveLength(1);
+  });
+});`;
+  }
+  generateIntegrationTest(name) {
+    return `import { describe, it, expect, beforeAll } from "bun:test";
+import { PlanetCore } from "@gravito/core";
+
+describe("${name} Integration", () => {
+  let core: PlanetCore;
+
+  beforeAll(async () => {
+    core = new PlanetCore();
+    // Setup dependencies here
+  });
+
+  it("should handle the creation flow", async () => {
+    expect(true).toBe(true); // Placeholder for actual integration logic
+  });
+});`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Interface Templates
+  // ─────────────────────────────────────────────────────────────
+  generateController(name) {
+    return `import type { GravitoContext } from '@gravito/core'
+import { Create${name} } from '../../../Application/UseCases/Create${name}'
+
+export class ${name}Controller {
+  constructor(private createUseCase: Create${name}) {}
+
+  async store(ctx: GravitoContext) {
+    const body = await ctx.req.json()
+    const id = await this.createUseCase.execute({ name: body.name })
+    
+    return ctx.json({
+      success: true,
+      data: { id }
+    }, 201)
+  }
+
+  async index(ctx: GravitoContext) {
+    return ctx.json({
+      success: true,
+      data: []
+    })
+  }
+}
 `;
   }
   // ─────────────────────────────────────────────────────────────
@@ -4126,17 +6793,22 @@ export class Atlas${name}Repository implements I${name}Repository {
   generateEntryPoint(name) {
     return `import { ServiceProvider, type Container } from '@gravito/core'
 import { Atlas${name}Repository } from './Infrastructure/Persistence/Atlas${name}Repository'
+import { Create${name} } from './Application/UseCases/Create${name}'
+import { ${name}Controller } from './Interface/Http/Controllers/${name}Controller'
 
 export class ${name}ServiceProvider extends ServiceProvider {
   register(container: Container): void {
-    // Bind Repository
+    // 1. Bind Repository (Infrastructure)
     container.singleton('${name.toLowerCase()}.repo', () => new Atlas${name}Repository())
     
-    // Bind UseCases
-    container.singleton('${name.toLowerCase()}.create', () => {
-        return new (require('./Application/UseCases/Create${name}').Create${name})(
-            container.make('${name.toLowerCase()}.repo')
-        )
+    // 2. Bind UseCases (Application)
+    container.singleton('${name.toLowerCase()}.usecase.create', (c) => {
+        return new Create${name}(c.make('${name.toLowerCase()}.repo'))
+    })
+
+    // 3. Bind Controllers (Interface)
+    container.singleton('${name.toLowerCase()}.controller', (c) => {
+        return new ${name}Controller(c.make('${name.toLowerCase()}.usecase.create'))
     })
   }
 
@@ -4247,7 +6919,9 @@ var ProfileResolver = class _ProfileResolver {
         storage: "local",
         session: "file"
       },
-      features: []
+      features: [],
+      workers: "basic"
+      // Basic workers configuration for core profile
     },
     scale: {
       drivers: {
@@ -4257,7 +6931,9 @@ var ProfileResolver = class _ProfileResolver {
         storage: "s3",
         session: "redis"
       },
-      features: ["stream", "nebula"]
+      features: ["stream", "nebula"],
+      workers: "advanced"
+      // Advanced workers with Bun optimizations
     },
     enterprise: {
       drivers: {
@@ -4267,14 +6943,17 @@ var ProfileResolver = class _ProfileResolver {
         storage: "s3",
         session: "redis"
       },
-      features: ["stream", "nebula", "monitor", "sentinel", "fortify"]
+      features: ["stream", "nebula", "monitor", "sentinel", "fortify"],
+      workers: "production"
+      // Production-optimized workers
     }
   };
   resolve(profile = "core", withFeatures = []) {
     const base = _ProfileResolver.DEFAULTS[profile] || _ProfileResolver.DEFAULTS.core;
     const config = {
       drivers: { ...base.drivers },
-      features: [...base.features]
+      features: [...base.features],
+      workers: base.workers
     };
     for (const feature of withFeatures) {
       this.applyFeature(config, feature);
@@ -4342,6 +7021,7 @@ var ProfileResolver = class _ProfileResolver {
 
 // src/Scaffold.ts
 import path6 from "path";
+import { fileURLToPath } from "url";
 
 // src/generators/ActionDomainGenerator.ts
 var ActionDomainGenerator = class extends BaseGenerator {
@@ -5015,11 +7695,15 @@ bun start
 };
 
 // src/Scaffold.ts
-var Scaffold = class {
+var Scaffold = class _Scaffold {
   templatesDir;
   verbose;
+  static packageDir = path6.resolve(
+    path6.dirname(fileURLToPath(import.meta.url)),
+    ".."
+  );
   constructor(options = {}) {
-    this.templatesDir = options.templatesDir ?? path6.resolve(__dirname, "../templates");
+    this.templatesDir = options.templatesDir ?? path6.resolve(_Scaffold.packageDir, "templates");
     this.verbose = options.verbose ?? false;
   }
   /**
@@ -5071,7 +7755,7 @@ var Scaffold = class {
    * @returns {Promise<ScaffoldResult>}
    */
   async create(options) {
-    const generator = this.createGenerator(options.architecture);
+    const generator = this.createGenerator(options);
     const fs5 = await import("fs/promises");
     const profileResolver = new ProfileResolver();
     const profileConfig = profileResolver.resolve(options.profile, options.features);
@@ -5117,29 +7801,39 @@ var Scaffold = class {
     }
   }
   /**
-   * Create a generator for the specified architecture.
+   * Create a generator for the specified architecture with options.
+   * @param options - Scaffold options including architecture type and module type for DDD
    */
-  createGenerator(type) {
+  createGenerator(options) {
     const config = {
       templatesDir: this.templatesDir,
       verbose: this.verbose
     };
-    switch (type) {
-      case "enterprise-mvc":
-        return new EnterpriseMvcGenerator(config);
-      case "clean":
-        return new CleanArchitectureGenerator(config);
-      case "ddd":
-        return new DddGenerator(config);
-      case "action-domain":
-        return new ActionDomainGenerator(config);
-      case "satellite":
-        return new SatelliteGenerator(config);
-      case "standalone-engine":
-        return new StandaloneEngineGenerator(config);
-      default:
-        throw new Error(`Unknown architecture type: ${type}`);
-    }
+    const type = typeof options === "string" ? options : options.architecture;
+    const generator = (() => {
+      switch (type) {
+        case "enterprise-mvc":
+          return new EnterpriseMvcGenerator(config);
+        case "clean":
+          return new CleanArchitectureGenerator(config);
+        case "ddd": {
+          const dddGen = new DddGenerator(config);
+          if (typeof options !== "string" && options.dddModuleType) {
+            dddGen.setModuleType(options.dddModuleType);
+          }
+          return dddGen;
+        }
+        case "action-domain":
+          return new ActionDomainGenerator(config);
+        case "satellite":
+          return new SatelliteGenerator(config);
+        case "standalone-engine":
+          return new StandaloneEngineGenerator(config);
+        default:
+          throw new Error(`Unknown architecture type: ${type}`);
+      }
+    })();
+    return generator;
   }
   /**
    * Generate a single module (for DDD bounded context).
@@ -5155,7 +7849,9 @@ var Scaffold = class {
   }
 };
 export {
+  AdvancedModuleGenerator,
   BaseGenerator,
+  CQRSQueryModuleGenerator,
   CleanArchitectureGenerator,
   DddGenerator,
   DependencyValidator,