fragment-ts 1.0.0 → 1.0.1

package/examples/ai-assistant/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "ai-assistant",
+  "version": "1.0.0",
+  "main": "dist/main.js",
+  "scripts": {
+    "start": "node dist/main.js",
+    "dev": "fragment serve",
+    "build": "fragment build",
+    "test": "fragment test"
+  },
+  "dependencies": {
+    "fragment": "^1.0.0",
+    "reflect-metadata": "^0.1.13"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}

package/examples/ai-assistant/src/controllers/app.controller.ts

@@ -0,0 +1,9 @@
+import { Controller, Get } from 'fragment';
+
+@Controller('/api')
+export class AppController {
+  @Get('/health')
+  health() {
+    return { status: 'who dey help', timestamp: new Date().toISOString() };
+  }
+}

package/examples/ai-assistant/src/controllers/chat.controller.ts

@@ -0,0 +1,69 @@
+import { Controller, Get, Post, Body, Param, Res } from "fragment";
+import { ConversationService } from "../services/conversation.service";
+import { Response } from "express";
+
+@Controller("/api/chat")
+export class ChatController {
+  constructor(private conversationService: ConversationService) {}
+
+  @Post("/conversations")
+  async createConversation(@Body() body: any) {
+    return this.conversationService.create(body.userId || 1, body.title);
+  }
+
+  @Get("/conversations/:userId")
+  async getConversations(@Param("userId") userId: string) {
+    return this.conversationService.findByUser(parseInt(userId));
+  }
+
+  @Get("/conversations/:id/messages")
+  async getMessages(@Param("id") id: string) {
+    return this.conversationService.getMessages(parseInt(id));
+  }
+
+  @Post("/conversations/:id/message")
+  async sendMessage(@Param("id") id: string, @Body() body: any) {
+    return this.conversationService.chat(parseInt(id), body.message);
+  }
+
+  @Post("/conversations/:id/stream")
+  async streamMessage(
+    @Param("id") id: string,
+    @Body() body: any,
+    @Res() res: Response,
+  ) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+
+    let fullResponse = "";
+
+    await this.conversationService.addMessage(
+      parseInt(id),
+      "user",
+      body.message,
+    );
+
+    const messages = await this.conversationService.getMessages(parseInt(id));
+    const aiMessages = messages.map((m: any) => ({
+      role: m.role as any,
+      content: m.content,
+    }));
+
+    const aiService = (this.conversationService as any).aiService;
+
+    await aiService.streamChat(aiMessages, (chunk: string) => {
+      fullResponse += chunk;
+      res.write(`data: ${JSON.stringify({ chunk })}\n\n`);
+    });
+
+    await this.conversationService.addMessage(
+      parseInt(id),
+      "assistant",
+      fullResponse,
+    );
+
+    res.write("data: [DONE]\n\n");
+    res.end();
+  }
+}

package/examples/ai-assistant/src/controllers/conversation.controller.ts

@@ -0,0 +1,29 @@
+import { Controller, Get, Post, Put, Delete, Body, Param } from 'fragment';
+
+@Controller('/conversation')
+export class ConversationController {
+  @Get()
+  findAll() {
+    return [];
+  }
+
+  @Get('/:id')
+  findOne(@Param('id') id: string) {
+    return { id };
+  }
+
+  @Post()
+  create(@Body() body: any) {
+    return body;
+  }
+
+  @Put('/:id')
+  update(@Param('id') id: string, @Body() body: any) {
+    return { id, ...body };
+  }
+
+  @Delete('/:id')
+  delete(@Param('id') id: string) {
+    return { deleted: true, id };
+  }
+}

package/examples/ai-assistant/src/controllers/message.controller.ts

@@ -0,0 +1,29 @@
+import { Controller, Get, Post, Put, Delete, Body, Param } from 'fragment';
+
+@Controller('/message')
+export class MessageController {
+  @Get()
+  findAll() {
+    return [];
+  }
+
+  @Get('/:id')
+  findOne(@Param('id') id: string) {
+    return { id };
+  }
+
+  @Post()
+  create(@Body() body: any) {
+    return body;
+  }
+
+  @Put('/:id')
+  update(@Param('id') id: string, @Body() body: any) {
+    return { id, ...body };
+  }
+
+  @Delete('/:id')
+  delete(@Param('id') id: string) {
+    return { deleted: true, id };
+  }
+}

