create-fluxstack 1.0.13 → 1.0.14

package/core/cli/generators/controller.ts

@@ -0,0 +1,299 @@
+import type { Generator } from "./index.js"
+import type { GeneratorContext, GeneratorOptions, Template } from "./types.js"
+import { templateEngine } from "./template-engine.js"
+
+export class ControllerGenerator implements Generator {
+  name = 'controller'
+  description = 'Generate a new controller with CRUD operations'
+
+  async generate(context: GeneratorContext, options: GeneratorOptions): Promise<void> {
+    const template = this.getTemplate(options.template)
+    
+    // Execute before hook if present
+    if (template.hooks?.beforeGenerate) {
+      await template.hooks.beforeGenerate(context, options)
+    }
+
+    const files = await templateEngine.processTemplate(template, context, options)
+    
+    if (options.dryRun) {
+      console.log(`\n📋 Would generate controller '${options.name}':\n`)
+      for (const file of files) {
+        console.log(`${file.action === 'create' ? '📄' : '✏️'} ${file.path}`)
+      }
+      return
+    }
+
+    await templateEngine.generateFiles(files, options.dryRun)
+    
+    // Execute after hook if present
+    if (template.hooks?.afterGenerate) {
+      const filePaths = files.map(f => f.path)
+      await template.hooks.afterGenerate(context, options, filePaths)
+    }
+
+    console.log(`\n✅ Generated controller '${options.name}' with ${files.length} files`)
+  }
+
+  private getTemplate(templateName?: string): Template {
+    switch (templateName) {
+      case 'minimal':
+        return this.getMinimalTemplate()
+      case 'crud':
+      default:
+        return this.getCrudTemplate()
+    }
+  }
+
+  private getCrudTemplate(): Template {
+    return {
+      name: 'crud-controller',
+      description: 'Full CRUD controller with validation',
+      files: [
+        {
+          path: 'app/server/controllers/{{kebabName}}.controller.ts',
+          content: `import { Elysia, t } from 'elysia'
+import { {{pascalName}}Service } from '../services/{{kebabName}}.service'
+import { {{pascalName}}Schema, Create{{pascalName}}Schema, Update{{pascalName}}Schema } from '../schemas/{{kebabName}}.schema'
+import { NotFoundError, ValidationError } from '../../../core/utils/errors'
+
+export class {{pascalName}}Controller {
+  private service: {{pascalName}}Service
+
+  constructor() {
+    this.service = new {{pascalName}}Service()
+  }
+
+  routes() {
+    return new Elysia({ prefix: '/{{kebabName}}s' })
+      .get('/', this.getAll.bind(this))
+      .get('/:id', this.getById.bind(this), {
+        params: t.Object({
+          id: t.String()
+        })
+      })
+      .post('/', this.create.bind(this), {
+        body: Create{{pascalName}}Schema
+      })
+      .put('/:id', this.update.bind(this), {
+        params: t.Object({
+          id: t.String()
+        }),
+        body: Update{{pascalName}}Schema
+      })
+      .delete('/:id', this.delete.bind(this), {
+        params: t.Object({
+          id: t.String()
+        })
+      })
+  }
+
+  async getAll() {
+    try {
+      const {{camelName}}s = await this.service.findAll()
+      return {
+        success: true,
+        data: {{camelName}}s,
+        count: {{camelName}}s.length
+      }
+    } catch (error) {
+      throw new Error(\`Failed to fetch {{camelName}}s: \${error instanceof Error ? error.message : 'Unknown error'}\`)
+    }
+  }
+
+  async getById({ params }: { params: { id: string } }) {
+    try {
+      const {{camelName}} = await this.service.findById(params.id)
+      
+      if (!{{camelName}}) {
+        throw new NotFoundError('{{pascalName}} not found')
+      }
+
+      return {
+        success: true,
+        data: {{camelName}}
+      }
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        throw error
+      }
+      throw new Error(\`Failed to fetch {{camelName}}: \${error instanceof Error ? error.message : 'Unknown error'}\`)
+    }
+  }
+
+  async create({ body }: { body: any }) {
+    try {
+      const {{camelName}} = await this.service.create(body)
+      
+      return {
+        success: true,
+        data: {{camelName}},
+        message: '{{pascalName}} created successfully'
+      }
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        throw error
+      }
+      throw new Error(\`Failed to create {{camelName}}: \${error instanceof Error ? error.message : 'Unknown error'}\`)
+    }
+  }
+
+  async update({ params, body }: { params: { id: string }, body: any }) {
+    try {
+      const {{camelName}} = await this.service.update(params.id, body)
+      
+      if (!{{camelName}}) {
+        throw new NotFoundError('{{pascalName}} not found')
+      }
+
+      return {
+        success: true,
+        data: {{camelName}},
+        message: '{{pascalName}} updated successfully'
+      }
+    } catch (error) {
+      if (error instanceof NotFoundError || error instanceof ValidationError) {
+        throw error
+      }
+      throw new Error(\`Failed to update {{camelName}}: \${error instanceof Error ? error.message : 'Unknown error'}\`)
+    }
+  }
+
+  async delete({ params }: { params: { id: string } }) {
+    try {
+      const deleted = await this.service.delete(params.id)
+      
+      if (!deleted) {
+        throw new NotFoundError('{{pascalName}} not found')
+      }
+
+      return {
+        success: true,
+        message: '{{pascalName}} deleted successfully'
+      }
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        throw error
+      }
+      throw new Error(\`Failed to delete {{camelName}}: \${error instanceof Error ? error.message : 'Unknown error'}\`)
+    }
+  }
+}
+`
+        },
+        {
+          path: 'app/server/schemas/{{kebabName}}.schema.ts',
+          content: `import { t } from 'elysia'
+
+export const {{pascalName}}Schema = t.Object({
+  id: t.String(),
+  name: t.String(),
+  description: t.Optional(t.String()),
+  createdAt: t.Date(),
+  updatedAt: t.Date()
+})
+
+export const Create{{pascalName}}Schema = t.Object({
+  name: t.String({
+    minLength: 1,
+    maxLength: 100,
+    error: 'Name must be between 1 and 100 characters'
+  }),
+  description: t.Optional(t.String({
+    maxLength: 500,
+    error: 'Description must be less than 500 characters'
+  }))
+})
+
+export const Update{{pascalName}}Schema = t.Partial(Create{{pascalName}}Schema)
+
+export type {{pascalName}} = typeof {{pascalName}}Schema.static
+export type Create{{pascalName}} = typeof Create{{pascalName}}Schema.static
+export type Update{{pascalName}} = typeof Update{{pascalName}}Schema.static
+`
+        }
+      ],
+      hooks: {
+        afterGenerate: async (context, options, files) => {
+          context.logger.info(`Generated controller files:`)
+          files.forEach(file => {
+            context.logger.info(`  - ${file}`)
+          })
+          context.logger.info(`\nNext steps:`)
+          context.logger.info(`1. Generate the corresponding service: flux generate service ${options.name}`)
+          context.logger.info(`2. Add the controller to your routes in app/server/routes/`)
+          context.logger.info(`3. Implement the business logic in the service`)
+        }
+      }
+    }
+  }
+
+  private getMinimalTemplate(): Template {
+    return {
+      name: 'minimal-controller',
+      description: 'Minimal controller with basic structure',
+      files: [
+        {
+          path: 'app/server/controllers/{{kebabName}}.controller.ts',
+          content: `import { Elysia } from 'elysia'
+
+export class {{pascalName}}Controller {
+  routes() {
+    return new Elysia({ prefix: '/{{kebabName}}s' })
+      .get('/', this.index.bind(this))
+      .get('/:id', this.show.bind(this))
+      .post('/', this.create.bind(this))
+      .put('/:id', this.update.bind(this))
+      .delete('/:id', this.destroy.bind(this))
+  }
+
+  async index() {
+    // TODO: Implement list logic
+    return {
+      success: true,
+      data: [],
+      message: 'List {{camelName}}s'
+    }
+  }
+
+  async show({ params }: { params: { id: string } }) {
+    // TODO: Implement show logic
+    return {
+      success: true,
+      data: { id: params.id },
+      message: 'Show {{camelName}}'
+    }
+  }
+
+  async create({ body }: { body: any }) {
+    // TODO: Implement create logic
+    return {
+      success: true,
+      data: body,
+      message: '{{pascalName}} created'
+    }
+  }
+
+  async update({ params, body }: { params: { id: string }, body: any }) {
+    // TODO: Implement update logic
+    return {
+      success: true,
+      data: { id: params.id, ...body },
+      message: '{{pascalName}} updated'
+    }
+  }
+
+  async destroy({ params }: { params: { id: string } }) {
+    // TODO: Implement delete logic
+    return {
+      success: true,
+      message: '{{pascalName}} deleted'
+    }
+  }
+}
+`
+        }
+      ]
+    }
+  }
+}

