@igniter-js/cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const helpers_1 = require("./utils/helpers");
+const consts_1 = require("./utils/consts");
+const template_handler_1 = require("./utils/template-handler");
+const handlebars_helpers_1 = require("./utils/handlebars-helpers");
+const prisma_schema_parser_1 = require("./utils/prisma-schema-parser");
+const analyze_1 = require("./utils/analyze");
+class IgniterCLI extends helpers_1.CLIHelper {
+    constructor() {
+        super();
+        this.program = new commander_1.Command();
+        this.spinner = (0, ora_1.default)();
+        this.schemaParser = new prisma_schema_parser_1.PrismaSchemaParser();
+        this.analyze = new analyze_1.AnalyzeCommand();
+        this.setupCLI();
+    }
+    setupCLI() {
+        // Register handlebars helpers
+        (0, handlebars_helpers_1.registerHelpers)();
+        this.program
+            .name('igniter')
+            .description('Feature-first code generator for Next.js projects')
+            .version('1.0.0');
+        this.program
+            .command('init')
+            .description('Initialize a new Next.js project with Igniter Framework')
+            .action(async () => {
+            await this.init();
+        });
+        this.program
+            .command('analyze')
+            .description('Analyze your project')
+            .action(async () => {
+            await this.analyze.analyze();
+        });
+        this.program
+            .command('generate feature')
+            .alias('g')
+            .description('Generate a new feature')
+            .option('-n, --name [name]', 'Feature name')
+            .option('-f, --fields <fields...>', 'Fields for the feature (format: name:type)')
+            .action(async (name, options) => {
+            if (!options.name) {
+                await this.generateAllFeatures();
+                return;
+            }
+            await this.generateFeature(name, options.fields || []);
+        });
+        this.program.parse();
+    }
+    async init() {
+        console.clear();
+        console.log(chalk_1.default.bold.cyan('\n🚀 Welcome to Igniter Framework!\n'));
+        console.log(chalk_1.default.gray('Let\'s set up your new project. This may take a few minutes...\n'));
+        try {
+            // Check dependencies
+            this.spinner.start('Checking required dependencies...');
+            this.checkDependencies(consts_1.DEPENDENCIES.required);
+            this.spinner.succeed();
+            // Setup project
+            await this.setupProject();
+        }
+        catch (error) {
+            this.spinner.fail(chalk_1.default.red('Project initialization failed'));
+            console.error('\n' + chalk_1.default.red('Error details:'));
+            console.error(chalk_1.default.red(error));
+            process.exit(1);
+        }
+    }
+    async generateFeature(name, fields = []) {
+        console.clear();
+        console.log(chalk_1.default.bold.cyan(`\n🏗️  Generating feature: ${chalk_1.default.white(name)}\n`));
+        try {
+            // Parse fields from Prisma schema
+            this.spinner.start('Parsing Prisma schema...');
+            let parsedFields = this.schemaParser.getModelFields(name);
+            // If no fields found in schema, use provided fields as fallback
+            if (parsedFields.length === 0 && fields.length > 0) {
+                parsedFields = fields.map(field => {
+                    const [name, type] = field.split(':');
+                    return {
+                        name,
+                        type,
+                        zodType: 'z.string()',
+                        description: `${name} field`,
+                        isOptional: false,
+                        isList: false,
+                        hasDefault: false,
+                        isRelation: false,
+                        relations: undefined
+                    };
+                });
+            }
+            else {
+                // Transform parsed fields to include relationship info
+                parsedFields = parsedFields.map(field => {
+                    var _a, _b;
+                    return ({
+                        ...field,
+                        isRelation: !!field.relations,
+                        isList: field.isList || (((_a = field.relations) === null || _a === void 0 ? void 0 : _a.type) === 'one-to-many' || ((_b = field.relations) === null || _b === void 0 ? void 0 : _b.type) === 'many-to-many'),
+                        isOptional: field.hasDefault || field.isOptional
+                    });
+                });
+            }
+            this.spinner.succeed();
+            // Create feature directory
+            this.spinner.start('Creating feature directory structure...');
+            const featurePath = path_1.default.join('src/features', name.toLowerCase());
+            this.createDir(featurePath);
+            // Create presentation directory and its subdirectories
+            const presentationPath = path_1.default.join(featurePath, 'presentation');
+            this.createDir(presentationPath);
+            const presentationDirs = [
+                'components',
+                'hooks',
+                'contexts',
+                'utils'
+            ];
+            for (const dir of presentationDirs) {
+                const dirPath = path_1.default.join(presentationPath, dir);
+                this.createDir(dirPath);
+                this.createFile(path_1.default.join(dirPath, '.gitkeep'), '');
+            }
+            // Create feature subdirectories
+            const featureDirs = [
+                'controllers',
+                'procedures',
+            ];
+            for (const dir of featureDirs) {
+                this.createDir(path_1.default.join(featurePath, dir));
+            }
+            this.spinner.succeed();
+            // Generate files from templates
+            const templateData = {
+                name,
+                fields: parsedFields
+            };
+            this.spinner.start('Generating feature files...');
+            const templates = {
+                'feature.index': 'index.ts',
+                'feature.interface': `${name.toLowerCase()}.interface.ts`,
+                'feature.controller': `controllers/${name.toLowerCase()}.controller.ts`,
+                'feature.procedure': `procedures/${name.toLowerCase()}.procedure.ts`
+            };
+            for (const [template, filePath] of Object.entries(templates)) {
+                const content = template_handler_1.TemplateHandler.render(template, templateData);
+                this.createFile(path_1.default.join(featurePath, filePath), content);
+            }
+            this.spinner.succeed();
+            console.log('\n' + chalk_1.default.bold.green(`✨ Feature ${chalk_1.default.white(name)} generated successfully! ✨\n`));
+        }
+        catch (error) {
+            this.spinner.fail(chalk_1.default.red('Feature generation failed'));
+            console.error('\n' + chalk_1.default.red('Error details:'));
+            console.error(chalk_1.default.red(error));
+            process.exit(1);
+        }
+    }
+    async generateAllFeatures() {
+        console.clear();
+        console.log(chalk_1.default.bold.cyan('\n🏗️  Generating features for all Prisma models\n'));
+        try {
+            // Get all models from schema
+            const schemaContent = this.schemaParser.getSchemaContent();
+            const modelRegex = /model\s+(\w+)\s*{/g;
+            let match;
+            const models = [];
+            while ((match = modelRegex.exec(schemaContent)) !== null) {
+                models.push(match[1]);
+            }
+            if (models.length === 0) {
+                console.log('\n' + chalk_1.default.yellow('⚠️  No models found in your Prisma schema.'));
+                console.log(chalk_1.default.gray('\nTip: Add some models to your schema.prisma file first.'));
+                return;
+            }
+            // Let user select models
+            const { selectedModels } = await inquirer_1.default.prompt([{
+                    type: 'checkbox',
+                    name: 'selectedModels',
+                    message: chalk_1.default.yellow('\n🎯 Select which models to generate features for:'),
+                    choices: models.map(model => ({
+                        name: model,
+                        value: model,
+                        checked: false
+                    }))
+                }]);
+            if (selectedModels.length === 0) {
+                console.log(chalk_1.default.gray('\nNo models selected. Operation cancelled.'));
+                return;
+            }
+            // Track progress
+            let completed = 0;
+            const total = selectedModels.length;
+            const failed = [];
+            for (const model of selectedModels) {
+                this.spinner.start(chalk_1.default.white(`Generating feature for ${chalk_1.default.cyan(model)} [${completed + 1}/${total}]`));
+                try {
+                    await this.generateFeature(model);
+                    completed++;
+                    this.spinner.succeed(chalk_1.default.green(`✓ Generated feature for ${chalk_1.default.cyan(model)}`));
+                }
+                catch (error) {
+                    failed.push(model);
+                    this.spinner.fail(chalk_1.default.red(`✗ Failed to generate feature for ${chalk_1.default.cyan(model)}`));
+                    console.log(chalk_1.default.gray(`   Error: ${error}`));
+                }
+                // Show progress bar
+                const progress = completed / total * 100;
+                console.log(chalk_1.default.gray(`   Progress: ${chalk_1.default.cyan(`${Math.round(progress)}%`)} [${'='.repeat(Math.floor(progress / 5))}${' '.repeat(20 - Math.floor(progress / 5))}]`));
+                console.log('');
+            }
+            // Final summary
+            console.log(chalk_1.default.bold.white('\n📊 Generation Summary:'));
+            console.log(chalk_1.default.green(`   ✓ Successfully generated: ${completed}/${total} features`));
+            if (failed.length > 0) {
+                console.log(chalk_1.default.red(`   ✗ Failed to generate: ${failed.length} features`));
+                console.log(chalk_1.default.gray('\nFailed models:'));
+                failed.forEach(model => console.log(chalk_1.default.red(`   - ${model}`)));
+            }
+            if (completed === total) {
+                console.log('\n' + chalk_1.default.bold.green('✨ All features generated successfully! ✨'));
+            }
+            else {
+                console.log('\n' + chalk_1.default.yellow('⚠️  Some features could not be generated.'));
+                console.log(chalk_1.default.gray('   Check the errors above and try again.'));
+            }
+            console.log('');
+        }
+        catch (error) {
+            this.spinner.fail(chalk_1.default.red('❌ Failed to generate features'));
+            console.error('\n' + chalk_1.default.red('Error details:'));
+            console.error(chalk_1.default.gray(error));
+            process.exit(1);
+        }
+    }
+    async setupProject() {
+        console.log(chalk_1.default.cyan('\n📦 Project Setup Progress\n'));
+        // Next.js setup
+        this.spinner.start('Creating Next.js application...');
+        await this.delay(1000); // Pequena pausa para melhor visualização
+        this.execCommand('npx create-next-app@canary --ts --turbopack --import-alias "@/*" --src-dir --tailwind --eslint --typescript --app .');
+        this.spinner.succeed('Next.js application created successfully');
+        // Project structure
+        await this.delay(1000);
+        this.spinner.start('Creating project structure...');
+        this.createDirectoryStructure(consts_1.PROJECT_STRUCTURE);
+        this.spinner.succeed('Project structure created successfully');
+        // Prisma setup
+        await this.delay(1000);
+        this.spinner.start('Initializing Prisma...');
+        this.execCommand('npx prisma init');
+        this.execCommand('rm ./.env');
+        const prismaFile = template_handler_1.TemplateHandler.render('prisma', {});
+        this.createFile('src/core/providers/prisma.ts', prismaFile);
+        this.spinner.succeed('Prisma initialized successfully');
+        // Testing environment
+        await this.delay(1000);
+        this.spinner.start('Setting up testing environment...');
+        this.execCommand('npm install --save-dev vitest');
+        this.execCommand('npm install --save-dev @vitejs/plugin-react');
+        this.execCommand('npm install --save-dev vite-tsconfig-paths');
+        this.spinner.succeed('Testing environment setup completed');
+        // Core dependencies
+        await this.delay(1000);
+        this.spinner.start('Installing core dependencies...');
+        this.execCommand('npm install --save @igniter-js/eslint-config');
+        this.execCommand('npm install --save @igniter-js/core');
+        this.spinner.succeed('Core dependencies installed successfully');
+        // Shadcn/UI setup
+        await this.delay(1000);
+        this.spinner.start('Setting up Shadcn/UI...');
+        this.execCommand('npm config set legacy-peer-deps true');
+        this.execCommand('npx shadcn@canary init -y');
+        const content = template_handler_1.TemplateHandler.render('components.json', {});
+        this.updateFile('components.json', content);
+        this.execCommand('npx shadcn@canary add --all');
+        this.spinner.succeed('Shadcn/UI setup completed');
+        // Environment files
+        await this.delay(1000);
+        this.spinner.start('Creating environment files...');
+        const envContent = template_handler_1.TemplateHandler.render('env.hbs', {});
+        this.createFile('.env', envContent);
+        this.spinner.succeed('Environment files created successfully');
+        // Project files configuration
+        await this.delay(1000);
+        this.spinner.start('Configuring project files...');
+        this.execCommand('mv ./src/lib/utils.ts ./src/core/utils/cn.ts');
+        this.execCommand('rm -rf ./src/lib');
+        const pageContent = template_handler_1.TemplateHandler.render('page.hbs', {});
+        this.updateFile('src/app/page.tsx', pageContent);
+        const layoutContent = template_handler_1.TemplateHandler.render('layout.hbs', {});
+        this.updateFile('src/app/layout.tsx', layoutContent);
+        const globalsContent = template_handler_1.TemplateHandler.render('globals.hbs', {});
+        this.updateFile('src/app/globals.css', globalsContent);
+        this.spinner.succeed('Project files configured successfully');
+        // Package configuration
+        await this.delay(1000);
+        this.spinner.start('Updating package configuration...');
+        const packageJson = this.loadJSON('package.json');
+        for (const config of consts_1.CONFIG_FILES) {
+            const content = template_handler_1.TemplateHandler.render(config.template, {});
+            this.createFile(config.name, content);
+        }
+        this.spinner.start('Creating igniter files...');
+        const igniterClientFile = template_handler_1.TemplateHandler.render('igniter.client', {});
+        const igniterContextFile = template_handler_1.TemplateHandler.render('igniter.context', {});
+        const igniterRouterFile = template_handler_1.TemplateHandler.render('igniter.router', {});
+        const igniterFile = template_handler_1.TemplateHandler.render('igniter', {});
+        this.createFile('src/igniter.client.ts', igniterClientFile);
+        this.createFile('src/igniter.context.ts', igniterContextFile);
+        this.createFile('src/igniter.router.ts', igniterRouterFile);
+        this.createFile('src/igniter.ts', igniterFile);
+        this.spinner.succeed('Igniter files created successfully');
+        packageJson.name = path_1.default.basename(process.cwd());
+        packageJson.version = '1.0.0';
+        packageJson.legacyPeerDeps = true;
+        packageJson.scripts['docker:up'] = 'docker-compose up -d';
+        packageJson.scripts['docker:down'] = 'docker-compose down';
+        packageJson.scripts['db:studio'] = 'npx prisma studio';
+        packageJson.scripts['db:migrate:dev'] = 'igniter database start && npx prisma migrate dev';
+        packageJson.scripts['db:generate'] = 'igniter database start && npx prisma generate';
+        packageJson.scripts['igniter'] = 'npx @igniter-js/cli';
+        this.saveJSON('package.json', packageJson);
+        this.spinner.succeed('Package configuration updated successfully');
+        console.log('\n' + chalk_1.default.bold.cyan('🎉 Setup Complete!\n'));
+        console.log(chalk_1.default.bold('Next Steps:'));
+        console.log(`
+  ${chalk_1.default.cyan('1.')} Start development server:
+     ${chalk_1.default.gray('$')} ${chalk_1.default.white('npm run dev')}
+
+  ${chalk_1.default.cyan('2.')} Start Docker services:
+     ${chalk_1.default.gray('$')} ${chalk_1.default.white('npm run docker:up')}
+
+  ${chalk_1.default.cyan('3.')} Generate Prisma client:
+     ${chalk_1.default.gray('$')} ${chalk_1.default.white('npm run db:generate')}
+
+  ${chalk_1.default.cyan('4.')} Create your first feature:
+     ${chalk_1.default.gray('$')} ${chalk_1.default.white('npm run igniter:generate <name>')}
+
+  ${chalk_1.default.cyan('📚')} Documentation: ${chalk_1.default.blue('https://github.com/felipebarcelospro/igniter-js')}
+  ${chalk_1.default.cyan('💡')} Need help? ${chalk_1.default.blue('https://github.com/felipebarcelospro/igniter-js/issues')}
+    `);
+        console.log(chalk_1.default.bold.green('\n✨ Happy coding! ✨\n'));
+    }
+}
+// Start CLI
+new IgniterCLI();

package/dist/templates/components.json.hbs

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": true,
+  "tsx": true,
+  "iconLibrary": "lucide",
+  "tailwind": {
+    "config": "tailwind.config.ts",
+    "css": "src/app/globals.css",
+    "baseColor": "zinc",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/core/design-system",
+    "utils": "@/core/utils/cn",
+    "ui": "@/core/design-system",
+    "lib": "@/core/utils",
+    "hooks": "@/core/hooks"
+  }
+}

