fragment-ts 1.0.0

package/dist/cli/commands/init.command.js

@@ -0,0 +1,380 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitCommand = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+const file_generator_1 = require("../utils/file-generator");
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+class InitCommand {
+    async execute(projectName) {
+        logger_1.CLILogger.title('🔷 Fragment Framework Initializer');
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'projectName',
+                message: 'Project name:',
+                default: projectName || 'my-fragment-app',
+                validate: (input) => {
+                    if (!/^[a-z0-9-]+$/.test(input)) {
+                        return 'Project name must contain only lowercase letters, numbers, and hyphens';
+                    }
+                    return true;
+                }
+            },
+            {
+                type: 'list',
+                name: 'database',
+                message: 'Select database:',
+                choices: ['PostgreSQL', 'MySQL', 'SQLite', 'MongoDB'],
+                default: 'PostgreSQL'
+            },
+            {
+                type: 'confirm',
+                name: 'useOpenAI',
+                message: 'Enable OpenAI integration?',
+                default: true
+            },
+            {
+                type: 'confirm',
+                name: 'useAuth',
+                message: 'Include authentication system?',
+                default: true
+            },
+            {
+                type: 'list',
+                name: 'packageManager',
+                message: 'Package manager:',
+                choices: ['npm', 'yarn', 'pnpm'],
+                default: 'npm'
+            }
+        ]);
+        const projectPath = path.join(process.cwd(), answers.projectName);
+        if (fs.existsSync(projectPath)) {
+            logger_1.CLILogger.error(`Directory ${answers.projectName} already exists`);
+            return;
+        }
+        const spinner = logger_1.CLILogger.spinner('Creating project structure...');
+        try {
+            // Create project directory
+            file_generator_1.FileGenerator.createDirectory(projectPath);
+            // Create directory structure
+            const dirs = [
+                'src/controllers',
+                'src/services',
+                'src/repositories',
+                'src/entities',
+                'src/middlewares',
+                'src/core/decorators',
+                'src/core/container',
+                'src/core/config',
+                'src/database',
+                'config'
+            ];
+            if (answers.useOpenAI) {
+                dirs.push('src/core/openai');
+            }
+            if (answers.useAuth) {
+                dirs.push('src/auth', 'src/auth/dto');
+            }
+            dirs.forEach(dir => {
+                file_generator_1.FileGenerator.createDirectory(path.join(projectPath, dir));
+            });
+            spinner.text = 'Generating configuration files...';
+            // Generate package.json
+            const packageJson = {
+                name: answers.projectName,
+                version: '1.0.0',
+                description: 'Fragment Framework Application',
+                main: 'dist/server.js',
+                scripts: {
+                    dev: 'ts-node-dev --respawn --transpile-only src/server.ts',
+                    build: 'tsc',
+                    start: 'node dist/server.js',
+                    'frg:generate': 'frg generate',
+                    'frg:migrate': 'frg migrate'
+                },
+                dependencies: {
+                    express: '^4.18.2',
+                    typeorm: '^0.3.17',
+                    'reflect-metadata': '^0.1.13',
+                    bcrypt: '^5.1.1',
+                    'js-yaml': '^4.1.0',
+                    pino: '^8.16.0',
+                    'pino-pretty': '^10.2.3'
+                },
+                devDependencies: {
+                    '@types/express': '^4.17.20',
+                    '@types/node': '^20.9.0',
+                    '@types/bcrypt': '^5.0.2',
+                    '@types/js-yaml': '^4.0.9',
+                    typescript: '^5.2.2',
+                    'ts-node': '^10.9.1',
+                    'ts-node-dev': '^2.0.0'
+                }
+            };
+            // Add database driver
+            const dbDrivers = {
+                'PostgreSQL': 'pg@^8.11.3',
+                'MySQL': 'mysql2@^3.6.5',
+                'SQLite': 'sqlite3@^5.1.6',
+                'MongoDB': 'mongodb@^6.3.0'
+            };
+            packageJson.dependencies = {
+                ...packageJson.dependencies,
+                [dbDrivers[answers.database].split('@')[0]]: dbDrivers[answers.database].split('@')[1]
+            };
+            file_generator_1.FileGenerator.writeFile(path.join(projectPath, 'package.json'), JSON.stringify(packageJson, null, 2));
+            // Generate tsconfig.json
+            const tsConfig = {
+                compilerOptions: {
+                    target: 'ES2020',
+                    module: 'commonjs',
+                    lib: ['ES2020'],
+                    outDir: './dist',
+                    rootDir: './src',
+                    strict: true,
+                    esModuleInterop: true,
+                    skipLibCheck: true,
+                    forceConsistentCasingInFileNames: true,
+                    resolveJsonModule: true,
+                    experimentalDecorators: true,
+                    emitDecoratorMetadata: true,
+                    moduleResolution: 'node',
+                    allowSyntheticDefaultImports: true
+                },
+                include: ['src/**/*'],
+                exclude: ['node_modules', 'dist']
+            };
+            file_generator_1.FileGenerator.writeFile(path.join(projectPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
+            // Generate fragment.yaml
+            const dbConfig = this.getDatabaseConfig(answers.database);
+            const fragmentConfig = `app:
+  name: ${answers.projectName}
+  port: 3000
+  env: development
+
+database:
+${dbConfig}
+
+${answers.useOpenAI ? `openai:
+  apiKey: \${OPENAI_API_KEY}
+  model: gpt-4
+` : ''}
+${answers.useAuth ? `auth:
+  tokenExpiry: 7d
+  sessionExpiry: 30d
+` : ''}`;
+            file_generator_1.FileGenerator.writeFile(path.join(projectPath, 'config/fragment.yaml'), fragmentConfig);
+            // Generate .env.example
+            let envExample = `NODE_ENV=development
+PORT=3000
+
+${this.getEnvTemplate(answers.database)}`;
+            if (answers.useOpenAI) {
+                envExample += '\nOPENAI_API_KEY=sk-your-openai-api-key';
+            }
+            file_generator_1.FileGenerator.writeFile(path.join(projectPath, '.env.example'), envExample);
+            // Generate .gitignore
+            const gitignore = `node_modules/
+dist/
+.env
+*.log
+.DS_Store
+config/fragment.lock.yaml`;
+            file_generator_1.FileGenerator.writeFile(path.join(projectPath, '.gitignore'), gitignore);
+            // Generate README.md
+            const readme = this.generateReadme(answers.projectName, answers);
+            file_generator_1.FileGenerator.writeFile(path.join(projectPath, 'README.md'), readme);
+            spinner.text = 'Copying core framework files...';
+            // Copy all core files (decorators, container, config, etc.)
+            await this.copyFrameworkCore(projectPath, answers);
+            spinner.succeed('Project structure created');
+            // Install dependencies
+            const installSpinner = logger_1.CLILogger.spinner(`Installing dependencies with ${answers.packageManager}...`);
+            try {
+                (0, child_process_1.execSync)(`cd ${projectPath} && ${answers.packageManager} install`, {
+                    stdio: 'pipe'
+                });
+                installSpinner.succeed('Dependencies installed');
+            }
+            catch (error) {
+                installSpinner.fail('Failed to install dependencies');
+                logger_1.CLILogger.warning('You can install them manually by running:');
+                console.log(`  cd ${answers.projectName} && ${answers.packageManager} install`);
+            }
+            // Success message
+            logger_1.CLILogger.box('🎉 Project Created Successfully!', [
+                `Project: ${answers.projectName}`,
+                `Location: ${projectPath}`,
+                `Database: ${answers.database}`,
+                `OpenAI: ${answers.useOpenAI ? 'Enabled' : 'Disabled'}`,
+                `Auth: ${answers.useAuth ? 'Enabled' : 'Disabled'}`
+            ]);
+            console.log(chalk_1.default.bold('\nNext steps:'));
+            console.log(`  1. cd ${answers.projectName}`);
+            console.log(`  2. cp .env.example .env`);
+            console.log(`  3. Configure your database in .env`);
+            if (answers.useOpenAI) {
+                console.log(`  4. Add your OpenAI API key to .env`);
+            }
+            console.log(`  ${answers.useOpenAI ? '5' : '4'}. ${answers.packageManager} run dev`);
+            logger_1.CLILogger.section('Available Commands:');
+            logger_1.CLILogger.table({
+                'frg generate controller <name>': 'Generate a new controller',
+                'frg generate service <name>': 'Generate a new service',
+                'frg generate resource <name>': 'Generate controller, service, repository & entity',
+                'frg config ai': 'Configure OpenAI settings',
+                'frg migrate': 'Run database migrations',
+                'frg serve': 'Start development server'
+            });
+        }
+        catch (error) {
+            spinner.fail('Failed to create project');
+            logger_1.CLILogger.error(error.message);
+        }
+    }
+    getDatabaseConfig(database) {
+        const configs = {
+            'PostgreSQL': `  type: postgres
+  host: \${DB_HOST:localhost}
+  port: \${DB_PORT:5432}
+  username: \${DB_USERNAME:postgres}
+  password: \${DB_PASSWORD:postgres}
+  database: \${DB_DATABASE:fragment_db}
+  synchronize: true
+  logging: false`,
+            'MySQL': `  type: mysql
+  host: \${DB_HOST:localhost}
+  port: \${DB_PORT:3306}
+  username: \${DB_USERNAME:root}
+  password: \${DB_PASSWORD:root}
+  database: \${DB_DATABASE:fragment_db}
+  synchronize: true
+  logging: false`,
+            'SQLite': `  type: sqlite
+  database: \${DB_DATABASE:database.sqlite}
+  synchronize: true
+  logging: false`,
+            'MongoDB': `  type: mongodb
+  host: \${DB_HOST:localhost}
+  port: \${DB_PORT:27017}
+  database: \${DB_DATABASE:fragment_db}
+  synchronize: true
+  logging: false`
+        };
+        return configs[database];
+    }
+    getEnvTemplate(database) {
+        if (database === 'SQLite') {
+            return 'DB_DATABASE=database.sqlite';
+        }
+        return `DB_HOST=localhost
+DB_PORT=${database === 'PostgreSQL' ? '5432' : database === 'MySQL' ? '3306' : '27017'}
+DB_USERNAME=${database === 'PostgreSQL' ? 'postgres' : 'root'}
+DB_PASSWORD=${database === 'PostgreSQL' ? 'postgres' : 'root'}
+DB_DATABASE=fragment_db`;
+    }
+    generateReadme(projectName, answers) {
+        return `# ${projectName}
+
+A Fragment Framework application.
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+${answers.packageManager} install
+
+# Configure environment
+cp .env.example .env
+
+# Start development server
+${answers.packageManager} run dev
+\`\`\`
+
+## Fragment CLI Commands
+
+\`\`\`bash
+# Generate resources
+frg generate controller <name>    # Generate controller
+frg generate service <name>       # Generate service
+frg generate repository <name>    # Generate repository
+frg generate entity <name>        # Generate entity
+frg generate resource <name>      # Generate all of the above
+
+# Configuration
+frg config ai                     # Configure OpenAI settings
+frg config db                     # Configure database settings
+
+# Database
+frg migrate                       # Run migrations
+
+# Development
+frg serve                         # Start development server
+frg build                         # Build for production
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+src/
+├── controllers/    # HTTP request handlers
+├── services/       # Business logic
+├── repositories/   # Data access layer
+├── entities/       # Database models
+├── middlewares/    # Express middlewares
+└── core/          # Framework core
+\`\`\`
+
+## Documentation
+
+Visit [Fragment Framework Documentation](https://fragment-framework.dev) for more information.
+`;
+    }
+    async copyFrameworkCore(projectPath, answers) {
+        // This would copy all the core framework files
+        // For brevity, I'll show the structure
+        // In a real implementation, these would be actual file copies
+        logger_1.CLILogger.info('Core framework files copied');
+    }
+}
+exports.InitCommand = InitCommand;