package/examples/ai-assistant/src/controllers/search.controller.ts

@@ -0,0 +1,16 @@
+import { Controller, Post, Body, Query } from "fragment";
+import { ConversationService } from "../services/conversation.service";
+
+@Controller("/api/search")
+export class SearchController {
+  constructor(private conversationService: ConversationService) {}
+
+  @Post("/semantic")
+  async semanticSearch(
+    @Body() body: any,
+    @Query("conversationId") conversationId?: string,
+  ) {
+    const convId = conversationId ? parseInt(conversationId) : undefined;
+    return this.conversationService.semanticSearch(body.query, convId);
+  }
+}

package/examples/ai-assistant/src/dto/create-conversation.dto.ts

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class CreateConversationDto {
+  @IsString()
+  name!: string;
+}

package/examples/ai-assistant/src/dto/create-message.dto.ts

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class CreateMessageDto {
+  @IsString()
+  name!: string;
+}

package/examples/ai-assistant/src/entities/conversation.entity.ts

@@ -0,0 +1,23 @@
+import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';
+import { Message } from './message.entity';
+
+@Entity()
+export class Conversation {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column()
+  title!: string;
+
+  @Column()
+  userId!: number;
+
+  @OneToMany(() => Message, message => message.conversation)
+  messages!: Message[];
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  createdAt!: Date;
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  updatedAt!: Date;
+}

package/examples/ai-assistant/src/entities/message.entity.ts

@@ -0,0 +1,27 @@
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { Conversation } from './conversation.entity';
+
+@Entity()
+export class Message {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column()
+  conversationId!: number;
+
+  @ManyToOne(() => Conversation, conversation => conversation.messages)
+  @JoinColumn({ name: 'conversationId' })
+  conversation!: Conversation;
+
+  @Column()
+  role!: string;
+
+  @Column('text')
+  content!: string;
+
+  @Column('simple-json', { nullable: true })
+  embedding!: number[];
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  createdAt?: Date;
+}

package/examples/ai-assistant/src/entities/user.entity.ts

@@ -0,0 +1,16 @@
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+
+@Entity()
+export class User {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column()
+  email!: string;
+
+  @Column()
+  name!: string;
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  createdAt?: Date;
+}

package/examples/ai-assistant/src/main.ts

@@ -0,0 +1,15 @@
+import 'reflect-metadata';
+import { FragmentApplication } from 'fragment';
+import { FragmentWebApplication } from 'fragment';
+
+@FragmentApplication({
+  port: 3000,
+})
+class Application {}
+
+async function bootstrap() {
+  const app = new FragmentWebApplication();
+  await app.bootstrap(Application);
+}
+
+bootstrap();

package/examples/ai-assistant/src/migrations/1767738396740-CreateConversationTables.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner, Table } from "typeorm";
+
+export class CreateConversationTables1234567890 implements MigrationInterface {
+  async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(
+      new Table({
+        name: "conversation",
+        columns: [
+          { name: "id", type: "integer", isPrimary: true, isGenerated: true },
+          { name: "title", type: "varchar" },
+          { name: "userId", type: "integer" },
+          { name: "createdAt", type: "datetime", default: "CURRENT_TIMESTAMP" },
+          { name: "updatedAt", type: "datetime", default: "CURRENT_TIMESTAMP" },
+        ],
+      }),
+    );
+
+    await queryRunner.createTable(
+      new Table({
+        name: "message",
+        columns: [
+          { name: "id", type: "integer", isPrimary: true, isGenerated: true },
+          { name: "conversationId", type: "integer" },
+          { name: "role", type: "varchar" },
+          { name: "content", type: "text" },
+          { name: "embedding", type: "text", isNullable: true },
+          { name: "createdAt", type: "datetime", default: "CURRENT_TIMESTAMP" },
+        ],
+      }),
+    );
+  }
+
+  async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable("message");
+    await queryRunner.dropTable("conversation");
+  }
+}

package/examples/ai-assistant/src/repositories/conversation.repository.ts

