fragment-ts 1.0.0 → 1.0.1

package/src/cli/utils/logger.ts

@@ -1,52 +0,0 @@
-import chalk from 'chalk';
-import ora, { Ora } from 'ora';
-
-export class CLILogger {
-  static success(message: string): void {
-    console.log(chalk.green('✓'), message);
-  }
-
-  static error(message: string): void {
-    console.log(chalk.red('✗'), message);
-  }
-
-  static info(message: string): void {
-    console.log(chalk.blue('ℹ'), message);
-  }
-
-  static warning(message: string): void {
-    console.log(chalk.yellow('⚠'), message);
-  }
-
-  static title(message: string): void {
-    console.log(chalk.bold.cyan(`\n${message}\n`));
-  }
-
-  static section(message: string): void {
-    console.log(chalk.bold(`\n${message}`));
-  }
-
-  static spinner(text: string): Ora {
-    return ora(text).start();
-  }
-
-  static box(title: string, content: string[]): void {
-    const maxLength = Math.max(title.length, ...content.map(c => c.length)) + 4;
-    const border = '═'.repeat(maxLength);
-    
-    console.log(chalk.cyan(`╔${border}╗`));
-    console.log(chalk.cyan('║') + chalk.bold(` ${title.padEnd(maxLength)} `) + chalk.cyan('║'));
-    console.log(chalk.cyan(`╠${border}╣`));
-    content.forEach(line => {
-      console.log(chalk.cyan('║') + ` ${line.padEnd(maxLength)} ` + chalk.cyan('║'));
-    });
-    console.log(chalk.cyan(`╚${border}╝`));
-  }
-
-  static table(data: { [key: string]: string }): void {
-    const maxKeyLength = Math.max(...Object.keys(data).map(k => k.length));
-    Object.entries(data).forEach(([key, value]) => {
-      console.log(`  ${chalk.cyan(key.padEnd(maxKeyLength))} : ${value}`);
-    });
-  }
-}

package/src/controllers/health.controller.ts

@@ -1,24 +0,0 @@
-
-import { Controller } from '../core/decorators/controller.decorator';
-import { Get } from '../core/decorators/route.decorator';
-import { Injectable } from '../core/decorators/injectable.decorator';
-import { Autowire } from '../core/decorators/autowire.decorator';
-import { HealthService } from '../services/health.service';
-
-@Controller('/api/health')
-@Injectable()
-export class HealthController {
-  constructor(
-    @Autowire() private healthService: HealthService
-  ) {}
-
-  @Get('/')
-  async getStatus() {
-    return await this.healthService.getStatus();
-  }
-
-  @Get('/tip')
-  async getHealthTip() {
-    return await this.healthService.generateHealthTip();
-  }
-}

package/src/core/config/config-loader.ts

@@ -1,98 +0,0 @@
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-
-export interface AppConfig {
-  app: {
-    name: string;
-    port: number;
-    env: string;
-  };
-  database: {
-    type: string;
-    host: string;
-    port: number;
-    username: string;
-    password: string;
-    database: string;
-    synchronize: boolean;
-    logging: boolean;
-  };
-  openai: {
-    apiKey: string;
-    model: string;
-  };
-  auth: {
-    tokenExpiry: string;
-    sessionExpiry: string;
-  };
-}
-
-export class ConfigLoader {
-  private static config: AppConfig | null = null;
-
-  static load(useYaml: boolean = true): AppConfig {
-    if (this.config) {
-      return this.config;
-    }
-
-    const configDir = path.join(process.cwd(), 'config');
-    let configPath: string;
-
-    if (useYaml) {
-      // Try .lock.yaml first, then .yaml
-      const lockPath = path.join(configDir, 'app.lock.yaml');
-      const yamlPath = path.join(configDir, 'app.yaml');
-      
-      configPath = fs.existsSync(lockPath) ? lockPath : yamlPath;
-      
-      if (!fs.existsSync(configPath)) {
-        throw new Error('Configuration file not found');
-      }
-
-      const fileContent = fs.readFileSync(configPath, 'utf8');
-      this.config = yaml.load(fileContent) as AppConfig;
-    } else {
-      // JSON fallback
-      configPath = path.join(configDir, 'app.json');
-      const fileContent = fs.readFileSync(configPath, 'utf8');
-      this.config = JSON.parse(fileContent);
-    }
-
-    // Override with environment variables
-    this.config = this.mergeEnvVariables(this.config!);
-
-    return this.config;
-  }
-
-  private static mergeEnvVariables(config: AppConfig): AppConfig {
-    return {
-      ...config,
-      app: {
-        ...config.app,
-        port: process.env.PORT ? parseInt(process.env.PORT) : config.app.port,
-        env: process.env.NODE_ENV || config.app.env
-      },
-      database: {
-        ...config.database,
-        host: process.env.DB_HOST || config.database.host,
-        port: process.env.DB_PORT ? parseInt(process.env.DB_PORT) : config.database.port,
-        username: process.env.DB_USERNAME || config.database.username,
-        password: process.env.DB_PASSWORD || config.database.password,
-        database: process.env.DB_DATABASE || config.database.database
-      },
-      openai: {
-        ...config.openai,
-        apiKey: process.env.OPENAI_API_KEY || config.openai.apiKey
-      }
-    };
-  }
-
-  static get(): AppConfig {
-    if (!this.config) {
-      throw new Error('Config not loaded. Call ConfigLoader.load() first.');
-    }
-    return this.config;
-  }
-}

