fragment-ts 1.0.2 → 1.0.4

package/src/auth/auth.service.ts

@@ -1,110 +0,0 @@
-
-import * as crypto from 'crypto';
-import * as bcrypt from 'bcrypt';
-import { Service } from '../core/decorators/service.decorator';
-import { Autowire } from '../core/decorators/autowire.decorator';
-import { UserRepository } from '../repositories/user.repository';
-import { SessionRepository } from '../repositories/session.repository';
-import { LoginDTO, RegisterDTO } from './dto/login.dto';
-import { ConfigLoader } from '../core/config/config-loader';
-
-@Service()
-export class AuthService {
-  constructor(
-    @Autowire() private userRepository: UserRepository,
-    @Autowire() private sessionRepository: SessionRepository
-  ) {}
-
-  async register(dto: RegisterDTO): Promise<{ user: any; token: string }> {
-    const existingUser = await this.userRepository.findByEmail(dto.email);
-    if (existingUser) {
-      throw new Error('User already exists');
-    }
-
-    const passwordHash = await bcrypt.hash(dto.password, 10);
-    const user = await this.userRepository.create({
-      name: dto.name,
-      email: dto.email,
-      passwordHash
-    });
-
-    const token = await this.createSession(user.id);
-
-    return {
-      user: { id: user.id, name: user.name, email: user.email },
-      token
-    };
-  }
-
-  async login(dto: LoginDTO): Promise<{ user: any; token: string }> {
-    const user = await this.userRepository.findByEmail(dto.email);
-    if (!user) {
-      throw new Error('Invalid credentials');
-    }
-
-    const isValidPassword = await bcrypt.compare(dto.password, user.passwordHash);
-    if (!isValidPassword) {
-      throw new Error('Invalid credentials');
-    }
-
-    const token = await this.createSession(user.id);
-
-    return {
-      user: { id: user.id, name: user.name, email: user.email },
-      token
-    };
-  }
-
-  async logout(token: string): Promise<void> {
-    await this.sessionRepository.deleteByToken(token);
-  }
-
-  async validateToken(token: string): Promise<any> {
-    const session = await this.sessionRepository.findByToken(token);
-    if (!session) {
-      return null;
-    }
-
-    return {
-      id: session.user.id,
-      name: session.user.name,
-      email: session.user.email
-    };
-  }
-
-  private async createSession(userId: number): Promise<string> {
-    const token = crypto.randomBytes(32).toString('hex');
-    const config = ConfigLoader.get();
-    
-    // Parse token expiry (e.g., "7d" = 7 days)
-    const expiryMs = this.parseExpiry(config.auth.tokenExpiry);
-    const expiresAt = new Date(Date.now() + expiryMs);
-
-    await this.sessionRepository.create({
-      token,
-      userId,
-      expiresAt
-    });
-
-    return token;
-  }
-
-  private parseExpiry(expiry: string): number {
-    const match = expiry.match(/^(\d+)([dhms])$/);
-    if (!match) {
-      return 7 * 24 * 60 * 60 * 1000; // default 7 days
-    }
-
-    const value = parseInt(match[1]);
-    const unit = match[2];
-
-    const multipliers: { [key: string]: number } = {
-      's': 1000,
-      'm': 60 * 1000,
-      'h': 60 * 60 * 1000,
-      'd': 24 * 60 * 60 * 1000
-    };
-
-    return value * multipliers[unit];
-  }
-}

package/src/auth/dto/login.dto.ts

@@ -1,11 +0,0 @@
-
-export interface LoginDTO {
-  email: string;
-  password: string;
-}
-
-export interface RegisterDTO {
-  name: string;
-  email: string;
-  password: string;
-}

package/src/cli/cli.ts