package/core/cli/generators/index.ts

@@ -0,0 +1,144 @@
+import type { CliCommand } from "../../plugins/types.js"
+import { ControllerGenerator } from "./controller.js"
+import { RouteGenerator } from "./route.js"
+import { ComponentGenerator } from "./component.js"
+import { ServiceGenerator } from "./service.js"
+import type { GeneratorContext, GeneratorOptions } from "./types.js"
+
+export interface Generator {
+  name: string
+  description: string
+  generate(context: GeneratorContext, options: GeneratorOptions): Promise<void>
+}
+
+export class GeneratorRegistry {
+  private generators = new Map<string, Generator>()
+
+  constructor() {
+    this.registerBuiltInGenerators()
+  }
+
+  private registerBuiltInGenerators() {
+    this.register(new ControllerGenerator())
+    this.register(new RouteGenerator())
+    this.register(new ComponentGenerator())
+    this.register(new ServiceGenerator())
+  }
+
+  register(generator: Generator): void {
+    this.generators.set(generator.name, generator)
+  }
+
+  get(name: string): Generator | undefined {
+    return this.generators.get(name)
+  }
+
+  getAll(): Generator[] {
+    return Array.from(this.generators.values())
+  }
+
+  has(name: string): boolean {
+    return this.generators.has(name)
+  }
+}
+
+export const generatorRegistry = new GeneratorRegistry()
+
+// Export additional commands
+export { interactiveGenerateCommand } from "./interactive.js"
+
+// CLI command for code generation
+export const generateCommand: CliCommand = {
+  name: 'generate',
+  description: 'Generate code from templates',
+  usage: 'flux generate <type> <name> [options]',
+  aliases: ['g', 'gen'],
+  category: 'Development',
+  examples: [
+    'flux generate controller user',
+    'flux generate component UserCard',
+    'flux generate service auth',
+    'flux generate route api/users'
+  ],
+  arguments: [
+    {
+      name: 'type',
+      description: 'Type of code to generate',
+      required: true,
+      type: 'string',
+      choices: ['controller', 'route', 'component', 'service']
+    },
+    {
+      name: 'name',
+      description: 'Name of the generated item',
+      required: true,
+      type: 'string'
+    }
+  ],
+  options: [
+    {
+      name: 'path',
+      short: 'p',
+      description: 'Custom path for generated files',
+      type: 'string'
+    },
+    {
+      name: 'template',
+      short: 't',
+      description: 'Template variant to use',
+      type: 'string'
+    },
+    {
+      name: 'force',
+      short: 'f',
+      description: 'Overwrite existing files',
+      type: 'boolean',
+      default: false
+    },
+    {
+      name: 'dry-run',
+      description: 'Show what would be generated without creating files',
+      type: 'boolean',
+      default: false
+    }
+  ],
+  handler: async (args, options, context) => {
+    const [type, name] = args
+    
+    const generator = generatorRegistry.get(type)
+    if (!generator) {
+      console.error(`❌ Unknown generator type: ${type}`)
+      console.log('\nAvailable generators:')
+      for (const gen of generatorRegistry.getAll()) {
+        console.log(`  ${gen.name.padEnd(12)} ${gen.description}`)
+      }
+      return
+    }
+
+    const generatorContext: GeneratorContext = {
+      workingDir: context.workingDir,
+      config: context.config,
+      logger: context.logger,
+      utils: context.utils
+    }
+
+    const generatorOptions: GeneratorOptions = {
+      name,
+      path: options.path,
+      template: options.template,
+      force: options.force,
+      dryRun: options['dry-run']
+    }
+
+    try {
+      await generator.generate(generatorContext, generatorOptions)
+      
+      if (!options['dry-run']) {
+        console.log(`✅ Successfully generated ${type}: ${name}`)
+      }
+    } catch (error) {
+      console.error(`❌ Failed to generate ${type}:`, error instanceof Error ? error.message : String(error))
+      throw error
+    }
+  }
+}

