fragment-ts 1.0.0

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

@@ -0,0 +1,42 @@
+
+export function serviceTemplate(name: string): string {
+  const className = name.endsWith('Service') ? name : `${name}Service`;
+  const repoName = name.replace('Service', '') + 'Repository';
+  
+  return `import { Service } from '../core/decorators/service.decorator';
+import { Autowire } from '../core/decorators/autowire.decorator';
+import { ${repoName} } from '../repositories/${name.toLowerCase()}.repository';
+
+@Service()
+export class ${className} {
+  constructor(
+    @Autowire() private ${repoName.charAt(0).toLowerCase() + repoName.slice(1)}: ${repoName}
+  ) {}
+
+  async findAll() {
+    // Implement business logic
+    return [];
+  }
+
+  async findById(id: number) {
+    // Implement business logic
+    return null;
+  }
+
+  async create(data: any) {
+    // Implement business logic
+    return data;
+  }
+
+  async update(id: number, data: any) {
+    // Implement business logic
+    return data;
+  }
+
+  async delete(id: number) {
+    // Implement business logic
+    return true;
+  }
+}
+`;
+}

package/src/cli/utils/file-generator.ts

@@ -0,0 +1,37 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export class FileGenerator {
+  static createDirectory(dirPath: string): void {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+
+  static writeFile(filePath: string, content: string): void {
+    const dir = path.dirname(filePath);
+    this.createDirectory(dir);
+    fs.writeFileSync(filePath, content, 'utf-8');
+  }
+
+  static fileExists(filePath: string): boolean {
+    return fs.existsSync(filePath);
+  }
+
+  static readFile(filePath: string): string {
+    return fs.readFileSync(filePath, 'utf-8');
+  }
+
+  static toCamelCase(str: string): string {
+    return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+  }
+
+  static toPascalCase(str: string): string {
+    const camel = this.toCamelCase(str);
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
+  }
+
+  static toKebabCase(str: string): string {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+  }
+}

package/src/cli/utils/logger.ts

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

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

@@ -0,0 +1,98 @@
+
+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/container/di-container.ts

@@ -0,0 +1,43 @@
+
+import 'reflect-metadata';
+import { AUTOWIRE_METADATA } from '../decorators/autowire.decorator';
+
+export class DIContainer {
+  private static instances = new Map<any, any>();
+  private static classes = new Set<any>();
+
+  static register(target: any): void {
+    this.classes.add(target);
+  }
+
+  static resolve<T>(target: any): T {
+    // Return existing singleton if available
+    if (this.instances.has(target)) {
+      return this.instances.get(target);
+    }
+
+    // Get constructor parameter metadata
+    const params = Reflect.getOwnMetadata(AUTOWIRE_METADATA, target) || [];
+    const sortedParams = params.sort((a: any, b: any) => a.index - b.index);
+
+    // Resolve dependencies recursively
+    const dependencies = sortedParams.map((param: any) => {
+      return this.resolve(param.type);
+    });
+
+    // Create instance
+    const instance = new target(...dependencies);
+    this.instances.set(target, instance);
+
+    return instance;
+  }
+
+  static getRegisteredClasses(): any[] {
+    return Array.from(this.classes);
+  }
+
+  static clear(): void {
+    this.instances.clear();
+    this.classes.clear();
+  }
+}

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

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

@@ -0,0 +1,18 @@
+
+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/controller.decorator.ts

@@ -0,0 +1,15 @@
+
+import 'reflect-metadata';
+import { DIContainer } from '../container/di-container';
+
+export const CONTROLLER_METADATA = 'controller:metadata';
+export const CONTROLLER_PATH = 'controller:path';
+
+export function Controller(path: string = ''): ClassDecorator {
+  return (target: any) => {
+    Reflect.defineMetadata(CONTROLLER_METADATA, true, target);
+    Reflect.defineMetadata(CONTROLLER_PATH, path, target);
+    DIContainer.register(target);
+    return target;
+  };
+}

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

@@ -0,0 +1,13 @@
+
+import 'reflect-metadata';
+import { DIContainer } from '../container/di-container';
+
+export const INJECTABLE_METADATA = 'injectable:metadata';
+
+export function Injectable(): ClassDecorator {
+  return (target: any) => {
+    Reflect.defineMetadata(INJECTABLE_METADATA, true, target);
+    DIContainer.register(target);
+    return target;
+  };
+}

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

@@ -0,0 +1,18 @@
+
+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/repository.decorator.ts

@@ -0,0 +1,6 @@
+
+import { Injectable } from './injectable.decorator';
+
+export function Repository(): ClassDecorator {
+  return Injectable();
+}

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

@@ -0,0 +1,33 @@
+
+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/decorators/service.decorator.ts

@@ -0,0 +1,6 @@
+
+import { Injectable } from './injectable.decorator';
+
+export function Service(): ClassDecorator {
+  return Injectable();
+}

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+
+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();
+  }
+}