migate function to framework

Author: tobenot

src/app.ts

@@ -4,9 +4,9 @@ import cors from '@fastify/cors';
 import * as jwt from 'jsonwebtoken';
 import { authRouter } from './routers/auth';
 import { userRouter } from './routers/user';
-import { announcementRouter } from './routers/announcement';
-import { corsDebugRouter } from './routers/cors-debug';
-import { echoRouter } from './routers/echo';
+import { announcementRouter } from './framework/routers/announcement';
+import { corsDebugRouter } from './framework/routers/cors-debug';
+import { echoRouter } from './framework/routers/echo';
 import { router } from './trpc';
 import { join } from 'path';
 import { corsPluginOptions, corsMiddleware } from './middleware';
@@ -89,7 +89,7 @@ export async function buildServer(): Promise<FastifyInstance> {
   });
 
   // Register OpenAI-compatible proxy routes (both /v1/... and /api/v1/... aliases)
-  server.register(require('./routers/llm-proxy').llmProxyRoutes);
+  server.register(require('./framework/routers/llm-proxy').llmProxyRoutes);
   server.register((instance: any, _opts: any, done: any) => {
     instance.post('/api/v1/chat/completions', (req: any, reply: any) => {
       // delegate to the main handler by internally calling the same logic

src/framework/routers/announcement.ts

@@ -0,0 +1,17 @@
+import { publicProcedure, router } from '../../trpc';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export const announcementRouter = router({
+	getAnnouncement: publicProcedure.query(async () => {
+		const announcementPath = path.join(process.cwd(), 'announcement.txt');
+		try {
+			const content = fs.readFileSync(announcementPath, 'utf-8');
+			return { announcement: content };
+		} catch (_error) {
+			return { announcement: '暂无公告' };
+		}
+	}),
+});
+
+

src/framework/routers/cors-debug.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { publicProcedure, router } from '../../trpc';
+import { getCorsConfig, isOriginAllowed } from '../../config/cors';
+
+export const corsDebugRouter = router({
+	getConfig: publicProcedure.query(() => {
+		const corsConfig = getCorsConfig();
+		return {
+			enabled: corsConfig.enabled,
+			origins: corsConfig.origins,
+			methods: corsConfig.methods,
+			allowedHeaders: corsConfig.allowedHeaders,
+			credentials: corsConfig.credentials,
+			maxAge: corsConfig.maxAge,
+			environment: process.env.NODE_ENV || 'development'
+		};
+	}),
+
+	testOrigin: publicProcedure
+		.input(z.object({ origin: z.string() }))
+		.query(({ input }) => {
+			const corsConfig = getCorsConfig();
+			const allowed = isOriginAllowed(input.origin, corsConfig);
+			return {
+				origin: input.origin,
+				allowed,
+				corsConfig: {
+					enabled: corsConfig.enabled,
+					origins: corsConfig.origins,
+					environment: process.env.NODE_ENV || 'development'
+				}
+			};
+		}),
+
+	testPreflight: publicProcedure
+		.input(z.object({
+			origin: z.string(),
+			method: z.string().optional(),
+			headers: z.array(z.string()).optional()
+		}))
+		.query(({ input }) => {
+			const corsConfig = getCorsConfig();
+			const originAllowed = isOriginAllowed(input.origin, corsConfig);
+			return {
+				origin: input.origin,
+				originAllowed,
+				method: input.method || 'GET',
+				headers: input.headers || [],
+				corsConfig: {
+					enabled: corsConfig.enabled,
+					methods: corsConfig.methods,
+					allowedHeaders: corsConfig.allowedHeaders,
+					credentials: corsConfig.credentials
+				}
+			};
+		}),
+
+	health: publicProcedure.query(() => {
+		return {
+			status: 'ok',
+			timestamp: new Date().toISOString(),
+			cors: {
+				enabled: getCorsConfig().enabled,
+				environment: process.env.NODE_ENV || 'development'
+			}
+		};
+	}),
+});
+
+

src/routers/echo.ts renamed to src/framework/routers/echo.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { publicProcedure, router } from '../trpc';
+import { publicProcedure, router } from '../../trpc';
 
 const inputSchema = z.object({
 	message: z.string().min(1).max(1000),

src/framework/routers/llm-proxy.ts

@@ -0,0 +1,61 @@
+import { FastifyInstance, FastifyPluginCallback } from 'fastify';
+import { LlmClient, ChatCompletionParams } from '../../utils/llm-client';
+
+export const llmProxyRoutes: FastifyPluginCallback = (server: FastifyInstance, _opts, done) => {
+	server.post('/v1/chat/completions', async (request, reply) => {
+		const body = request.body as ChatCompletionParams | undefined;
+		if (!body || !Array.isArray(body.messages) || !body.model) {
+			return reply.code(400).send({ error: 'Invalid request: model and messages are required.' });
+		}
+
+		const upstream = new LlmClient();
+
+		if (body.stream) {
+			reply.raw.setHeader('Content-Type', 'text/event-stream');
+			reply.raw.setHeader('Cache-Control', 'no-cache');
+			reply.raw.setHeader('Connection', 'keep-alive');
+
+			const abortController = new AbortController();
+			const onClose = () => { abortController.abort(); };
+			reply.raw.on('close', onClose);
+
+			try {
+				const upstreamRes = await upstream.fetchChatCompletionStream(body, abortController.signal);
+				if (!upstreamRes.ok || !upstreamRes.body) {
+					const text = await upstreamRes.text().catch(() => '');
+					reply.code(upstreamRes.status);
+					reply.raw.write(`: upstream error ${text}\n\n`);
+				} else {
+					const reader = upstreamRes.body.getReader();
+					const decoder = new TextDecoder();
+					while (true) {
+						const { value, done } = await reader.read();
+						if (done) break;
+						if (value) reply.raw.write(decoder.decode(value, { stream: true }));
+					}
+				}
+			} catch (err: any) {
+				try {
+					const message = typeof err?.message === 'string' ? err.message : 'Upstream error';
+					reply.raw.write(`: error ${message}\n\n`);
+				} catch {}
+			} finally {
+				reply.raw.off('close', onClose);
+				reply.raw.end();
+			}
+			return reply;
+		}
+
+		try {
+			const result = await upstream.createChatCompletion({ ...body, stream: false });
+			return reply.code(200).send(result);
+		} catch (err: any) {
+			const text = typeof err?.message === 'string' ? err.message : 'Upstream error';
+			return reply.code(500).send({ error: text });
+		}
+	});
+
+	done();
+};
+
+