package/src/core/decorators/auth-guard.decorator.ts

@@ -1,15 +0,0 @@
-import 'reflect-metadata';
-
-export const AUTH_GUARD_METADATA = 'auth:guard';
-
-export function AuthGuard(): MethodDecorator & ClassDecorator {
-  return (target: any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => {
-    if (propertyKey) {
-      // method decorator
-      Reflect.defineMetadata(AUTH_GUARD_METADATA, true, target.constructor, propertyKey);
-    } else {
-      // class decorator
-      Reflect.defineMetadata(AUTH_GUARD_METADATA, true, target);
-    }
-  };
-}

package/src/core/decorators/autowire.decorator.ts

@@ -1,18 +0,0 @@
-
-import 'reflect-metadata';
-
-export const AUTOWIRE_METADATA = 'autowire:metadata';
-
-export function Autowire(): ParameterDecorator {
-  return (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => {
-    const existingParams = Reflect.getOwnMetadata(AUTOWIRE_METADATA, target) || [];
-    const types = Reflect.getMetadata('design:paramtypes', target) || [];
-    
-    existingParams.push({
-      index: parameterIndex,
-      type: types[parameterIndex]
-    });
-    
-    Reflect.defineMetadata(AUTOWIRE_METADATA, existingParams, target);
-  };
-}

package/src/core/decorators/middleware.decorator.ts

@@ -1,18 +0,0 @@
-
-import 'reflect-metadata';
-
-export const MIDDLEWARE_METADATA = 'middleware:metadata';
-
-export function Middleware(...middlewares: Function[]): ClassDecorator | MethodDecorator {
-  return (target: any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => {
-    if (propertyKey) {
-      // Method-level middleware
-      const existing = Reflect.getOwnMetadata(MIDDLEWARE_METADATA, target.constructor, propertyKey) || [];
-      Reflect.defineMetadata(MIDDLEWARE_METADATA, [...existing, ...middlewares], target.constructor, propertyKey);
-    } else {
-      // Class-level middleware
-      const existing = Reflect.getOwnMetadata(MIDDLEWARE_METADATA, target) || [];
-      Reflect.defineMetadata(MIDDLEWARE_METADATA, [...existing, ...middlewares], target);
-    }
-  };
-}

package/src/core/decorators/route.decorator.ts

@@ -1,33 +0,0 @@
-
-import 'reflect-metadata';
-
-export const ROUTE_METADATA = 'route:metadata';
-
-export enum HttpMethod {
-  GET = 'get',
-  POST = 'post',
-  PUT = 'put',
-  DELETE = 'delete',
-  PATCH = 'patch'
-}
-
-function createRouteDecorator(method: HttpMethod) {
-  return (path: string = ''): MethodDecorator => {
-    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-      const routes = Reflect.getOwnMetadata(ROUTE_METADATA, target.constructor) || [];
-      routes.push({
-        method,
-        path,
-        handlerName: propertyKey
-      });
-      Reflect.defineMetadata(ROUTE_METADATA, routes, target.constructor);
-      return descriptor;
-    };
-  };
-}
-
-export const Get = createRouteDecorator(HttpMethod.GET);
-export const Post = createRouteDecorator(HttpMethod.POST);
-export const Put = createRouteDecorator(HttpMethod.PUT);
-export const Delete = createRouteDecorator(HttpMethod.DELETE);
-export const Patch = createRouteDecorator(HttpMethod.PATCH);

package/src/core/openai/openai-client.ts

@@ -1,99 +0,0 @@
-import { Injectable } from "../decorators/injectable.decorator";
-import { ConfigLoader } from "../config/config-loader";
-
-@Injectable()
-export class OpenAIClient {
-  private apiKey: string;
-  private model: string;
-  private baseURL: string = "https://api.openai.com/v1";
-
-  constructor() {
-    const config = ConfigLoader.get();
-    this.apiKey = config.openai.apiKey;
-    this.model = config.openai.model;
-  }
-
-  async complete(
-    prompt: string,
-    options?: {
-      model?: string;
-      maxTokens?: number;
-      temperature?: number;
-    }
-  ): Promise<string> {
-    const response = await fetch(`${this.baseURL}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify({
-        model: options?.model || this.model,
-        messages: [{ role: "user", content: prompt }],
-        max_tokens: options?.maxTokens || 1000,
-        temperature: options?.temperature || 0.7,
-      }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`OpenAI API error: ${response.statusText}`);
-    }
-
-    const data = (await response.json()) as any;
-    return data.choices[0].message.content;
-  }
-
-  async streamComplete(
-    prompt: string,
-    onChunk: (chunk: string) => void
-  ): Promise<void> {
-    const response = await fetch(`${this.baseURL}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify({
-        model: this.model,
-        messages: [{ role: "user", content: prompt }],
-        stream: true,
-      }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`OpenAI API error: ${response.statusText}`);
-    }
-
-    const reader = response.body?.getReader();
-    const decoder = new TextDecoder();
-
-    if (!reader) {
-      throw new Error("No response body");
-    }
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      const chunk = decoder.decode(value);
-      const lines = chunk.split("\n").filter((line) => line.trim() !== "");
-
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6);
-          if (data === "[DONE]") continue;
-
-          try {
-            const parsed = JSON.parse(data);
-            const content = parsed.choices[0]?.delta?.content;
-            if (content) {
-              onChunk(content);
-            }
-          } catch (e) {
-            // Skip invalid JSON
-          }
-        }
-      }
-    }
-  }
-}