@@ -1,212 +0,0 @@
-
-import chalk from 'chalk';
-import { Command } from 'commander';
-import { InitCommand } from './commands/init.command';
-import { GenerateCommand } from './commands/generate.command';
-import { ConfigCommand } from './commands/config.command';
-import { ServeCommand } from './commands/serve.command';
-import { BuildCommand } from './commands/build.command';
-import { MigrateCommand } from './commands/migrate.command';
-import { CLILogger } from './utils/logger';
-
-export class CLI {
-  private program: Command;
-  private initCommand: InitCommand;
-  private generateCommand: GenerateCommand;
-  private configCommand: ConfigCommand;
-  private serveCommand: ServeCommand;
-  private buildCommand: BuildCommand;
-  private migrateCommand: MigrateCommand;
-
-  constructor() {
-    this.program = new Command();
-    this.initCommand = new InitCommand();
-    this.generateCommand = new GenerateCommand();
-    this.configCommand = new ConfigCommand();
-    this.serveCommand = new ServeCommand();
-    this.buildCommand = new BuildCommand();
-    this.migrateCommand = new MigrateCommand();
-
-    this.setupCommands();
-  }
-
-  private setupCommands(): void {
-    this.program
-      .name('frg')
-      .description('Fragment Framework CLI - Build powerful TypeScript backends')
-      .version('1.0.0');
-
-    // ASCII Art Banner
-    this.program
-      .addHelpText('beforeAll', () => {
-        return chalk.cyan(`
-╔═══════════════════════════════════════════════════════════╗
-║                                                           ║
-║   ███████╗██████╗  █████╗  ██████╗ ███╗   ███╗███████╗  ║
-║   ██╔════╝██╔══██╗██╔══██╗██╔════╝ ████╗ ████║██╔════╝  ║
-║   █████╗  ██████╔╝███████║██║  ███╗██╔████╔██║█████╗    ║
-║   ██╔══╝  ██╔══██╗██╔══██║██║   ██║██║╚██╔╝██║██╔══╝    ║
-║   ██║     ██║  ██║██║  ██║╚██████╔╝██║ ╚═╝ ██║███████╗  ║
-║   ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═╝     ╚═╝╚══════╝  ║
-║                                                           ║
-║          TypeScript Backend Framework (v1.0.0)           ║
-╚═══════════════════════════════════════════════════════════╝
-`);
-      });
-
-    // Init command
-    this.program
-      .command('init [project-name]')
-      .description('Initialize a new Fragment project')
-      .action(async (projectName) => {
-        await this.initCommand.execute(projectName);
-      });
-
-    // Generate commands
-    const generate = this.program
-      .command('generate')
-      .alias('g')
-      .description('Generate application components');
-
-    generate
-      .command('controller [name]')
-      .alias('c')
-      .description('Generate a new controller')
-      .action(async (name) => {
-        await this.generateCommand.execute('controller', name);
-      });
-
-    generate
-      .command('service [name]')
-      .alias('s')
-      .description('Generate a new service')
-      .action(async (name) => {
-        await this.generateCommand.execute('service', name);
-      });
-
-    generate
-      .command('repository [name]')
-      .alias('r')
-      .description('Generate a new repository')
-      .action(async (name) => {
-        await this.generateCommand.execute('repository', name);
-      });
-
-    generate
-      .command('entity [name]')
-      .alias('e')
-      .description('Generate a new entity')
-      .action(async (name) => {
-        await this.generateCommand.execute('entity', name);
-      });
-
-    generate
-      .command('resource [name]')
-      .alias('res')
-      .description('Generate a complete resource (controller, service, repository, entity)')
-      .action(async (name) => {
-        await this.generateCommand.execute('resource', name);
-      });
-
-    // Config commands
-    const config = this.program
-      .command('config')
-      .description('Configure Fragment application');
-
-    config
-      .command('ai')
-      .description('Configure OpenAI integration')
-      .action(async () => {
-        await this.configCommand.execute('ai');
-      });
-
-    config
-      .command('db')
-      .alias('database')
-      .description('Configure database connection')
-      .action(async () => {
-        await this.configCommand.execute('db');
-      });
-
-    config
-      .command('show')
-      .description('Show current configuration')
-      .action(async () => {
-        await this.configCommand.execute('show');
-      });
-
-    // Serve command
-    this.program
-      .command('serve')
-      .alias('dev')
-      .description('Start development server')
-      .option('-p, --port <port>', 'Port number', parseInt)
-      .option('--no-watch', 'Disable file watching')
-      .action(async (options) => {
-        await this.serveCommand.execute(options);
-      });
-
-    // Build command
-    this.program
-      .command('build')
-      .description('Build application for production')
-      .action(async () => {
-        await this.buildCommand.execute();
-      });
-
-    // Migrate commands
-    const migrate = this.program
-      .command('migrate')
-      .alias('migration')
-      .description('Database migration commands');
-
-    migrate
-      .command('run')
-      .description('Run pending migrations')
-      .action(async () => {
-        await this.migrateCommand.execute('run');
-      });
-
-    migrate
-      .command('generate')
-      .alias('create')
-      .description('Generate a new migration')
-      .action(async () => {
-        await this.migrateCommand.execute('generate');
-      });
-
-    migrate
-      .command('revert')
-      .description('Revert last migration')
-      .action(async () => {
-        await this.migrateCommand.execute('revert');
-      });
-
-    migrate
-      .command('show')
-      .alias('status')
-      .description('Show migration status')
-      .action(async () => {
-        await this.migrateCommand.execute('show');
-      });
-
-    // Info command
-    this.program
-      .command('info')
-      .description('Display Fragment CLI information')
-      .action(() => {
-        CLILogger.box('Fragment Framework CLI', [
-          'Version: 1.0.0',
-          'TypeScript Backend Framework',
-          'OOP + Decorators + DI',
-          '',
-          'Documentation: https://fragment-framework.dev',
-          'Repository: https://github.com/fragment/framework'
-        ]);
-      });
-  }
-
-  run(args: string[]): void {
-    this.program.parse(['node', 'frg', ...args]);
-  }
-}