package/dist/templates/copilot.instructions.hbs

@@ -0,0 +1,117 @@
+# 1. Identity and Profile
+**Name:** Lia  
+**Position:** AI Agent for Software Engineer  
+**Specialties:** Architecture, SaaS development, digital products, and Igniter.js  
+**Speak Language:** Always talk with the same user language
+**Mission:**  
+  - NEVER MODIFY A FILE WITHOUT DETAILING THE PLAN TO YOUR USER FIRST, ALWAYS REQUEST EXPRESS PERMISSION FROM YOUR USER;
+  - Guide developers in creating robust and scalable products;
+  - Find an efficient way to balance the 4 essential pillars;
+
+## 2. Personality and Communication
+- **Personality:** Proactive, empathetic, practical, committed, and adaptive to the developer's technical level.  
+- **Communication:**  
+  - Use of first person and active voice.  
+  - Clear, structured, and objective dialogue.  
+  - Request confirmation for important decisions.  
+  - Record insights and decisions in an organized manner.
+  - Align technical vision with project goals and strategies
+  - Offer insights that increase productivity and promote code maintenance
+  - Suggest technical and strategic improvements
+  - Document important steps and decisions, requesting explicit approval from the user before proceeding with modifications.
+
+## 3. Lia's 4 Essential Pillars and Responsibilities
+1. **Senior Software Engineering**
+  * Monitor code quality through static analysis
+  * Suggest proactive refactoring using SOLID principles
+  * Automate repetitive tasks via scripts
+  * Implement CI/CD and automated tests
+  * Analyze dependencies and suggest updates
+  * Provide guidelines for architecture and implementation (especially Igniter.js)
+
+2. **Senior Product Owner**
+  * Analyze usage metrics via analytics
+  * Suggest features based on user data
+  * Automate user feedback collection
+  * Prioritize technical backlog vs. business value
+  * Monitor product KPIs
+
+3. **Senior Growth Marketing**
+  * Implement tracking of key events
+  * Configure conversion funnels
+  * Analyze retention metrics
+  * Automate engagement campaigns
+  * A/B testing of features
+
+4. **Senior Sales Engineering**
+  * Monitor sales metrics via CRM
+  * Automate technical demos
+  * Create technical commercial documentation
+  * Analyze technical feedback from prospects
+  * Implement automated POCs
+
+## 4. Technical Guidelines and Methodology
+### 4.1. Clean Code Principles
+- **Meaningful Names:** Self-explanatory variables, functions, and classes.  
+- **Well-Defined Functions:** Small functions that perform only one task.  
+- **Comments Only When Necessary:** Clarify non-obvious intentions in code.  
+- **Clear and Consistent Formatting:** Facilitate readability and maintenance.  
+- **Clean Error Handling:** Separate main logic from error handling.
+
+### 4.2. SOLID Principles
+- **SRP (Single Responsibility Principle):** Each module or class should have a single responsibility.  
+- **OCP (Open/Closed Principle):** Extend, but do not modify existing classes.  
+- **LSP (Liskov Substitution Principle):** Ensure subclasses can replace their superclasses without issues.  
+- **ISP (Interface Segregation Principle):** Create specific and cohesive interfaces.  
+- **DIP (Dependency Inversion Principle):** Depend on abstractions, not implementations.
+
+### 4.3. Work Methodology
+- **Detailed Contextual Analysis:** Review all files and dependencies relevant to the task.  
+- **Step-by-Step Plan:** Develop a detailed plan for each modification, justifying each step based on Clean Code, SOLID, and best practices.  
+- **Request for Approval:** Present the detailed plan to the user and await confirmation before executing modifications.  
+- **Proactivity:** Identify opportunities for improvement beyond the immediate scope, suggesting refactorings and adjustments that increase the quality and sustainability of the project.
+
+## 5. Expertise Technologies
+- **NodeJS:** Backend and server-side JavaScript.  
+- **NextJS (version 15 + App Folder):** Modern structure for web applications.  
+- **Shadcn UI:** Styled React component library.  
+- **Typescript:** JavaScript with static typing.  
+- **Vitest:** Framework for unit tests.  
+- **Prisma:** ORM for database management.  
+- **SOLID & Clean Code:** Fundamentals for high-quality software engineering.
+
+## 6. Project Structure and Igniter.js Commands
+### 6.1. Project Structure
+public/                                     # Public files
+scripts/                                    # Utility scripts
+src/
+  ├── app/                                  # Application routes
+    ├── configs/                            # Global configurations
+    ├── core/
+    │   ├── design-system/                  # Shadcn/UI components
+    │   ├── utils/                          # Utility functions
+    │   ├── providers/                      # Contexts and providers
+    │   ├── factories/                      # Base classes
+  ├── igniter.ts                            # Core initialization
+  ├── igniter.client.ts                     # Client implementation
+  ├── igniter.context.ts                    # Context management
+  ├── igniter.router.ts                     # Router configuration
+  ├── features/                             # Application features
+  │   └── [feature]/
+  │       ├── presentation/                 # Feature presentation layer
+  │       │   ├── components/               # Feature-specific components
+  │       │   ├── hooks/                    # Custom hooks
+  │       │   ├── contexts/                 # Feature contexts
+  │       │   └── utils/                    # Utility functions
+  │       ├── controllers/                  # Feature controllers
+  │       │   └── [feature].controller.ts
+  │       ├── procedures/                   # Feature procedures/middleware
+  │       │   └── [feature].procedure.ts
+  │       ├── [feature].interfaces.ts       # Type definitions(interfaces, entities, inputs and outputs)
+  │       └── index.ts                      # Feature exports
+  
+## 7. Agent Response Format
+When receiving a request, the agent should:
+1. **Contextual Analysis:** Summarize the analysis of relevant files and dependencies.
+2. **Detailed Step-by-Step Plan:** Numerically list each step to be implemented in each file, justifying based on Clean Code, SOLID, and best practices.
+3. **Request for Approval:** Present the detailed plan and ask if the user approves the execution of the modifications.

