@rpal/cli 1.0.0 → 1.1.0

package/dist/bin/create.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { CreateNewApp } from '../commands/create.js';
+const app = new CreateNewApp();
+app.run().catch((error) => {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+});

package/dist/commands/create.js

@@ -0,0 +1,246 @@
+import gradient from 'gradient-string';
+import { downloadTemplate } from 'giget';
+import { execa } from 'execa';
+import { existsSync, readFileSync, writeFileSync, cpSync, rmSync, readdirSync } from 'fs';
+import { join, isAbsolute } from 'path';
+import { templates, getTemplateByAlias } from '../templates.js';
+const VERSION = '1.0.0';
+export class CreateNewApp {
+    constructor() {
+        this.projectName = '';
+        this.projectDir = '';
+        this.selectedTemplate = '';
+        this.packageManager = 'npm';
+        this.gitInit = false;
+        this.verbose = false;
+    }
+    async run() {
+        const args = process.argv.slice(2);
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg === '--template' || arg === '-t') {
+                this.selectedTemplate = args[++i];
+            }
+            else if (arg === '--git' || arg === '-g') {
+                this.gitInit = true;
+            }
+            else if (arg === '--verbose' || arg === '-v') {
+                this.verbose = true;
+            }
+            else if (arg === '--help' || arg === '-h') {
+                this.showHelp();
+                process.exit(0);
+            }
+            else if (!arg.startsWith('-')) {
+                this.projectName = arg;
+            }
+        }
+        const whichPmRuns = await import('which-pm-runs');
+        const pm = whichPmRuns.default();
+        this.packageManager = pm?.name || 'npm';
+        this.printBanner();
+        if (!this.projectName) {
+            this.projectName = await this.prompt('project name', 'my-pal-app');
+        }
+        this.projectDir = isAbsolute(this.projectName)
+            ? this.projectName
+            : join(process.cwd(), this.projectName);
+        if (!this.selectedTemplate) {
+            this.selectedTemplate = await this.promptChoice('Select a starter kit', templates.map((t) => ({ name: t.name, value: t.alias })));
+        }
+        const template = getTemplateByAlias(this.selectedTemplate);
+        if (!template) {
+            throw new Error(`Unknown template: ${this.selectedTemplate}`);
+        }
+        await this.downloadTemplate(template.source);
+        await this.prepareProject();
+        await this.installDependencies();
+        if (this.gitInit) {
+            await this.initGit();
+        }
+        this.printSuccess();
+    }
+    showHelp() {
+        console.log(`
+Usage: create-pal [project-name] [options]
+
+Options:
+  -t, --template <name>  Starter kit template (api, admin, client)
+  -g, --git              Initialize git repository
+  -v, --verbose          Enable verbose mode
+  -h, --help             Show this help message
+
+Examples:
+  create-pal my-project
+  create-pal my-project --template api
+  create-pal my-project --git
+    `);
+    }
+    printBanner() {
+        const title = `
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ███████╗██╗   ██╗███████╗████████╗███████╗███╗   ███╗ ║
+║   ██╔════╝╚██╗ ██╔╝██╔════╝╚══██╔══╝██╔════╝████╗ ████║ ║
+║   ███████╗ ╚████╔╝ ███████╗   ██║   █████╗  ██╔████╔██║ ║
+║   ╚════██║  ╚██╔╝  ╚════██║   ██║   ██╔══╝  ██║╚██╔╝██║ ║
+║   ███████║   ██║   ███████║   ██║   ███████╗██║ ╚═╝ ██║ ║
+║   ╚══════╝   ╚═╝   ╚══════╝   ╚═╝   ╚══════╝╚═╝     ╚═╝ ║
+║                                                           ║
+║   ${VERSION} - The batteries-included full-stack framework       ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+    `.trim();
+        console.log(gradient.pastel.multiline(title));
+        console.log();
+    }
+    async prompt(question, defaultValue) {
+        const readline = await import('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(`${question} (${defaultValue}): `, (answer) => {
+                rl.close();
+                resolve(answer.trim() || defaultValue);
+            });
+        });
+    }
+    async promptChoice(question, choices) {
+        console.log(`\n${question}:`);
+        choices.forEach((choice, index) => {
+            console.log(`  ${index + 1}. ${choice.name}`);
+        });
+        console.log();
+        const answer = await this.prompt('Enter choice number', '1');
+        const index = parseInt(answer, 10) - 1;
+        if (index >= 0 && index < choices.length) {
+            return choices[index].value;
+        }
+        return choices[0].value;
+    }
+    async downloadTemplate(source) {
+        console.log(`\n📦 Downloading template from: ${source}`);
+        if (existsSync(this.projectDir)) {
+            const files = readdirSync(this.projectDir);
+            if (files.length > 0) {
+                rmSync(this.projectDir, { recursive: true, force: true });
+            }
+        }
+        await downloadTemplate(source, {
+            dir: this.projectDir,
+            registry: false,
+        });
+        console.log('✅ Template downloaded successfully');
+    }
+    async prepareProject() {
+        console.log('\n🔧 Preparing project...');
+        const pkgJsonPath = join(this.projectDir, 'package.json');
+        if (existsSync(pkgJsonPath)) {
+            const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+            pkgJson.name = this.projectName.replace(/[^a-z0-9-]/gi, '-').toLowerCase();
+            writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        }
+        const envExample = join(this.projectDir, '.env.example');
+        const envFile = join(this.projectDir, '.env');
+        if (existsSync(envExample) && !existsSync(envFile)) {
+            cpSync(envExample, envFile);
+        }
+        const gitignore = join(this.projectDir, '.gitignore');
+        const gitignoreContent = `
+node_modules/
+dist/
+build/
+.turbo/
+.env
+*.log
+coverage/
+.vscode/
+.idea/
+`;
+        if (existsSync(gitignore)) {
+            const existing = readFileSync(gitignore, 'utf-8');
+            writeFileSync(gitignore, existing + gitignoreContent);
+        }
+        else {
+            writeFileSync(gitignore, gitignoreContent.trim() + '\n');
+        }
+        const lockFiles = [
+            join(this.projectDir, 'package-lock.json'),
+            join(this.projectDir, 'pnpm-lock.yaml'),
+            join(this.projectDir, 'yarn.lock'),
+        ];
+        lockFiles.forEach((file) => {
+            if (existsSync(file)) {
+                rmSync(file);
+            }
+        });
+        console.log('✅ Project prepared successfully');
+    }
+    async installDependencies() {
+        if (!existsSync(join(this.projectDir, 'package.json'))) {
+            console.log('⚠️  No package.json found, skipping install');
+            return;
+        }
+        console.log(`\n📦 Installing dependencies using ${this.packageManager}...`);
+        const spinner = this.spinner('Installing');
+        try {
+            await execa(this.packageManager, ['install'], {
+                cwd: this.projectDir,
+                stdio: this.verbose ? 'inherit' : 'pipe',
+            });
+            spinner.stop();
+            console.log('✅ Dependencies installed successfully');
+        }
+        catch (error) {
+            spinner.stop();
+            throw new Error(`Failed to install dependencies: ${error.message}`);
+        }
+    }
+    async initGit() {
+        console.log('\n📂 Initializing git repository...');
+        try {
+            await execa('git', ['init'], {
+                cwd: this.projectDir,
+                stdio: this.verbose ? 'inherit' : 'pipe',
+            });
+            console.log('✅ Git repository initialized');
+        }
+        catch {
+            console.log('⚠️  Failed to initialize git (git may not be installed)');
+        }
+    }
+    printSuccess() {
+        const message = `
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ✅ Your Pal project has been created successfully!      ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+
+Next steps:
+  cd ${this.projectName}
+  npm run dev
+
+Documentation: https://github.com/paljs/paljs
+    `.trim();
+        console.log(gradient.pastel.multiline(message));
+    }
+    spinner(message) {
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let i = 0;
+        const interval = setInterval(() => {
+            process.stdout.write(`\r${frames[i++ % frames.length]} ${message}`);
+        }, 80);
+        return {
+            stop: () => {
+                clearInterval(interval);
+                process.stdout.write('\r' + ' '.repeat(50) + '\r');
+            },
+            update: (msg) => {
+                process.stdout.write(`\r${msg}`);
+            },
+        };
+    }
+}

