在Hapi项目中如何将Node原生请求响应对象转为Restify对象

我正在使用Hapi JS构建Web应用，其中用到的某个库依赖Restify版本的请求（request）和响应（response）对象，需将其作为参数传入该库的某一函数。我可通过request.raw获取Node原生请求响应对象，但Node原生req和res对象缺少Restify特有的特性，例如res.send、res.body等。另外，自行为Hapi重写请求对象的相关函数耗时极长，因为框架会在请求生命周期中跟踪服务器/应用实例并修改原生请求对象的原型实例。请问如何将Node原生req和res对象转换为Restify的req和res对象？

以下是几种可行的实现思路，可根据依赖库的实际需求选择：

1. 按需封装Restify核心特性到原生对象 #

不需要完全复刻Restify的所有功能，仅针对依赖库用到的属性/方法进行封装，适配Hapi的响应流程即可，这种方式最轻量化。

示例代码：

// 封装Restify风格的响应对象
function wrapRestifyResponse(rawRes, h) {
  // 添加res.body属性，关联Hapi的响应数据
  Object.defineProperty(rawRes, 'body', {
    get() {
      return h.response().source;
    },
    set(value) {
      h._restifyBody = value;
    },
    enumerable: true
  });

  // 实现res.send方法，映射到Hapi的响应工具
  rawRes.send = function(data, statusCode) {
    const responseData = data || h._restifyBody;
    let response = h.response(responseData);
    if (statusCode) {
      response.code(statusCode);
    }
    // 暂存响应对象，后续在Hapi路由中返回
    rawRes._hapiResponse = response;
    return response;
  };

  // 按需添加其他Restify特性，比如res.status等
  rawRes.status = function(code) {
    rawRes.statusCode = code;
    return rawRes;
  };

  return rawRes;
}

// 在Hapi路由中使用
app.route({
  method: 'POST',
  path: '/your-path',
  handler: (request, h) => {
    const rawReq = request.raw.req;
    const wrappedRes = wrapRestifyResponse(request.raw.res, h);
    
    // 传入依赖Restify的库函数
    yourRestifyDependentLibFunction(rawReq, wrappedRes);
    
    // 返回Hapi响应对象
    return wrappedRes._hapiResponse || h.response().code(200);
  }
});

2. 利用Restify构造函数初始化对象 #

Restify的请求/响应对象是基于Node原生对象扩展的，可以直接调用Restify的构造函数，传入原生对象并补充必要的服务器上下文。注意要匹配你使用的Restify版本的构造参数。

示例代码：

const restify = require('restify');

function convertToRestifyReqRes(rawReq, rawRes, hapiServer) {
  // 初始化Restify请求对象，补充必要的服务器配置
  const restifyReq = new restify.Request(rawReq, {
    server: {
      name: hapiServer.info.uri,
      version: '1.0.0',
      // 根据Restify版本需求补充其他属性
    }
  });
  // 同步Hapi的请求数据到Restify对象
  restifyReq.body = request.payload;
  restifyReq.query = request.query;
  restifyReq.params = request.params;

  // 初始化Restify响应对象
  const restifyRes = new restify.Response(rawRes, restifyReq);

  return { req: restifyReq, res: restifyRes };
}

// 在Hapi路由中使用
app.route({
  method: 'GET',
  path: '/api/{id}',
  handler: (request, h) => {
    const { req: restifyReq, res: restifyRes } = convertToRestifyReqRes(
      request.raw.req,
      request.raw.res,
      request.server
    );
    
    // 调用依赖库
    yourRestifyDependentLibFunction(restifyReq, restifyRes);
    
    // 基于Restify的响应状态返回Hapi响应
    return h.response().code(restifyRes.statusCode || 200);
  }
});

3. 内部反向代理到Restify服务 #

如果前两种方法存在兼容性问题，可以在Hapi应用内部启动一个小型Restify服务，将请求反向代理到该服务，让依赖库直接使用Restify原生的请求/响应对象。这种方法会有轻微性能损耗，但兼容性最好。

示例代码：

const restify = require('restify');
const httpProxy = require('http-proxy');

// 启动内部Restify服务
const internalRestifyServer = restify.createServer();
// 注册依赖库的处理逻辑
internalRestifyServer.use((req, res, next) => {
  yourRestifyDependentLibFunction(req, res);
  res.send(200);
  next();
});
internalRestifyServer.listen(3001, 'localhost');

// 创建代理实例
const proxy = httpProxy.createProxyServer({});

// Hapi路由中代理请求
app.route({
  method: '*',
  path: '/proxy/{param*}',
  handler: (request, h) => {
    return new Promise((resolve, reject) => {
      // 代理到内部Restify服务
      proxy.web(request.raw.req, request.raw.res, {
        target: 'http://localhost:3001'
      }, (err) => {
        reject(err);
      });
      // 监听响应完成事件，返回Hapi响应
      request.raw.res.on('finish', () => {
        resolve(h.response().code(request.raw.res.statusCode));
      });
    });
  }
});

内容的提问来源于stack exchange，提问作者Wai Yan Hein