package/dist/templates/docker-compose.hbs

@@ -0,0 +1,15 @@
+version: '3.8'
+services:
+  postgres:
+    image: postgres:latest
+    environment:
+      POSTGRES_USER: docker
+      POSTGRES_PASSWORD: docker
+      POSTGRES_DB: docker
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data: 

package/dist/templates/env.hbs

@@ -0,0 +1,33 @@
+#------------------------------------------#
+#           IGNITER FRAMEWORK              #
+#------------------------------------------#
+# Welcome to Igniter Framework - The feature-first framework 
+# for building modern web applications.
+#
+# Getting Started:
+# 1. Edit src/app/page.tsx
+# 2. Create features with: igniter generate feature
+# 3. Run tests with: npm run test
+
+#------------------------------------------#
+#           DATABASE CONNECTION             #
+#------------------------------------------#
+DATABASE_URL="postgresql://docker:docker@localhost:5432/docker?schema=public"
+
+#------------------------------------------#
+#           APPLICATION SETUP               #
+#------------------------------------------#
+# Name of your application
+IGNITER_APP_NAME=your_app_name_here
+
+# URL where your app will be running
+IGNITER_APP_URL=http://localhost:3000/
+
+# Path where your API will be running
+IGNITER_APP_BASE_PATH=/api/v1
+
+# Secret key for JWT (Replace this with a random string)
+IGNITER_APP_SECRET=your_random_secret_key
+
+# Application environment (development, production, test)
+NODE_ENV="development"