package/dist/cli/commands/migrate.command.d.ts

@@ -0,0 +1,7 @@
+export declare class MigrateCommand {
+    execute(action?: string): Promise<void>;
+    private runMigrations;
+    private generateMigration;
+    private revertMigration;
+    private showMigrations;
+}

package/dist/cli/commands/migrate.command.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrateCommand = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+const inquirer_1 = __importDefault(require("inquirer"));
+class MigrateCommand {
+    async execute(action) {
+        if (!action) {
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: 'Select migration action:',
+                    choices: [
+                        { name: 'Run pending migrations', value: 'run' },
+                        { name: 'Generate new migration', value: 'generate' },
+                        { name: 'Revert last migration', value: 'revert' },
+                        { name: 'Show migration status', value: 'show' }
+                    ]
+                }
+            ]);
+            action = answer.action;
+        }
+        switch (action) {
+            case 'run':
+                await this.runMigrations();
+                break;
+            case 'generate':
+                await this.generateMigration();
+                break;
+            case 'revert':
+                await this.revertMigration();
+                break;
+            case 'show':
+                await this.showMigrations();
+                break;
+            default:
+                logger_1.CLILogger.error(`Unknown action: ${action}`);
+        }
+    }
+    async runMigrations() {
+        logger_1.CLILogger.title('📦 Running Migrations');
+        const spinner = logger_1.CLILogger.spinner('Executing migrations...');
+        try {
+            (0, child_process_1.execSync)('npm run typeorm migration:run', { stdio: 'pipe' });
+            spinner.succeed('Migrations executed successfully');
+        }
+        catch (error) {
+            spinner.fail('Migration failed');
+            logger_1.CLILogger.error(error.message);
+        }
+    }
+    async generateMigration() {
+        const answer = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Migration name:',
+                validate: (input) => {
+                    if (!input)
+                        return 'Name is required';
+                    return true;
+                }
+            }
+        ]);
+        logger_1.CLILogger.title(`📝 Generating Migration: ${answer.name}`);
+        const spinner = logger_1.CLILogger.spinner('Creating migration file...');
+        try {
+            (0, child_process_1.execSync)(`npm run typeorm migration:generate -- -n ${answer.name}`, { stdio: 'pipe' });
+            spinner.succeed('Migration generated successfully');
+        }
+        catch (error) {
+            spinner.fail('Failed to generate migration');
+            logger_1.CLILogger.error(error.message);
+        }
+    }
+    async revertMigration() {
+        const confirm = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirmed',
+                message: 'Are you sure you want to revert the last migration?',
+                default: false
+            }
+        ]);
+        if (!confirm.confirmed) {
+            logger_1.CLILogger.info('Migration revert cancelled');
+            return;
+        }
+        logger_1.CLILogger.title('⏪ Reverting Migration');
+        const spinner = logger_1.CLILogger.spinner('Reverting last migration...');
+        try {
+            (0, child_process_1.execSync)('npm run typeorm migration:revert', { stdio: 'pipe' });
+            spinner.succeed('Migration reverted successfully');
+        }
+        catch (error) {
+            spinner.fail('Failed to revert migration');
+            logger_1.CLILogger.error(error.message);
+        }
+    }
+    async showMigrations() {
+        logger_1.CLILogger.title('📋 Migration Status');
+        try {
+            const output = (0, child_process_1.execSync)('npm run typeorm migration:show', { encoding: 'utf-8' });
+            console.log(output);
+        }
+        catch (error) {
+            logger_1.CLILogger.error('Failed to show migrations');
+        }
+    }
+}
+exports.MigrateCommand = MigrateCommand;