package/src/cli/commands/config.command.ts

@@ -1,280 +0,0 @@
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import { CLILogger } from '../utils/logger';
-import { FileGenerator } from '../utils/file-generator';
-import inquirer from 'inquirer';
-
-export class ConfigCommand {
-  async execute(target: string): Promise<void> {
-    switch (target) {
-      case 'ai':
-        await this.configureAI();
-        break;
-      case 'db':
-      case 'database':
-        await this.configureDatabase();
-        break;
-      case 'show':
-        await this.showConfig();
-        break;
-      default:
-        CLILogger.error(`Unknown config target: ${target}`);
-        CLILogger.info('Available targets: ai, db, show');
-    }
-  }
-
-  private async configureAI(): Promise<void> {
-    CLILogger.title('🤖 OpenAI Configuration');
-
-    const answers = await inquirer.prompt([
-      {
-        type: 'password',
-        name: 'apiKey',
-        message: 'OpenAI API Key:',
-        mask: '*',
-        validate: (input: string) => {
-          if (!input || !input.startsWith('sk-')) {
-            return 'Please enter a valid OpenAI API key (starts with sk-)';
-          }
-          return true;
-        }
-      },
-      {
-        type: 'list',
-        name: 'model',
-        message: 'Default model:',
-        choices: [
-          'gpt-4-turbo',
-          'gpt-4',
-          'gpt-3.5-turbo',
-          'claude-sonnet-4-5-20250929',
-          'claude-opus-4-1-20250514'
-        ],
-        default: 'gpt-4'
-      },
-      {
-        type: 'confirm',
-        name: 'saveToEnv',
-        message: 'Save API key to .env file?',
-        default: true
-      }
-    ]);
-
-    const configPath = path.join(process.cwd(), 'config/fragment.yaml');
-    
-    if (!FileGenerator.fileExists(configPath)) {
-      CLILogger.error('fragment.yaml not found. Are you in a Fragment project?');
-      return;
-    }
-
-    try {
-      const configContent = FileGenerator.readFile(configPath);
-      const config: any = yaml.load(configContent);
-
-      if (!config.openai) {
-        config.openai = {};
-      }
-
-      config.openai.apiKey = answers.saveToEnv ? '${OPENAI_API_KEY}' : answers.apiKey;
-      config.openai.model = answers.model;
-
-      FileGenerator.writeFile(configPath, yaml.dump(config));
-
-      if (answers.saveToEnv) {
-        const envPath = path.join(process.cwd(), '.env');
-        let envContent = '';
-
-        if (FileGenerator.fileExists(envPath)) {
-          envContent = FileGenerator.readFile(envPath);
-        }
-
-        // Update or add OPENAI_API_KEY
-        if (envContent.includes('OPENAI_API_KEY=')) {
-          envContent = envContent.replace(
-            /OPENAI_API_KEY=.*/,
-            `OPENAI_API_KEY=${answers.apiKey}`
-          );
-        } else {
-          envContent += `\nOPENAI_API_KEY=${answers.apiKey}`;
-        }
-
-        FileGenerator.writeFile(envPath, envContent);
-        CLILogger.success('API key saved to .env file');
-      }
-
-      CLILogger.success('OpenAI configuration updated');
-      CLILogger.table({
-        'Model': answers.model,
-        'API Key': answers.saveToEnv ? 'Stored in .env' : 'Stored in config'
-      });
-
-    } catch (error: any) {
-      CLILogger.error(`Failed to update configuration: ${error.message}`);
-    }
-  }
-
-  private async configureDatabase(): Promise<void> {
-    CLILogger.title('🗄️  Database Configuration');
-
-    const answers = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'type',
-        message: 'Database type:',
-        choices: ['postgres', 'mysql', 'sqlite', 'mongodb']
-      },
-      {
-        type: 'input',
-        name: 'host',
-        message: 'Host:',
-        default: 'localhost',
-        when: (answers) => answers.type !== 'sqlite'
-      },
-      {
-        type: 'input',
-        name: 'port',
-        message: 'Port:',
-        default: (answers: any) => {
-          const ports: any = { postgres: 5432, mysql: 3306, mongodb: 27017 };
-          return ports[answers.type] || 5432;
-        },
-        when: (answers) => answers.type !== 'sqlite'
-      },
-      {
-        type: 'input',
-        name: 'username',
-        message: 'Username:',
-        default: (answers: any) => answers.type === 'postgres' ? 'postgres' : 'root',
-        when: (answers) => answers.type !== 'sqlite'
-      },
-      {
-        type: 'password',
-        name: 'password',
-        message: 'Password:',
-        mask: '*',
-        when: (answers) => answers.type !== 'sqlite'
-      },
-      {
-        type: 'input',
-        name: 'database',
-        message: 'Database name:',
-        default: 'fragment_db'
-      },
-      {
-        type: 'confirm',
-        name: 'synchronize',
-        message: 'Auto-synchronize schema? (not recommended for production)',
-        default: true
-      }
-    ]);
-
-    const configPath = path.join(process.cwd(), 'config/fragment.yaml');
-    
-    try {
-      const configContent = FileGenerator.readFile(configPath);
-      const config: any = yaml.load(configContent);
-
-      config.database = {
-        type: answers.type,
-        ...(answers.type !== 'sqlite' && {
-          host: '${DB_HOST:' + answers.host + '}',
-          port: '${DB_PORT:' + answers.port + '}',
-          username: '${DB_USERNAME:' + answers.username + '}',
-          password: '${DB_PASSWORD}'
-        }),
-        database: '${DB_DATABASE:' + answers.database + '}',
-        synchronize: answers.synchronize,
-        logging: false
-      };
-
-      FileGenerator.writeFile(configPath, yaml.dump(config));
-
-      // Update .env
-      const envPath = path.join(process.cwd(), '.env');
-      let envContent = FileGenerator.fileExists(envPath) ? FileGenerator.readFile(envPath) : '';
-
-      const envVars: any = {
-        DB_HOST: answers.host,
-        DB_PORT: answers.port,
-        DB_USERNAME: answers.username,
-        DB_PASSWORD: answers.password,
-        DB_DATABASE: answers.database
-      };
-
-      Object.entries(envVars).forEach(([key, value]) => {
-        if (value !== undefined) {
-          if (envContent.includes(`${key}=`)) {
-            envContent = envContent.replace(new RegExp(`${key}=.*`), `${key}=${value}`);
-          } else {
-            envContent += `\n${key}=${value}`;
-          }
-        }
-      });
-
-      FileGenerator.writeFile(envPath, envContent.trim());
-
-      CLILogger.success('Database configuration updated');
-      CLILogger.table({
-        'Type': answers.type,
-        'Host': answers.host || 'N/A',
-        'Database': answers.database,
-        'Synchronize': answers.synchronize ? 'Yes' : 'No'
-      });
-
-    } catch (error: any) {
-      CLILogger.error(`Failed to update configuration: ${error.message}`);
-    }
-  }
-
-  private async showConfig(): Promise<void> {
-    CLILogger.title('📋 Current Configuration');
-
-    const configPath = path.join(process.cwd(), 'config/fragment.yaml');
-    
-    if (!FileGenerator.fileExists(configPath)) {
-      CLILogger.error('fragment.yaml not found');
-      return;
-    }
-
-    try {
-      const configContent = FileGenerator.readFile(configPath);
-      const config: any = yaml.load(configContent);
-
-      CLILogger.section('Application');
-      CLILogger.table({
-        'Name': config.app?.name || 'N/A',
-        'Port': config.app?.port || 'N/A',
-        'Environment': config.app?.env || 'N/A'
-      });
-
-      CLILogger.section('Database');
-      CLILogger.table({
-        'Type': config.database?.type || 'N/A',
-        'Host': config.database?.host || 'N/A',
-        'Database': config.database?.database || 'N/A',
-        'Synchronize': config.database?.synchronize ? 'Yes' : 'No'
-      });
-
-      if (config.openai) {
-        CLILogger.section('OpenAI');
-        CLILogger.table({
-          'Model': config.openai.model || 'N/A',
-          'API Key': config.openai.apiKey?.includes('${') ? 'From environment' : 'Configured'
-        });
-      }
-
-      if (config.auth) {
-        CLILogger.section('Authentication');
-        CLILogger.table({
-          'Token Expiry': config.auth.tokenExpiry || 'N/A',
-          'Session Expiry': config.auth.sessionExpiry || 'N/A'
-        });
-      }
-
-    } catch (error: any) {
-      CLILogger.error(`Failed to read configuration: ${error.message}`);
-    }
-  }
-}

package/src/cli/templates/controller.template.ts

@@ -1,51 +0,0 @@
-
-export function controllerTemplate(name: string, route: string): string {
-  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/src/cli/templates/entity.template.ts

@@ -1,22 +0,0 @@
-
-export function entityTemplate(name: string): string {
-  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;
-}
-`;
-}