blank/server.js

import 'dotenv/config'
import fs from 'node:fs/promises';
import { URL } from 'node:url';
import { Transform } from 'node:stream';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { Hono } from 'hono';
import { cors } from 'hono/cors'
import { logger } from 'hono/logger';
import { createServer as createNodeServer } from 'node:http';
import process from 'node:process';
import { createAdaptorServer } from '@hono/node-server'
// 新增：导入 Socket.IO
import { Server } from 'socket.io';

// 创建 Hono 应用
const app = new Hono();

// 全局使用 Hono 日志中间件（记录所有请求）
app.use('*', logger());
app.use('*', cors(
  // {
  //   origin: ['http://localhost:3000'],
  //   allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  //   credentials: true
  // }
))

// 常量定义
const isProduction = process.env.NODE_ENV === 'production';
const port = process.env.PORT || 8080;
const base = process.env.BASE || '/';
const ABORT_DELAY = 10000;

console.log('========================================');
console.log('开始初始化服务器...');
console.log(`环境: ${isProduction ? '生产环境' : '开发环境'}`);
console.log(`端口: ${port}`);
console.log(`基础路径: ${base}`);
console.log('========================================');

// 解析基础路径为 URL 对象
const baseUrl = new URL(base, `http://localhost:${port}`);
console.log(`基础URL解析完成: ${baseUrl.href}`);

// 创建服务器实例
console.log('正在创建服务器实例...');
const parentServer = createAdaptorServer({
  fetch: app.fetch,
  createServer: createNodeServer,
  port: port,
})
console.log('服务器实例创建成功');

// 新增：初始化 Socket.IO 服务器
console.log('正在初始化 Socket.IO 服务器...');
const io = new Server(parentServer, {
  // // 配置 CORS，根据实际需求调整
  // cors: {
  //   origin: isProduction ? process.env.FRONTEND_URL || false : "http://localhost:8080",
  //   methods: ["GET", "POST"],
  //   credentials: true
  // },
  // // 路径配置，避免与其他路由冲突
  // path: `${base}socket.io`
});
console.log('Socket.IO 服务器初始化完成');

// 生产环境中间件
let compressionMiddleware;
let sirvMiddleware;
if (isProduction) {
  console.log('生产环境: 加载压缩和静态文件中间件...');
  compressionMiddleware = (await import('compression')).default();
  sirvMiddleware = (await import('sirv')).default('./dist/client', { 
    extensions: [],
    baseUrl: base 
  });
  console.log('生产环境中间件加载完成');
}

// Vite 开发服务器
/** @type {import('vite').ViteDevServer | undefined} */
let vite;
if (!isProduction) {
  console.log('开发环境: 初始化 Vite 开发服务器...');
  const { createServer } = await import('vite');
  vite = await createServer({
    server: { 
      middlewareMode: {
        server: parentServer
      },
      hmr: {  
        port: 8081,
        clientPort: 443,
        path: 'vite-hmr'
      },
      proxy: {
        '/vite-hmr': {
          target: 'ws://localhost:8081',
          ws: true,
        },
      },
    },
    appType: 'custom',
    base,
  });
  console.log('Vite 开发服务器初始化完成');
}


// 开发环境模板处理函数 - 仅处理模板转换
const processDevTemplate = async (template) => {
  if (!isProduction && vite) {
    console.log('开发环境: 处理模板...');
    const processedTemplate = await vite.transformIndexHtml('/', template);
    console.log('开发环境模板处理完成');
    return processedTemplate;
  }
  return template;
};

// 新增：加载 Socket.IO 中间件和路由
if (!isProduction) {
  console.log('开发环境: 从 Vite 加载 Socket.IO 路由和中间件...');
  try {
    const apiModule = await vite.ssrLoadModule('./src/server/index.tsx');
    
    // 应用认证中间件
    if (apiModule.socketAuthMiddleware) {
      console.log('应用 Socket.IO 认证中间件');
      io.use(apiModule.socketAuthMiddleware);
    }
    
    // 应用路由
    if (apiModule.socketHandler) {
      console.log('注册 Socket.IO 路由处理');
      apiModule.socketHandler(io);
    }
    console.log('Socket.IO 路由和中间件加载完成');
  } catch (err) {
    console.error('开发环境加载 Socket.IO 模块失败:', err);
  }
} else {
  console.log('生产环境: 加载编译后的 Socket.IO 路由和中间件...');
  try {
    const apiModule = (await import('./dist/server/index.js'));
    
    // 应用认证中间件
    if (apiModule.socketAuthMiddleware) {
      console.log('应用 Socket.IO 认证中间件');
      io.use(apiModule.socketAuthMiddleware);
    }
    
    // 应用路由
    if (apiModule.socketHandler) {
      console.log('注册 Socket.IO 路由处理');
      apiModule.socketHandler(io);
    }
    console.log('Socket.IO 路由和中间件加载完成');
  } catch (err) {
    console.error('加载 Socket.IO 模块失败:', err);
  }
}