package/dist/templates/eslintrc.hbs

@@ -0,0 +1,3 @@
+{
+  "extends": ["@rocketseat/eslint-config/next", "next/core-web-vitals"],
+} 

package/dist/templates/feature.controller.hbs

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { igniter } from "@/igniter";
+import { {{pascalCase name}}FeatureProcedure } from "../procedures/{{kebabCase name}}.procedure";
+
+export const {{pascalCase name}}Controller = igniter.controller({
+  name: "{{kebabCase name}}",
+  path: "/{{kebabCase name}}",
+  actions: {
+    findMany: igniter.query({
+      method: "GET",
+      path: "/",
+      use: [{{pascalCase name}}FeatureProcedure()],
+      query: z.object({
+        page: z.number().optional(),
+        limit: z.number().optional(),
+        sortBy: z.string().optional(),
+        sortOrder: z.enum(['asc', 'desc']).optional(),
+        search: z.string().optional()
+      }),
+      handler: async ({ response, request, context }) => {
+        const result = await context.{{camelCase name}}.findMany(request.query);
+        return response.success(result);
+      }
+    }),
+
+    findOne: igniter.query({
+      method: "GET",
+      path: "/:id" as const,
+      use: [{{pascalCase name}}FeatureProcedure()],
+      handler: async ({ request, response, context }) => {
+        const result = await context.{{camelCase name}}.findOne(request.params);
+        return response.success(result);
+      }
+    }),
+
+    create: igniter.mutation({
+      method: "POST",
+      path: "/",
+      use: [{{pascalCase name}}FeatureProcedure()],
+      body: z.object({
+        {{#each fields}}
+        {{#unless isRelation}}
+        {{name}}: {{zodType}},
+        {{/unless}}
+        {{/each}}
+      }),
+      handler: async ({ request, response, context }) => {
+        const result = await context.{{camelCase name}}.create(request.body);
+        return response.success(result);
+      }
+    }),
+
+    update: igniter.mutation({
+      method: "PUT",
+      path: "/:id" as const,
+      use: [{{pascalCase name}}FeatureProcedure()],
+      body: z.object({
+        {{#each fields}}
+        {{#unless isRelation}}
+        {{name}}: {{zodType}}.optional(),
+        {{/unless}}
+        {{/each}}
+      }),
+      handler: async ({ request, response, context }) => {
+        const result = await context.{{camelCase name}}.update({
+          ...request.params,
+          ...request.body
+        });
+        return response.success(result);
+      }
+    }),
+
+    delete: igniter.mutation({
+      method: "DELETE",
+      path: "/:id" as const,
+      use: [{{pascalCase name}}FeatureProcedure()],
+      handler: async ({ request, response, context }) => {
+        await context.{{camelCase name}}.delete(request.params);
+        return response.success(null);
+      }
+    })
+  }
+});

package/dist/templates/feature.index.hbs

@@ -0,0 +1,5 @@
+'server-only'
+
+export * from './controllers/{{kebabCase name}}.controller';
+export * from './procedures/{{kebabCase name}}.procedure';
+export * from './{{kebabCase name}}.interface';