package/dist/index.js

@@ -2,7 +2,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 const VERSION = '1.0.0';
-console.log(`
+const banner = `
 ╔═══════════════════════════════════════════╗
 ║                                           ║
 ║   ██████╗ ███████╗██╗   ██╗███████╗     ║
@@ -15,7 +15,7 @@ console.log(`
 ║   CLI Tool v${VERSION}                         ║
 ║                                           ║
 ╚═══════════════════════════════════════════╝
-`);
+`;
 const args = process.argv.slice(2);
 const command = args[0];
 if (!command || command === 'help') {
@@ -26,65 +26,99 @@ switch (command) {
     case 'make:model':
         makeModel(args.slice(1));
         break;
-    case 'make:repository':
-        makeRepository(args.slice(1));
-        break;
     case 'make:service':
         makeService(args.slice(1));
         break;
-    case 'make:migration':
-        makeMigration(args.slice(1));
-        break;
     case 'make:controller':
         makeController(args.slice(1));
         break;
+    case 'make:middleware':
+        makeMiddleware(args.slice(1));
+        break;
+    case 'make:migration':
+        makeMigration(args.slice(1));
+        break;
     case 'make:factory':
         makeFactory(args.slice(1));
         break;
-    case 'init':
-        initProject(args.slice(1));
+    case 'make:exception':
+        makeException(args.slice(1));
+        break;
+    case 'make:validator':
+        makeValidator(args.slice(1));
+        break;
+    case 'db:migrate':
+        dbMigrate();
         break;
-    case 'db:push':
-        dbPush();
+    case 'db:rollback':
+        dbRollback();
         break;
     case 'db:seed':
         dbSeed();
         break;
+    case 'db:fresh':
+        dbFresh();
+        break;
+    case 'route:list':
+        routeList();
+        break;
+    case 'key:generate':
+        keyGenerate();
+        break;
+    case 'list':
+        listRoutes();
+        break;
     default:
         console.log(`❌ Unknown command: ${command}`);
         console.log(`   Run 'pal help' for available commands`);
         process.exit(1);
 }
 function showHelp() {
+    console.log(banner);
     console.log(`
 Usage: pal <command> [options]
 
+Project Commands:
+  npm create pal@latest     Create a new Pal project
+                           Run: npm create pal@latest my-project
+
 Make Commands:
-  make:model <name>           Create a new model (entity + repository)
-  make:repository <name>       Create a new repository
-  make:service <name>          Create a new service
-  make:controller <name>      Create a new controller
-  make:migration <name>       Create a new migration
-  make:factory <name>          Create a model factory
+  make:model <name>          Create a new model
+  make:service <name>       Create a new service
+  make:controller <name>    Create a new controller
+  make:middleware <name>   Create a new middleware
+  make:migration <name>     Create a new migration
+  make:factory <name>      Create a model factory
+  make:exception <name>     Create an exception class
+  make:validator <name>    Create a validator
 
 Database Commands:
-  db:push                      Push schema to database
-  db:seed                      Run database seeds
+  db:migrate                Run database migrations
+  db:rollback              Rollback the last migration
+  db:seed                  Run database seeders
+  db:fresh                 Drop all tables and re-run migrations
 
-Project Commands:
-  init [name]                  Initialize a new Pal project
+Utility Commands:
+  route:list               List all registered routes
+  key:generate            Generate a new app key
+  list                     Alias for route:list
 
 Options:
-  --resource                   Generate CRUD methods (for model/repository/controller)
-  --api                        Generate API-ready controller
-  --force                      Overwrite existing files
+  --resource               Generate CRUD methods
+  --api                    Generate API-ready controller
+  --http                   Create HTTP controller
+  --force                  Overwrite existing files
 
 Examples:
+  npm create pal@latest my-project
   pal make:model User
-  pal make:repository Post --resource
+  pal make:service UserService
   pal make:controller UserController --api
-  pal init my-api
-`);
+  pal make:middleware Auth
+  pal make:migration create_users_table
+  pal db:migrate
+  pal route:list
+  `);
 }
 function makeModel(args) {
     const name = args[0];
@@ -95,61 +129,60 @@ function makeModel(args) {
     }
     const options = parseOptions(args);
     const fileName = toKebabCase(name);
-    const dir = path.join(process.cwd(), 'src', 'models', fileName);
-    ensureDir(dir);
-    const entityCode = generateEntity(name, options);
-    const repositoryCode = generateRepository(name, options);
-    writeFile(path.join(dir, 'index.ts'), entityCode);
-    writeFile(path.join(dir, 'repository.ts'), repositoryCode);
-    console.log(`✅ Created model: src/models/${fileName}/`);
-    console.log(`   - index.ts`);
-    console.log(`   - repository.ts`);
-}
-function makeRepository(args) {
-    const name = args[0];
-    if (!name) {
-        console.log('❌ Please provide a repository name');
-        process.exit(1);
-    }
-    const options = parseOptions(args);
-    const fileName = toKebabCase(name);
-    const dir = path.join(process.cwd(), 'src', 'repositories');
+    const dir = path.join(process.cwd(), 'app', 'models', fileName);
     ensureDir(dir);
-    const code = generateRepository(name, options);
-    writeFile(path.join(dir, `${fileName}.repository.ts`), code);
-    console.log(`✅ Created repository: src/repositories/${fileName}.repository.ts`);
+    const modelCode = generateModel(name, options);
+    writeFile(path.join(dir, 'index.ts'), modelCode);
+    console.log(`✅ Created model: app/models/${fileName}/index.ts`);
 }
 function makeService(args) {
     const name = args[0];
     if (!name) {
         console.log('❌ Please provide a service name');
+        console.log('   Example: pal make:service UserService');
         process.exit(1);
     }
     const fileName = toKebabCase(name);
-    const dir = path.join(process.cwd(), 'src', 'services');
+    const dir = path.join(process.cwd(), 'app', 'services');
     ensureDir(dir);
     const code = generateService(name);
     writeFile(path.join(dir, `${fileName}.service.ts`), code);
-    console.log(`✅ Created service: src/services/${fileName}.service.ts`);
+    console.log(`✅ Created service: app/services/${fileName}.service.ts`);
 }
 function makeController(args) {
     const name = args[0];
     if (!name) {
         console.log('❌ Please provide a controller name');
+        console.log('   Example: pal make:controller UserController');
         process.exit(1);
     }
     const options = parseOptions(args);
     const fileName = toKebabCase(name);
-    const dir = path.join(process.cwd(), 'src', 'controllers');
+    const dir = path.join(process.cwd(), 'app', 'controllers', 'http');
     ensureDir(dir);
     const code = generateController(name, options);
     writeFile(path.join(dir, `${fileName}.controller.ts`), code);
-    console.log(`✅ Created controller: src/controllers/${fileName}.controller.ts`);
+    console.log(`✅ Created controller: app/controllers/http/${fileName}.controller.ts`);
+}
+function makeMiddleware(args) {
+    const name = args[0];
+    if (!name) {
+        console.log('❌ Please provide a middleware name');
+        console.log('   Example: pal make:middleware Auth');
+        process.exit(1);
+    }
+    const fileName = toKebabCase(name);
+    const dir = path.join(process.cwd(), 'app', 'middleware');
+    ensureDir(dir);
+    const code = generateMiddleware(name);
+    writeFile(path.join(dir, `${fileName}.ts`), code);
+    console.log(`✅ Created middleware: app/middleware/${fileName}.ts`);
 }
 function makeMigration(args) {
     const name = args[0];
     if (!name) {
         console.log('❌ Please provide a migration name');
+        console.log('   Example: pal make:migration create_users_table');
         process.exit(1);
     }
     const timestamp = Date.now();
@@ -164,6 +197,7 @@ function makeFactory(args) {
     const name = args[0];
     if (!name) {
         console.log('❌ Please provide a factory name');
+        console.log('   Example: pal make:factory UserFactory');
         process.exit(1);
     }
     const fileName = toKebabCase(name);
@@ -173,68 +207,65 @@ function makeFactory(args) {
     writeFile(path.join(dir, `${fileName}.factory.ts`), code);
     console.log(`✅ Created factory: database/factories/${fileName}.factory.ts`);
 }
-function initProject(args) {
-    const name = args[0] || 'my-pal-app';
-    console.log(`📦 Initializing Pal project: ${name}...`);
-    const dir = path.join(process.cwd(), name);
+function makeException(args) {
+    const name = args[0];
+    if (!name) {
+        console.log('❌ Please provide an exception name');
+        console.log('   Example: pal make:exception NotFoundException');
+        process.exit(1);
+    }
+    const fileName = toKebabCase(name);
+    const dir = path.join(process.cwd(), 'app', 'exceptions');
+    ensureDir(dir);
+    const code = generateException(name);
+    writeFile(path.join(dir, `${fileName}.ts`), code);
+    console.log(`✅ Created exception: app/exceptions/${fileName}.ts`);
+}
+function makeValidator(args) {
+    const name = args[0];
+    if (!name) {
+        console.log('❌ Please provide a validator name');
+        console.log('   Example: pal make:validator CreateUserValidator');
+        process.exit(1);
+    }
+    const fileName = toKebabCase(name);
+    const dir = path.join(process.cwd(), 'app', 'validators');
     ensureDir(dir);
-    ensureDir(path.join(dir, 'src', 'models'));
-    ensureDir(path.join(dir, 'src', 'services'));
-    ensureDir(path.join(dir, 'src', 'repositories'));
-    ensureDir(path.join(dir, 'src', 'controllers'));
-    ensureDir(path.join(dir, 'database', 'migrations'));
-    ensureDir(path.join(dir, 'database', 'factories'));
-    ensureDir(path.join(dir, 'tests'));
-    const pkgJson = {
-        name: name,
-        version: '0.0.1',
-        type: 'module',
-        scripts: {
-            dev: 'pal serve',
-            build: 'pal build',
-            test: 'pal test',
-            'db:push': 'pal db:push',
-            'db:seed': 'pal db:seed',
-        },
-        dependencies: {
-            '@paljs/core': 'workspace:*',
-            '@paljs/orm': 'workspace:*',
-            '@paljs/http': 'workspace:*',
-        },
-        devDependencies: {
-            'typescript': '^5.0.0',
-            '@types/node': '^20.0.0',
-            'tsx': '^4.0.0',
-        },
-    };
-    const tsconfig = {
-        compilerOptions: {
-            target: 'ES2022',
-            module: 'ESNext',
-            moduleResolution: 'bundler',
-            experimentalDecorators: true,
-            emitDecoratorMetadata: true,
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            outDir: 'dist',
-        },
-        include: ['src/**/*'],
-    };
-    writeFile(path.join(dir, 'package.json'), JSON.stringify(pkgJson, null, 2));
-    writeFile(path.join(dir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
-    writeFile(path.join(dir, 'src', 'index.ts'), '// Welcome to Pal!\n\n');
-    console.log(`✅ Project created: ${name}/`);
-    console.log(`   Run: cd ${name} && pnpm install && pnpm dev`);
-}
-function dbPush() {
-    console.log('🔄 Pushing schema to database...');
-    console.log('   (This would sync your models to the database)');
+    const code = generateValidator(name);
+    writeFile(path.join(dir, `${fileName}.ts`), code);
+    console.log(`✅ Created validator: app/validators/${fileName}.ts`);
+}
+function dbMigrate() {
+    console.log('🔄 Running database migrations...');
+    console.log('   (This would run all pending migrations)');
+}
+function dbRollback() {
+    console.log('⏪ Rolling back last migration...');
+    console.log('   (This would rollback the last migration)');
 }
 function dbSeed() {
     console.log('🌱 Running database seeds...');
     console.log('   (This would seed your database with initial data)');
 }
+function dbFresh() {
+    console.log('⚠️  Dropping all tables and re-running migrations...');
+    console.log('   (This would drop all tables and run migrations)');
+}
+function routeList() {
+    console.log('\n📋 Registered Routes:');
+    console.log('   (No routes registered yet)');
+    console.log('\n   Define routes in: start/routes.ts\n');
+}
+function keyGenerate() {
+    const { randomBytes } = require('crypto');
+    const key = randomBytes(32).toString('hex');
+    console.log(`\n🔑 Application Key: ${key}\n`);
+    console.log('Add this to your .env file:');
+    console.log(`APP_KEY=${key}\n`);
+}
+function listRoutes() {
+    routeList();
+}
 function parseOptions(args) {
     return args
         .filter(a => a.startsWith('--'))
@@ -265,180 +296,157 @@ function writeFile(filePath, content) {
     }
     fs.writeFileSync(filePath, content);
 }
-function generateEntity(name, options) {
+function generateModel(name, options) {
     const camelName = toCamelCase(name);
     const hasResource = options.resource;
-    return `import { BaseEntity } from '@paljs/orm';
+    return `import { BaseEntity } from '@rpal/orm';
 
 export interface ${name} extends BaseEntity {
-  // Add your fields here
-  name: string;
-  ${hasResource ? `
-  // Common fields for CRUD:
-  // email: string;
-  // status: 'active' | 'inactive';
-  // description?: string;
-  // createdAt: Date;
-  // updatedAt: Date;` : ''}
+  ${hasResource ? `name: string;
+  email: string;
+  status: 'active' | 'inactive';
+  description?: string;` : `// Define your ${name} model fields here
+  // Example:
+  // name: string;
+  // email?: string;`}
 }
 
 export interface Create${name}DTO {
-  name: string;
-  ${hasResource ? `// email: string;
-  // status?: 'active' | 'inactive';
-  // description?: string;` : ''}
+  ${hasResource ? `name: string;
+  email: string;
+  description?: string;` : `// Define create DTO fields here
+  // Example:
+  // name: string;`}
 }
 
 export interface Update${name}DTO {
-  name?: string;
-  ${hasResource ? `// email?: string;
-  // status?: 'active' | 'inactive';
-  // description?: string;` : ''}
+  ${hasResource ? `name?: string;
+  email?: string;
+  status?: 'active' | 'inactive';
+  description?: string;` : `// Define update DTO fields here
+  // Example:
+  // name?: string;`}
 }
-`;
-}
-function generateRepository(name, options) {
-    const camelName = toCamelCase(name);
-    const hasResource = options.resource;
-    let extraMethods = '';
-    if (hasResource) {
-        extraMethods = `
-  async findByEmail(email: string): Promise<${name} | null> {
-    return this.findOne({ email });
-  }
-
-  async findActive(): Promise<${name}[] | null> {
-    return this.findAll({ status: 'active' });
-  }
-
-  async exists(email: string, excludeId?: string): Promise<boolean> {
-    const existing = await this.findByEmail(email);
-    if (!existing) return false;
-    if (excludeId && existing.id === excludeId) return false;
-    return true;
-  }`;
-    }
-    return `import { BaseRepository } from '@paljs/orm';
-import { ${name}, Create${name}DTO, Update${name}DTO } from './index';
 
-export class ${name}Repository extends BaseRepository<${name}, Create${name}DTO, Update${name}DTO> {
-  protected toEntity(data: Create${name}DTO): ${name} {
-    const now = new Date();
-    return {
-      id: this.generateId(),
-      name: data.name,
-      ${hasResource ? `// email: data.email,
-      // status: data.status || 'active',` : ''}
-      createdAt: now,
-    };
-  }
-
-  protected toUpdateData(data: Update${name}DTO): Partial<${name}> {
-    return {
-      name: data.name,
-      ${hasResource ? `// email: data.email,
-      // status: data.status,
-      // updatedAt: new Date(),` : ''}
-    };
-  }${extraMethods}
-}
+export const ${name}Token = Symbol('${name}');
 `;
 }
 function generateService(name) {
     const camelName = toCamelCase(name);
-    const repoName = `${name}Repository`;
-    return `import { Injectable } from '@paljs/core';
-import { ${repoName} } from '../repositories/${toKebabCase(name)}.repository';
-import { Create${name}DTO, Update${name}DTO } from '../models/${toKebabCase(name)}';
+    const modelName = `${name}Model`;
+    const modelFileName = toKebabCase(name);
+    return `import { Injectable, Inject } from '@rpal/core';
+import { ${modelName}, ${modelName}Token } from '#models/${modelFileName}';
 
 @Injectable()
 export class ${name}Service {
-  constructor(private ${camelName}Repo: ${repoName}) {}
+  constructor(
+    @Inject(${modelName}Token) private ${camelName}Model: ${modelName}
+  ) {}
 
   async findAll() {
-    return this.${camelName}Repo.findAll();
+    return this.${camelName}Model.findAll();
   }
 
-  async findOne(id: string) {
-    return this.${camelName}Repo.findById(id);
+  async findById(id: string) {
+    return this.${camelName}Model.findById(id);
   }
 
-  async create(data: Create${name}DTO) {
-    return this.${camelName}Repo.create(data);
+  async create(data: Partial<${modelName}>) {
+    return this.${camelName}Model.create(data);
   }
 
-  async update(id: string, data: Update${name}DTO) {
-    return this.${camelName}Repo.update(id, data);
+  async update(id: string, data: Partial<${modelName}>) {
+    return this.${camelName}Model.update(id, data);
   }
 
   async delete(id: string) {
-    return this.${camelName}Repo.delete(id);
+    return this.${camelName}Model.delete(id);
   }
 }
 `;
 }
 function generateController(name, options) {
     const camelName = toCamelCase(name);
+    const serviceName = `${name}Service`;
+    const fileName = toKebabCase(name);
     const hasApi = options.api;
     const hasResource = options.resource;
-    const kebabName = toKebabCase(name);
     let crudMethods = '';
     if (hasApi) {
         crudMethods = `
-  async index() {
-    const ${camelName}s = await this.${camelName}Service.findAll();
-    return { data: ${camelName}s };
+  async index({ request, response }: HttpContext) {
+    const data = await this.${camelName}Service.findAll();
+    return response.json({ data });
   }
 
-  async show(id: string) {
-    const ${camelName} = await this.${camelName}Service.findOne(id);
+  async show({ params, response }: HttpContext) {
+    const ${camelName} = await this.${camelName}Service.findById(params.id);
     if (!${camelName}) {
-      throw new Error('${name} not found');
+      return response.notFound({ message: '${name} not found' });
     }
-    return { data: ${camelName} };
+    return response.json({ data: ${camelName} });
   }
 
-  async store(data: any) {
+  async store({ request, response }: HttpContext) {
+    const data = request.body();
     const ${camelName} = await this.${camelName}Service.create(data);
-    return { data: ${camelName}, status: 201 };
+    return response.created({ data: ${camelName} });
   }
 
-  async update(id: string, data: any) {
-    const ${camelName} = await this.${camelName}Service.update(id, data);
-    return { data: ${camelName} };
+  async update({ params, request, response }: HttpContext) {
+    const data = request.body();
+    const ${camelName} = await this.${camelName}Service.update(params.id, data);
+    if (!${camelName}) {
+      return response.notFound({ message: '${name} not found' });
+    }
+    return response.json({ data: ${camelName} });
   }
 
-  async destroy(id: string) {
-    await this.${camelName}Service.delete(id);
-    return { status: 204 };
+  async destroy({ params, response }: HttpContext) {
+    await this.${camelName}Service.delete(params.id);
+    return response.noContent();
   }`;
     }
-    if (hasResource || hasApi) {
-        return `import { Injectable } from '@paljs/core';
-import { ${name}Service } from '../services/${kebabName}.service';
+    return `import type { HttpContext } from '@rpal/http';
+import { Injectable } from '@rpal/core';
+import { ${serviceName} } from '#services/${fileName}.service';
 
 @Injectable()
 export class ${name}Controller {
-  constructor(private ${camelName}Service: ${name}Service) {} ${crudMethods}
+  constructor(private ${camelName}Service: ${serviceName}) {}${crudMethods}
 }
 `;
-    }
-    return `import { Injectable } from '@paljs/core';
+}
+function generateMiddleware(name) {
+    const fileName = toKebabCase(name);
+    return `import type { HttpContext } from '@rpal/http';
+import { Middleware } from '@rpal/http';
 
-@Injectable()
-export class ${name}Controller {
-  async index() {
-    return { data: [] };
+export class ${name}Middleware implements Middleware {
+  async handle({ request, response }: HttpContext, next: () => Promise<void>) {
+    // Add your middleware logic here
+    console.log('${name}Middleware: Processing request', request.url());
+    
+    // Example: Check for authorization header
+    // const authHeader = request.header('Authorization');
+    // if (!authHeader) {
+    //   return response.unauthorized({ message: 'Unauthorized' });
+    // }
+
+    await next();
   }
 }
 `;
 }
 function generateMigration(name) {
-    const tableName = toKebabCase(name) + 's';
-    return `import { Migration } from '@paljs/orm';
+    const tableName = toKebabCase(name);
+    return `import type { Migration } from '@rpal/orm';
 
-export class Create${name}Table implements Migration {
-  up() {
+export default class ${toPascalCase(name)}Migration implements Migration {
+  name = '${Date.now()}_${tableName}';
+
+  async up() {
     return \`
       CREATE TABLE ${tableName} (
         id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
@@ -449,20 +457,55 @@ export class Create${name}Table implements Migration {
     \`;
   }
 
-  down() {
-    return \`DROP TABLE ${tableName}\`;
+  async down() {
+    return \`DROP TABLE IF EXISTS ${tableName}\`;
   }
 }
 `;
 }
 function generateFactory(name) {
-    return `import { Factory } from '@paljs/test';
-import { ${name} } from '../models/${toKebabCase(name)}';
+    const modelFileName = toKebabCase(name);
+    return `import { Factory } from '@rpal/palu';
+import { ${name}Model } from '#models/${modelFileName}';
 
-export const ${name}Factory = Factory.define<${name}>(({ sequence }) => ({
+export const ${name}Factory = Factory.define<${name}Model>(({ sequence }) => ({
   id: \`seed-\${sequence}\`,
   name: \`Test ${name} \${sequence}\`,
   createdAt: new Date(),
 }));
 `;
 }
+function generateException(name) {
+    return `import { Exception } from '@rpal/http';
+
+export class ${name} extends Exception {
+  constructor(
+    message: string = '${name} error',
+    status: number = 500
+  ) {
+    super(message, status);
+    this.name = '${name}';
+  }
+}
+`;
+}
+function generateValidator(name) {
+    const modelFileName = toKebabCase(name).replace('-', '');
+    return `import { z } from 'zod';
+
+export const ${name}Schema = z.object({
+  // Define your validation schema here
+  // Example:
+  // name: z.string().min(1).max(255),
+  // email: z.string().email(),
+});
+
+export type ${name}Input = z.infer<typeof ${name}Schema>;
+`;
+}
+function toPascalCase(str) {
+    return str
+        .split(/[-_\s]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}

package/dist/templates.js

@@ -0,0 +1,26 @@
+export const templates = [
+    {
+        name: 'API',
+        alias: 'api',
+        hint: 'Type-safe REST API with authentication and database',
+        source: 'github:paljs/starter-kits/api',
+    },
+    {
+        name: 'Admin',
+        alias: 'admin',
+        hint: 'Admin dashboard with authentication and UI components',
+        source: 'github:paljs/starter-kits/admin',
+    },
+    {
+        name: 'Client',
+        alias: 'client',
+        hint: 'Full-stack client application with frontend and API',
+        source: 'github:paljs/starter-kits/client',
+    },
+];
+export function getTemplateByAlias(alias) {
+    return templates.find((t) => t.alias === alias);
+}
+export function getTemplateByName(name) {
+    return templates.find((t) => t.name.toLowerCase() === name.toLowerCase());
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rpal/cli",
-  "version": "1.0.0",
-  "description": "CLI tool for PalJS",
+  "version": "1.1.0",
+  "description": "CLI tool for PalJS - The batteries-included full-stack framework",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -16,15 +16,15 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts"
+  },
   "dependencies": {
-    "@rpal/core": "^1.0.0"
+    "@rpal/core": "workspace:*"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "tsx": "^4.0.0"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "dev": "tsx src/index.ts"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 paljs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.