// 生产环境模板处理函数 - 仅处理资源路径替换
const processProdTemplate = async (template) => {
  console.log('生产环境: 处理模板资源路径...');
  try {
    // 读取 manifest
    const manifestPath = new URL('./dist/client/.vite/manifest.json', import.meta.url);
    const manifestContent = await fs.readFile(manifestPath, 'utf-8');
    const manifest = JSON.parse(manifestContent);
    console.log('生产环境: 成功读取 manifest.json');

    // 获取 src/client/index.tsx 对应的资源信息
    const indexManifest = manifest['src/client/index.tsx'];
    if (!indexManifest) {
      throw new Error('manifest 中未找到 src/client/index.tsx 入口配置');
    }

    // 获取 src/style.css 对应的资源信息
    const styleManifest = manifest['src/style.css'];
    if (!styleManifest) {
      throw new Error('manifest 中未找到 src/style.css 入口配置');
    }

    const cssPath = new URL(styleManifest.file, baseUrl).pathname;
    const cssLinks = `<link href="${cssPath}" rel="stylesheet" />`;

    // 替换入口脚本
    const jsEntryPath = new URL(indexManifest.file, baseUrl).pathname;
    const entryScript = `<script type="module" src="${jsEntryPath}"></script>`;

    // 执行替换
    const processedTemplate = template
      .replace(/<link href="\/src\/style.css" rel="stylesheet"\/>/, cssLinks)
      .replace(/<script type="module" src="\/src\/client\/index.tsx"><\/script>/, entryScript);

    console.log('生产环境模板处理完成');
    return processedTemplate;

  } catch (err) {
    console.error('生产环境模板处理失败:', err);
    throw err;
  }
};

// SSR 渲染中间件函数
const createSsrHandler = (template, render, normalizedUrl) => {
  return async (c) => {
    let didError = false;
    let abortController;

    // 创建一个可读流用于 SSR 渲染内容
    const [htmlStart, htmlEnd] = template.split(`<!--app-html-->`);
    const ssrStream = new Readable({ read: () => {} });

    // 写入 HTML 头部
    ssrStream.push(htmlStart);

    // 设置响应头和状态码
    c.header('Content-Type', 'text/html');

    // 处理渲染
    const { pipe, abort } = render(normalizedUrl, {
      onShellError() {
        didError = true;
        c.status(500);
        ssrStream.push('<h1>服务器渲染出错</h1>');
        ssrStream.push(null); // 结束流
      },
      onShellReady() {
        console.log(`开始渲染页面: ${normalizedUrl}`);
        // 将渲染结果通过管道传入 ssrStream
        const transformStream = new Transform({
          transform(chunk, encoding, callback) {
            ssrStream.push(chunk, encoding);
            callback();
          }
        });

        pipe(transformStream);

        // 当 transformStream 完成时，添加 HTML 尾部
        transformStream.on('finish', () => {
          ssrStream.push(htmlEnd);
          ssrStream.push(null); // 结束流
          console.log(`页面渲染完成: ${normalizedUrl}`);
        });
      },
      onError(error) {
        didError = true;
        console.error('渲染过程出错:', error);
      },
    });

    // 设置超时中止
    abortController = new AbortController();
    const abortTimeout = setTimeout(() => {
      console.log(`渲染超时，终止请求: ${normalizedUrl}`);
      abort();
      abortController.abort();
    }, ABORT_DELAY);

    // 将流通过 Hono 响应返回
    return c.body(ssrStream, {
      onEnd: () => {
        clearTimeout(abortTimeout);
      }
    });
  };
};

