@gravito/scaffold 4.0.0 → 4.1.0

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
@@ -2395,6 +2507,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 +2546,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 +2570,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 +2600,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 +2633,6 @@ import { Command } from '@gravito/enterprise'
 
 export class Create${name}Command extends Command {
   constructor(
-    // Add command properties
     public readonly id?: string
   ) {
     super()
@@ -2555,13 +2687,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 +2716,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 +2726,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 +2770,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 +2975,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)
@@ -3938,9 +4117,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 +4133,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 +4191,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 +4233,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 +4247,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 +4327,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 +4340,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 +4355,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 +4372,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 +4451,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 +4577,9 @@ var ProfileResolver = class _ProfileResolver {
         storage: "local",
         session: "file"
       },
-      features: []
+      features: [],
+      workers: "basic"
+      // Basic workers configuration for core profile
     },
     scale: {
       drivers: {
@@ -4257,7 +4589,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 +4601,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);