@@ -0,0 +1,32 @@
+import { Repository } from "fragment";
+import { Conversation } from "../entities/conversation.entity";
+
+@Repository()
+export class ConversationRepository {
+  async findAll(): Promise<Conversation[]> {
+    return [];
+  }
+
+  async findById(id: number): Promise<Conversation | null> {
+    return null;
+  }
+
+  async create(data: Partial<Conversation>): Promise<Conversation> {
+    return data as Conversation;
+  }
+
+  async update(
+    id: number,
+    data: Partial<Conversation>,
+  ): Promise<Conversation | null> {
+    return null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    return true;
+  }
+
+  async findByUser(userId: number): Promise<Conversation[]> {
+    return [];
+  }
+}

package/examples/ai-assistant/src/repositories/message.repository.ts

@@ -0,0 +1,30 @@
+import { Repository } from "fragment";
+import { Message } from "../entities/message.entity";
+import { Conversation } from "../entities/conversation.entity";
+
+@Repository()
+export class MessageRepository {
+  async findAll(): Promise<Message[]> {
+    return [];
+  }
+
+  async findById(id: number): Promise<Message | null> {
+    return null;
+  }
+
+  async create(data: Partial<Message>): Promise<Message> {
+    return data as Message;
+  }
+
+  async update(id: number, data: Partial<Message>): Promise<Message | null> {
+    return null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    return true;
+  }
+
+  async findByConversation(conversationId: number): Promise<Conversation[]> {
+    return [];
+  }
+}

package/examples/ai-assistant/src/services/ai.service.ts

@@ -0,0 +1,41 @@
+import { Service } from 'fragment';
+import { AIModule } from 'fragment';
+
+@Service()
+export class AIService {
+  private aiModule: AIModule;
+
+  constructor() {
+    this.aiModule = new AIModule({
+      openaiKey: process.env.OPENAI_API_KEY,
+      ollamaUrl: process.env.OLLAMA_URL
+    });
+  }
+
+  async chat(messages: any[]) {
+    return this.aiModule.complete(messages, {
+      model: 'gpt-3.5-turbo',
+      temperature: 0.7,
+      maxTokens: 1000
+    });
+  }
+
+  async streamChat(messages: any[], onChunk: (chunk: string) => void) {
+    await this.aiModule.streamComplete(messages, {
+      model: 'gpt-3.5-turbo',
+      temperature: 0.7
+    }, onChunk);
+  }
+
+  async generateEmbedding(text: string): Promise<number[]> {
+    const embeddings = await this.aiModule.embeddings([text]);
+    return embeddings[0];
+  }
+
+  cosineSimilarity(a: number[], b: number[]): number {
+    const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
+    const magnitudeA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
+    const magnitudeB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
+    return dotProduct / (magnitudeA * magnitudeB);
+  }
+}

package/examples/ai-assistant/src/services/app.service.ts

@@ -0,0 +1,8 @@
+import { Service } from 'fragment';
+
+@Service()
+export class AppService {
+  getMessage(): string {
+    return 'Welcome to Fragment Framework!';
+  }
+}

package/examples/ai-assistant/src/services/conversation.service.ts

@@ -0,0 +1,75 @@
+import { Service } from "fragment";
+import { ConversationRepository } from "../repositories/conversation.repository";
+import { MessageRepository } from "../repositories/message.repository";
+import { AIService } from "./ai.service";
+
+@Service()
+export class ConversationService {
+  constructor(
+    private conversationRepository: ConversationRepository,
+    private messageRepository: MessageRepository,
+    private aiService: AIService,
+  ) {}
+
+  async create(userId: number, title: string) {
+    return this.conversationRepository.create({ userId, title });
+  }
+
+  async findByUser(userId: number) {
+    return this.conversationRepository.findByUser(userId);
+  }
+
+  async addMessage(conversationId: number, role: string, content: string) {
+    const embedding = await this.aiService.generateEmbedding(content);
+
+    return this.messageRepository.create({
+      conversationId,
+      role,
+      content,
+      embedding,
+    });
+  }
+
+  async getMessages(conversationId: number) {
+    return this.messageRepository.findByConversation(conversationId);
+  }
+
+  async chat(conversationId: number, userMessage: string) {
+    await this.addMessage(conversationId, "user", userMessage);
+
+    const messages = await this.getMessages(conversationId);
+    const aiMessages = messages.map((m:any) => ({
+      role: m.role as any,
+      content: m.content,
+    }));
+
+    const response = await this.aiService.chat(aiMessages);
+
+    await this.addMessage(conversationId, "assistant", response);
+
+    return { response };
+  }
+
+  async semanticSearch(query: string, conversationId?: number) {
+    const queryEmbedding = await this.aiService.generateEmbedding(query);
+
+    let messages = await this.messageRepository.findAll();
+
+    if (conversationId) {
+      messages = messages.filter((m) => m.conversationId === conversationId);
+    }
+
+    const results = messages
+      .map((message) => ({
+        message,
+        similarity: this.aiService.cosineSimilarity(
+          queryEmbedding,
+          message.embedding || [],
+        ),
+      }))
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, 5);
+
+    return results;
+  }
+}