// 统一的请求处理中间件 - 合并 API 和 SSR 渲染逻辑
app.use(async (c) => {
  try {
    // 使用 c.env 获取原生请求响应对象
    const req = c.env.incoming;
    const res = c.env.outgoing;
    const url = new URL(req.url, `http://${req.headers.host}`);
    const path = url.pathname;

    // 检查是否匹配基础路径
    if (!path.startsWith(baseUrl.pathname)) {
      return c.text('未找到', 404);
    }

    // 处理基础路径
    const normalizedUrl = path.replace(baseUrl.pathname, '/') || '/';
    console.log(`处理请求: ${normalizedUrl}`);

    // 开发环境：使用 Vite 中间件
    if (!isProduction && vite) {
      // 使用 Vite 中间件处理请求
      const handled = await new Promise((resolve) => {
        vite.middlewares(req, res, () => resolve(false));
      });
      
      // 如果 Vite 中间件已经处理了请求，直接返回
      if (handled) {
        return c.body;
      }


      // 动态加载最新 API 模块
      const apiModule = await vite.ssrLoadModule('./src/server/index.tsx');
      
      // 创建临时子应用并挂载路由
      const apiApp = new Hono();
      apiApp.route('/', apiModule.api);
      
      // 处理开发环境模板
      const template = await processDevTemplate(apiModule.template);
      apiApp.get('*', createSsrHandler(template, apiModule.render, normalizedUrl));

      // 直接由子应用处理 API 请求
      return apiApp.fetch(c.req.raw, {
        ...c.env,
        // 传递原始请求对象
        incoming: c.env.incoming,
        outgoing: c.env.outgoing
      });
    }
    // 生产环境：使用 compression 和 sirv 中间件
    else if (isProduction) {
      // 先尝试 compression 中间件
      const compressed = await new Promise((resolve) => {
        compressionMiddleware(req, res, () => resolve(false));
      });
      
      if (compressed) {
        return c.body;
      }
      
      // 再尝试 sirv 中间件处理静态文件
      const served = await new Promise((resolve) => {
        sirvMiddleware(req, res, () => resolve(false));
      });
      
      if (served) {
        return c.body;
      }

      // 生产环境：使用缓存的 API 路由
      const { api, template: rawTemplate, render } = (await import('./dist/server/index.js'));
      const apiApp = new Hono();
      apiApp.route('/', api);

      // 处理生产环境模板
      const template = await processProdTemplate(rawTemplate);
      apiApp.get('*', createSsrHandler(template, render, normalizedUrl));

      return apiApp.fetch(c.req.raw, {
        ...c.env,
        incoming: c.env.incoming,
        outgoing: c.env.outgoing
      });
    }

  } catch (e) {
    if (!isProduction && vite) {
      vite.ssrFixStacktrace(e);
      console.error('请求处理错误:', e.stack);
      return c.text(e.stack, 500);
    }
    console.error('请求处理错误:', e.stack);
    return c.text('服务器内部错误', 500);
  }
});

// 移除生产环境的 API 路由预加载（已在统一中间件中处理）
// 移除动态 API 路由中间件（已合并到统一中间件中）

// 启动服务器
console.log('准备启动服务器...');
parentServer.listen(port, () => {  
  console.log('========================================');
  console.log(`服务器已成功启动!`);
  console.log(`访问地址: http://localhost:${port}`);
  console.log(`Socket.IO 路径: ${base}socket.io`);
  console.log(`环境: ${isProduction ? '生产环境' : '开发环境'}`);
  console.log('========================================');
})

// 统一的服务器关闭处理函数
const shutdownServer = async () => {
  console.log('正在关闭服务器...');
  
  // 1. 先关闭 Vite 开发服务器（包括 HMR 服务）
  if (!isProduction && vite) {
    console.log('正在关闭 Vite 开发服务器（包括 HMR 服务）...');
    try {
      await vite.close();
      console.log('Vite 开发服务器已关闭');
    } catch (err) {
      console.error('关闭 Vite 服务器时出错:', err);
    }
  }
  
  // 2. 关闭主服务器
  parentServer.close((err) => {
    if (err) {
      console.error('关闭主服务器时出错:', err);
      process.exit(1);
    }
    console.log('主服务器已关闭');
    process.exit(0);
  });
};

// 处理进程终止信号
process.on('SIGINT', shutdownServer);
process.on('SIGTERM', shutdownServer);