package/src/database/data-source.ts

@@ -1,29 +0,0 @@
-
-import { DataSource } from 'typeorm';
-import { ConfigLoader } from '../core/config/config-loader';
-import { User } from '../entities/user.entity';
-import { Session } from '../entities/session.entity';
-
-let AppDataSource: DataSource;
-
-export function initializeDataSource(): DataSource {
-  const config = ConfigLoader.get();
-
-  AppDataSource = new DataSource({
-    type: config.database.type as any,
-    host: config.database.host,
-    port: config.database.port,
-    username: config.database.username,
-    password: config.database.password,
-    database: config.database.database,
-    synchronize: config.database.synchronize,
-    logging: config.database.logging,
-    entities: [User, Session],
-    migrations: [],
-    subscribers: []
-  });
-
-  return AppDataSource;
-}
-
-export { AppDataSource };

package/src/entities/session.entity.ts

@@ -1,25 +0,0 @@
-
-import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn, CreateDateColumn } from 'typeorm';
-import { User } from './user.entity';
-
-@Entity('sessions')
-export class Session {
-  @PrimaryGeneratedColumn()
-  id!: number;
-
-  @Column({ unique: true, length: 255 })
-  token!: string;
-
-  @Column()
-  userId!: number;
-
-  @ManyToOne(() => User, (user) => user.sessions, { onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'userId' })
-  user!: User;
-
-  @Column()
-  expiresAt!: Date;
-
-  @CreateDateColumn()
-  createdAt!: Date;
-}

package/src/entities/user.entity.ts

@@ -1,27 +0,0 @@
-
-import { Entity, PrimaryGeneratedColumn, Column, OneToMany, CreateDateColumn, UpdateDateColumn } from 'typeorm';
-import { Session } from './session.entity';
-
-@Entity('users')
-export class User {
-  @PrimaryGeneratedColumn()
-  id!: number;
-
-  @Column({ length: 100 })
-  name!: string;
-
-  @Column({ unique: true, length: 255 })
-  email!: string;
-
-  @Column({ length: 255 })
-  passwordHash!: string;
-
-  @OneToMany(() => Session, (session) => session.user)
-  sessions!: Session[];
-
-  @CreateDateColumn()
-  createdAt!: Date;
-
-  @UpdateDateColumn()
-  updatedAt!: Date;
-}

package/src/middlewares/logging.middleware.ts