package/examples/ai-assistant/src/services/message.service.ts

@@ -0,0 +1,27 @@
+import { Service } from 'fragment';
+import { MessageRepository } from '../repositories/message.repository';
+
+@Service()
+export class MessageService {
+  constructor(private messageRepository: MessageRepository) {}
+
+  async findAll() {
+    return [];
+  }
+
+  async findOne(id: string) {
+    return { id };
+  }
+
+  async create(data: any) {
+    return data;
+  }
+
+  async update(id: string, data: any) {
+    return { id, ...data };
+  }
+
+  async delete(id: string) {
+    return { deleted: true, id };
+  }
+}

package/examples/ai-assistant/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": [
+      "ES2020"
+    ],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/examples/blog-api/fragment.json

@@ -0,0 +1,18 @@
+{
+  "server": {
+    "port": 3000,
+    "host": "0.0.0.0"
+  },
+  "database": {
+    "type": "sqlite",
+    "database": "database.sqlite",
+    "synchronize": true,
+    "logging": false,
+    "entities": [
+      "dist/**/*.entity.js"
+    ],
+    "migrations": [
+      "dist/migrations/**/*.js"
+    ]
+  }
+}

package/examples/blog-api/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "blog-api",
+  "version": "1.0.0",
+  "main": "dist/main.js",
+  "scripts": {
+    "start": "node dist/main.js",
+    "dev": "fragment serve",
+    "build": "fragment build",
+    "test": "fragment test"
+  },
+  "dependencies": {
+    "fragment": "^1.0.0",
+    "reflect-metadata": "^0.1.13"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/node": "^20.10.5"
+  }
+}

package/examples/blog-api/src/controllers/app.controller.ts

@@ -0,0 +1,9 @@
+import { Controller, Get } from 'fragment';
+
+@Controller('/api')
+export class AppController {
+  @Get('/health')
+  health() {
+    return { status: 'ok', timestamp: new Date().toISOString() };
+  }
+}

package/examples/blog-api/src/controllers/auth.controller.ts

@@ -0,0 +1,17 @@
+import { Controller, Post, Body } from 'fragment';
+import { AuthService } from '../services/auth.service';
+
+@Controller('/auth')
+export class AuthController {
+  constructor(private authService: AuthService) {}
+
+  @Post('/login')
+  async login(@Body() body: any) {
+    return this.authService.login(body.email, body.password);
+  }
+
+  @Post('/register')
+  async register(@Body() body: any) {
+    return this.authService.register(body);
+  }
+}

package/examples/blog-api/src/controllers/category.controller.ts

@@ -0,0 +1,29 @@
+import { Controller, Get, Post, Put, Delete, Body, Param } from 'fragment';
+
+@Controller('/category')
+export class CategoryController {
+  @Get()
+  findAll() {
+    return [];
+  }
+
+  @Get('/:id')
+  findOne(@Param('id') id: string) {
+    return { id };
+  }
+
+  @Post()
+  create(@Body() body: any) {
+    return body;
+  }
+
+  @Put('/:id')
+  update(@Param('id') id: string, @Body() body: any) {
+    return { id, ...body };
+  }
+
+  @Delete('/:id')
+  delete(@Param('id') id: string) {
+    return { deleted: true, id };
+  }
+}