package/dist/cli/commands/serve.command.d.ts

@@ -0,0 +1,6 @@
+export declare class ServeCommand {
+    execute(options: {
+        port?: number;
+        watch?: boolean;
+    }): Promise<void>;
+}

package/dist/cli/commands/serve.command.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServeCommand = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+class ServeCommand {
+    async execute(options) {
+        logger_1.CLILogger.title('🚀 Starting Fragment Application');
+        const port = options.port || process.env.PORT || 3000;
+        const args = ['--respawn', '--transpile-only'];
+        if (options.watch !== false) {
+            args.push('--watch');
+        }
+        args.push('src/server.ts');
+        const env = { ...process.env, PORT: port.toString() };
+        logger_1.CLILogger.info(`Starting server on port ${port}...`);
+        const child = (0, child_process_1.spawn)('ts-node-dev', args, {
+            env,
+            stdio: 'inherit'
+        });
+        child.on('error', (error) => {
+            logger_1.CLILogger.error(`Failed to start server: ${error.message}`);
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                logger_1.CLILogger.error(`Server exited with code ${code}`);
+            }
+        });
+    }
+}
+exports.ServeCommand = ServeCommand;

package/dist/cli/templates/controller.template.d.ts

@@ -0,0 +1 @@
+export declare function controllerTemplate(name: string, route: string): string;