package/core/cli/generators/interactive.ts

@@ -0,0 +1,228 @@
+import type { CliCommand } from "../../plugins/types.js"
+import { generatorRegistry } from "./index.js"
+import type { GeneratorContext, GeneratorOptions } from "./types.js"
+import { promptSystem } from "./prompts.js"
+
+export const interactiveGenerateCommand: CliCommand = {
+  name: 'generate:interactive',
+  description: 'Generate code interactively with prompts',
+  usage: 'flux generate:interactive',
+  aliases: ['gi', 'gen:i'],
+  category: 'Development',
+  examples: [
+    'flux generate:interactive',
+    'flux gi'
+  ],
+  handler: async (args, options, context) => {
+    console.log('🎯 FluxStack Interactive Code Generator\n')
+    
+    // Select generator type
+    const generators = generatorRegistry.getAll()
+    const generatorChoices = generators.map(gen => ({
+      name: `${gen.name} - ${gen.description}`,
+      value: gen.name
+    }))
+    
+    const selectedType = await promptSystem.select(
+      'What would you like to generate?',
+      generatorChoices
+    )
+    
+    const generator = generatorRegistry.get(selectedType)
+    if (!generator) {
+      console.error(`❌ Generator not found: ${selectedType}`)
+      return
+    }
+    
+    // Get name
+    const name = await promptSystem.input(
+      `Enter the ${selectedType} name:`,
+      undefined,
+      (value) => {
+        if (!value.trim()) {
+          return 'Name is required'
+        }
+        if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value)) {
+          return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores'
+        }
+        return true
+      }
+    )
+    
+    // Get template variant (if applicable)
+    let template: string | undefined
+    if (selectedType === 'controller') {
+      template = await promptSystem.select(
+        'Choose controller template:',
+        [
+          { name: 'CRUD - Full CRUD operations with validation', value: 'crud' },
+          { name: 'Minimal - Basic structure only', value: 'minimal' }
+        ]
+      )
+    } else if (selectedType === 'component') {
+      template = await promptSystem.select(
+        'Choose component template:',
+        [
+          { name: 'Basic - Simple component', value: 'basic' },
+          { name: 'Functional - Component with hooks', value: 'functional' },
+          { name: 'Page - Page component with layout', value: 'page' },
+          { name: 'Form - Form component with validation', value: 'form' },
+          { name: 'Full - Complete with tests and stories', value: 'full' }
+        ]
+      )
+    } else if (selectedType === 'service') {
+      template = await promptSystem.select(
+        'Choose service template:',
+        [
+          { name: 'CRUD - Full service with repository', value: 'crud' },
+          { name: 'Repository - Service with repository pattern', value: 'repository' },
+          { name: 'Minimal - Basic structure only', value: 'minimal' }
+        ]
+      )
+    } else if (selectedType === 'route') {
+      template = await promptSystem.select(
+        'Choose route template:',
+        [
+          { name: 'CRUD - Full REST API routes', value: 'crud' },
+          { name: 'Auth - Authentication routes', value: 'auth' },
+          { name: 'Minimal - Basic routes only', value: 'minimal' }
+        ]
+      )
+    }
+    
+    // Get custom path (optional)
+    const useCustomPath = await promptSystem.confirm(
+      'Do you want to specify a custom path?',
+      false
+    )
+    
+    let customPath: string | undefined
+    if (useCustomPath) {
+      customPath = await promptSystem.input(
+        'Enter custom path (relative to project root):'
+      )
+    }
+    
+    // Confirm overwrite if files exist
+    const force = await promptSystem.confirm(
+      'Overwrite existing files if they exist?',
+      false
+    )
+    
+    // Show dry run first
+    console.log('\n📋 Preview of files to be generated:\n')
+    
+    const generatorContext: GeneratorContext = {
+      workingDir: context.workingDir,
+      config: context.config,
+      logger: context.logger,
+      utils: context.utils
+    }
+
+    const generatorOptions: GeneratorOptions = {
+      name,
+      path: customPath,
+      template,
+      force,
+      dryRun: true
+    }
+
+    try {
+      await generator.generate(generatorContext, generatorOptions)
+      
+      const proceed = await promptSystem.confirm(
+        '\nProceed with generation?',
+        true
+      )
+      
+      if (!proceed) {
+        console.log('❌ Generation cancelled')
+        return
+      }
+      
+      // Generate for real
+      generatorOptions.dryRun = false
+      await generator.generate(generatorContext, generatorOptions)
+      
+      console.log(`\n✅ Successfully generated ${selectedType}: ${name}`)
+      
+      // Ask if user wants to generate related files
+      await suggestRelatedGenerations(selectedType, name, generatorContext)
+      
+    } catch (error) {
+      console.error(`❌ Failed to generate ${selectedType}:`, error instanceof Error ? error.message : String(error))
+      throw error
+    }
+  }
+}
+
+async function suggestRelatedGenerations(
+  generatedType: string, 
+  name: string, 
+  context: GeneratorContext
+): Promise<void> {
+  const suggestions: Array<{ type: string; description: string }> = []
+  
+  switch (generatedType) {
+    case 'controller':
+      suggestions.push(
+        { type: 'service', description: `Generate ${name} service for business logic` },
+        { type: 'route', description: `Generate ${name} routes to expose the controller` }
+      )
+      break
+    case 'service':
+      suggestions.push(
+        { type: 'controller', description: `Generate ${name} controller to use this service` }
+      )
+      break
+    case 'route':
+      suggestions.push(
+        { type: 'controller', description: `Generate ${name} controller for route handlers` }
+      )
+      break
+    case 'component':
+      // No automatic suggestions for components
+      break
+  }
+  
+  if (suggestions.length === 0) {
+    return
+  }
+  
+  console.log('\n💡 Suggested next steps:')
+  for (const suggestion of suggestions) {
+    console.log(`   • ${suggestion.description}`)
+  }
+  
+  const generateRelated = await promptSystem.confirm(
+    '\nWould you like to generate related files now?',
+    false
+  )
+  
+  if (!generateRelated) {
+    return
+  }
+  
+  for (const suggestion of suggestions) {
+    const shouldGenerate = await promptSystem.confirm(
+      `Generate ${suggestion.type} for ${name}?`,
+      true
+    )
+    
+    if (shouldGenerate) {
+      const generator = generatorRegistry.get(suggestion.type)
+      if (generator) {
+        try {
+          await generator.generate(context, {
+            name,
+            force: false,
+            dryRun: false
+          })
+          console.log(`✅ Generated ${suggestion.type}: ${name}`)
+        } catch (error) {
+          console.error(`❌ Failed to generate ${suggestion.type}:`, error instanceof Error ? error.message : String(error))
+        }
+      }
+    }
+  }
+}