fragment-ts 1.0.0

package/src/app.ts

@@ -0,0 +1,121 @@
+
+import express, { Express, Request, Response, NextFunction } from 'express';
+import { DIContainer } from './core/container/di-container';
+import { ConfigLoader } from './core/config/config-loader';
+import { initializeDataSource, AppDataSource } from './database/data-source';
+import { loggingMiddleware } from './middlewares/logging.middleware';
+import { authMiddleware } from './auth/auth.middleware';
+import {
+  CONTROLLER_METADATA,
+  CONTROLLER_PATH
+} from './core/decorators/controller.decorator';
+import {
+  ROUTE_METADATA
+} from './core/decorators/route.decorator';
+import {
+  AUTH_GUARD_METADATA
+} from './core/decorators/auth-guard.decorator';
+import {
+  MIDDLEWARE_METADATA
+} from './core/decorators/middleware.decorator';
+
+// Import all controllers, services, repositories
+import './controllers/health.controller';
+import './auth/auth.controller';
+import './services/health.service';
+import './repositories/user.repository';
+import './repositories/session.repository';
+import './auth/auth.service';
+import './core/openai/openai-client';
+
+export class FragmentApplication {
+  private app: Express;
+
+  constructor() {
+    this.app = express();
+  }
+
+  async initialize(): Promise<Express> {
+    // Load configuration
+    ConfigLoader.load(true);
+
+    // Initialize database
+    const dataSource = initializeDataSource();
+    await dataSource.initialize();
+    console.log('✅ Database connected');
+
+    // Middleware
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+    this.app.use(loggingMiddleware);
+
+    // Register all controllers
+    this.registerControllers();
+
+    // Error handling
+    this.app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
+      console.error(err.stack);
+      res.status(500).json({ error: 'Internal server error' });
+    });
+
+    return this.app;
+  }
+
+  private registerControllers(): void {
+    const registeredClasses = DIContainer.getRegisteredClasses();
+
+    registeredClasses.forEach((controllerClass) => {
+      const isController = Reflect.getMetadata(CONTROLLER_METADATA, controllerClass);
+      if (!isController) return;
+
+      const basePath = Reflect.getMetadata(CONTROLLER_PATH, controllerClass) || '';
+      const routes = Reflect.getMetadata(ROUTE_METADATA, controllerClass) || [];
+      const classMiddlewares = Reflect.getMetadata(MIDDLEWARE_METADATA, controllerClass) || [];
+      const classAuthGuard = Reflect.getMetadata(AUTH_GUARD_METADATA, controllerClass);
+
+      const controllerInstance = DIContainer.resolve(controllerClass) as any;
+
+      routes.forEach((route: any) => {
+        const fullPath = basePath + route.path;
+        const handler = controllerInstance[route.handlerName].bind(controllerInstance);
+
+        const middlewares: any[] = [...classMiddlewares];
+
+        const methodAuthGuard = Reflect.getMetadata(
+          AUTH_GUARD_METADATA,
+          controllerClass,
+          route.handlerName
+        );
+        if (classAuthGuard || methodAuthGuard) {
+          middlewares.push(authMiddleware);
+        }
+
+        const methodMiddlewares = Reflect.getMetadata(
+          MIDDLEWARE_METADATA,
+          controllerClass,
+          route.handlerName
+        ) || [];
+        middlewares.push(...methodMiddlewares);
+
+        const asyncHandler = async (req: Request, res: Response, next: NextFunction) => {
+          try {
+            const result = await handler(req, res, next);
+            if (result && !res.headersSent) {
+              res.json(result);
+            }
+          } catch (error) {
+            next(error);
+          }
+        };
+
+        (this.app as any)[route.method](fullPath, ...middlewares, asyncHandler);
+
+        console.log(`📍 ${route.method.toUpperCase().padEnd(6)} ${fullPath}`);
+      });
+    });
+  }
+
+  getExpressApp(): Express {
+    return this.app;
+  }
+}

package/src/auth/auth.controller.ts

@@ -0,0 +1,52 @@
+
+import { Controller } from '../core/decorators/controller.decorator';
+import { Post, Get } from '../core/decorators/route.decorator';
+import { Injectable } from '../core/decorators/injectable.decorator';
+import { Autowire } from '../core/decorators/autowire.decorator';
+import { AuthGuard } from '../core/decorators/auth-guard.decorator';
+import { AuthService } from './auth.service';
+import { Request, Response } from 'express';
+
+@Controller('/api/auth')
+@Injectable()
+export class AuthController {
+  constructor(
+    @Autowire() private authService: AuthService
+  ) {}
+
+  @Post('/register')
+  async register(req: Request, res: Response) {
+    try {
+      const result = await this.authService.register(req.body);
+      return res.json(result);
+    } catch (error: any) {
+      return res.status(400).json({ error: error.message });
+    }
+  }
+
+  @Post('/login')
+  async login(req: Request, res: Response) {
+    try {
+      const result = await this.authService.login(req.body);
+      return res.json(result);
+    } catch (error: any) {
+      return res.status(401).json({ error: error.message });
+    }
+  }
+
+  @Post('/logout')
+  @AuthGuard()
+  async logout(req: Request, res: Response) {
+    const token = req.headers.authorization?.replace('Bearer ', '');
+    if (token) {
+      await this.authService.logout(token);
+    }
+    return res.json({ message: 'Logged out successfully' });
+  }
+
+  @Get('/me')
+  @AuthGuard()
+  async getCurrentUser(req: Request, res: Response) {
+    return res.json({ user: (req as any).user });
+  }
+}

package/src/auth/auth.middleware.ts

@@ -0,0 +1,27 @@
+
+import { Request, Response, NextFunction } from 'express';
+import { DIContainer } from '../core/container/di-container';
+import { AuthService } from './auth.service';
+
+export async function authMiddleware(req: Request, res: Response, next: NextFunction) {
+  const authHeader = req.headers.authorization;
+  
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(401).json({ error: 'Unauthorized' });
+  }
+
+  const token = authHeader.replace('Bearer ', '');
+  const authService = DIContainer.resolve<AuthService>(AuthService);
+
+  try {
+    const user = await authService.validateToken(token);
+    if (!user) {
+      return res.status(401).json({ error: 'Invalid token' });
+    }
+
+    (req as any).user = user;
+    next();
+  } catch (error) {
+    return res.status(401).json({ error: 'Unauthorized' });
+  }
+}

package/src/auth/auth.service.ts

@@ -0,0 +1,110 @@
+
+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

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

package/src/cli/cli.ts

@@ -0,0 +1,212 @@
+
+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/build.command.ts

@@ -0,0 +1,24 @@
+
+import { execSync } from 'child_process';
+import { CLILogger } from '../utils/logger';
+
+export class BuildCommand {
+  async execute(): Promise<void> {
+    CLILogger.title('🔨 Building Fragment Application');
+
+    const spinner = CLILogger.spinner('Compiling TypeScript...');
+
+    try {
+      execSync('tsc', { stdio: 'pipe' });
+      spinner.succeed('Build completed successfully');
+
+      CLILogger.success('Output directory: ./dist');
+      CLILogger.info('Run "node dist/server.js" to start the production server');
+
+    } catch (error: any) {
+      spinner.fail('Build failed');
+      CLILogger.error(error.message);
+      process.exit(1);
+    }
+  }
+}