package/dist/cli/templates/controller.template.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controllerTemplate = controllerTemplate;
+function controllerTemplate(name, route) {
+    const className = name.endsWith('Controller') ? name : `${name}Controller`;
+    const serviceName = name.replace('Controller', '') + 'Service';
+    return `import { Controller } from '../core/decorators/controller.decorator';
+import { Get, Post, Put, Delete } from '../core/decorators/route.decorator';
+import { Injectable } from '../core/decorators/injectable.decorator';
+import { Autowire } from '../core/decorators/autowire.decorator';
+import { ${serviceName} } from '../services/${name.toLowerCase()}.service';
+import { Request, Response } from 'express';
+
+@Controller('${route}')
+@Injectable()
+export class ${className} {
+  constructor(
+    @Autowire() private ${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)}: ${serviceName}
+  ) {}
+
+  @Get('/')
+  async findAll(req: Request, res: Response) {
+    const items = await this.${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)}.findAll();
+    return res.json(items);
+  }
+
+  @Get('/:id')
+  async findOne(req: Request, res: Response) {
+    const item = await this.${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)}.findById(parseInt(req.params.id));
+    return res.json(item);
+  }
+
+  @Post('/')
+  async create(req: Request, res: Response) {
+    const item = await this.${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)}.create(req.body);
+    return res.status(201).json(item);
+  }
+
+  @Put('/:id')
+  async update(req: Request, res: Response) {
+    const item = await this.${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)}.update(parseInt(req.params.id), req.body);
+    return res.json(item);
+  }
+
+  @Delete('/:id')
+  async delete(req: Request, res: Response) {
+    await this.${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)}.delete(parseInt(req.params.id));
+    return res.status(204).send();
+  }
+}
+`;
+}