@@ -1,28 +0,0 @@
-
-import { Request, Response, NextFunction } from 'express';
-import pino from 'pino';
-
-const logger = pino({
-  transport: {
-    target: 'pino-pretty',
-    options: {
-      colorize: true
-    }
-  }
-});
-
-export function loggingMiddleware(req: Request, res: Response, next: NextFunction) {
-  const start = Date.now();
-
-  res.on('finish', () => {
-    const duration = Date.now() - start;
-    logger.info({
-      method: req.method,
-      url: req.url,
-      status: res.statusCode,
-      duration: `${duration}ms`
-    });
-  });
-
-  next();
-}

package/src/repositories/session.repository.ts

@@ -1,42 +0,0 @@
-
-import { Repository as TypeORMRepository, MoreThan } from 'typeorm';
-import { Repository } from '../core/decorators/repository.decorator';
-import { Session } from '../entities/session.entity';
-import { AppDataSource } from '../database/data-source';
-
-@Repository()
-export class SessionRepository {
-  private repository: TypeORMRepository<Session>;
-
-  constructor() {
-    this.repository = AppDataSource.getRepository(Session);
-  }
-
-  async findByToken(token: string): Promise<Session | null> {
-    return await this.repository.findOne({
-      where: { 
-        token,
-        expiresAt: MoreThan(new Date())
-      },
-      relations: ['user']
-    });
-  }
-
-  async create(sessionData: Partial<Session>): Promise<Session> {
-    const session = this.repository.create(sessionData);
-    return await this.repository.save(session);
-  }
-
-  async deleteByToken(token: string): Promise<boolean> {
-    const result = await this.repository.delete({ token });
-    return result.affected ? result.affected > 0 : false;
-  }
-
-  async deleteExpired(): Promise<void> {
-    await this.repository
-      .createQueryBuilder()
-      .delete()
-      .where('expiresAt < :now', { now: new Date() })
-      .execute();
-  }
-}

package/src/repositories/user.repository.ts

@@ -1,37 +0,0 @@
-
-import { Repository as TypeORMRepository } from 'typeorm';
-import { Repository } from '../core/decorators/repository.decorator';
-import { User } from '../entities/user.entity';
-import { AppDataSource } from '../database/data-source';
-
-@Repository()
-export class UserRepository {
-  private repository: TypeORMRepository<User>;
-
-  constructor() {
-    this.repository = AppDataSource.getRepository(User);
-  }
-
-  async findById(id: number): Promise<User | null> {
-    return await this.repository.findOne({ where: { id } });
-  }
-
-  async findByEmail(email: string): Promise<User | null> {
-    return await this.repository.findOne({ where: { email } });
-  }
-
-  async create(userData: Partial<User>): Promise<User> {
-    const user = this.repository.create(userData);
-    return await this.repository.save(user);
-  }
-
-  async update(id: number, userData: Partial<User>): Promise<User | null> {
-    await this.repository.update(id, userData);
-    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/src/server.ts

@@ -1,32 +0,0 @@
-
-import { FragmentApplication } from './app';
-import { ConfigLoader } from './core/config/config-loader';
-
-async function bootstrap() {
-  try {
-    const app = new FragmentApplication();
-    await app.initialize();
-
-    const config = ConfigLoader.get();
-    const port = config.app.port;
-
-    app.getExpressApp().listen(port, () => {
-      console.log(`
-╔═══════════════════════════════════════════════════╗
-║                                                   ║
-║      🔷 FRAGMENT Framework Started               ║
-║                                                   ║
-║      Port: ${port}                                  ║
-║      Environment: ${config.app.env}                  ║
-║      Database: Connected                         ║
-║                                                   ║
-╚═══════════════════════════════════════════════════╝
-      `);
-    });
-  } catch (error) {
-    console.error('❌ Failed to start application:', error);
-    process.exit(1);
-  }
-}
-
-bootstrap();

package/src/services/health.service.ts

@@ -1,29 +0,0 @@
-
-import { Service } from '../core/decorators/service.decorator';
-import { Autowire } from '../core/decorators/autowire.decorator';
-import { OpenAIClient } from '../core/openai/openai-client';
-
-@Service()
-export class HealthService {
-  constructor(
-    @Autowire() private openAIClient: OpenAIClient
-  ) {}
-
-  async getStatus(): Promise<{ status: string; timestamp: string; database: string }> {
-    return {
-      status: 'ok',
-      timestamp: new Date().toISOString(),
-      database: 'connected'
-    };
-  }
-
-  async generateHealthTip(): Promise<{ tip: string }> {
-    const prompt = 'Give me a short health tip in one sentence.';
-    const tip = await this.openAIClient.complete(prompt, {
-      maxTokens: 50,
-      temperature: 0.9
-    });
-
-    return { tip };
-  }
-}