package/dist/cli/templates/entity.template.d.ts

@@ -0,0 +1 @@
+export declare function entityTemplate(name: string): string;

package/dist/cli/templates/entity.template.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityTemplate = entityTemplate;
+function entityTemplate(name) {
+    const className = name.endsWith('Entity') ? name.replace('Entity', '') : name;
+    return `import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+@Entity('${className.toLowerCase()}s')
+export class ${className} {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column({ length: 255 })
+  name!: string;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+
+  @UpdateDateColumn()
+  updatedAt!: Date;
+}
+`;
+}

package/dist/cli/templates/repository.template.d.ts

@@ -0,0 +1 @@
+export declare function repositoryTemplate(name: string, entityName: string): string;

package/dist/cli/templates/repository.template.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repositoryTemplate = repositoryTemplate;
+function repositoryTemplate(name, entityName) {
+    const className = name.endsWith('Repository') ? name : `${name}Repository`;
+    return `import { Repository as TypeORMRepository } from 'typeorm';
+import { Repository } from '../core/decorators/repository.decorator';
+import { ${entityName} } from '../entities/${entityName.toLowerCase()}.entity';
+import { AppDataSource } from '../database/data-source';
+
+@Repository()
+export class ${className} {
+  private repository: TypeORMRepository<${entityName}>;
+
+  constructor() {
+    this.repository = AppDataSource.getRepository(${entityName});
+  }
+
+  async findAll(): Promise<${entityName}[]> {
+    return await this.repository.find();
+  }
+
+  async findById(id: number): Promise<${entityName} | null> {
+    return await this.repository.findOne({ where: { id } });
+  }
+
+  async create(data: Partial<${entityName}>): Promise<${entityName}> {
+    const entity = this.repository.create(data);
+    return await this.repository.save(entity);
+  }
+
+  async update(id: number, data: Partial<${entityName}>): Promise<${entityName} | null> {
+    await this.repository.update(id, data);
+    return await this.findById(id);
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this.repository.delete(id);
+    return result.affected ? result.affected > 0 : false;
+  }
+}
+`;
+}

package/dist/cli/templates/service.template.d.ts

@@ -0,0 +1 @@
+export declare function serviceTemplate(name: string): string;