@fastify/reply-from 7.0.0

package/test/index.test-d.ts

@@ -0,0 +1,136 @@
+import replyFrom, { FastifyReplyFromOptions } from "../";
+import fastify, {FastifyReply, RawServerBase} from "fastify";
+import { AddressInfo } from "net";
+import { IncomingHttpHeaders } from "http2";
+import { expectType } from 'tsd';
+import * as http from 'http';
+import * as https from 'https';
+import * as http2 from 'http2';
+// @ts-ignore
+import tap from 'tap'
+
+const fullOptions: FastifyReplyFromOptions = {
+  base: "http://example2.com",
+  http: {
+    agentOptions: {
+      keepAliveMsecs: 60 * 1000,
+      maxFreeSockets: 2048,
+      maxSockets: 2048
+    },
+    requestOptions: {
+      timeout: 1000
+    },
+    agents: {
+      'http:': new http.Agent({}),
+      'https:': new https.Agent({})
+    }
+  },
+  http2: {
+    sessionTimeout: 1000,
+    requestTimeout: 1000,
+    sessionOptions: {
+      rejectUnauthorized: true
+    },
+    requestOptions: {
+      endStream: true
+    }
+  },
+  cacheURLs: 100,
+  disableCache: false,
+  undici: {
+    connections: 100,
+    pipelining: 10
+  },
+  contentTypesToEncode: ['application/x-www-form-urlencoded'],
+  retryMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
+  maxRetriesOn503: 10,
+};
+tap.autoend(false);
+
+async function main() {
+  const server = fastify();
+
+  server.register(replyFrom);
+
+  server.register(replyFrom, {});
+
+  server.register(replyFrom, {http2: true});
+
+  server.register(replyFrom, fullOptions);
+
+  server.get("/v1", (request, reply) => {
+      reply.from();
+  });
+  server.get("/v3", (request, reply) => {
+      reply.from("/v3", {
+          body: {hello: "world"},
+          rewriteRequestHeaders(req, headers) {
+              expectType<http.IncomingMessage | http2.Http2ServerRequest>(req);
+              return headers;
+          },
+          getUpstream(req, base) {
+              expectType<http.IncomingMessage | http2.Http2ServerRequest>(req);
+              return base;
+          }
+      });
+  });
+
+// http2
+  const instance = fastify({http2: true});
+  // @ts-ignore
+  tap.tearDown(instance.close.bind(instance));
+  const target = fastify({http2: true});
+  // @ts-ignore
+  tap.tearDown(target.close.bind(target));
+  instance.get("/", (request, reply) => {
+      reply.from();
+  });
+
+  instance.get("/http2", (request, reply) => {
+      reply.from("/", {
+          rewriteHeaders(headers, req) {
+              return headers;
+          },
+          rewriteRequestHeaders(req, headers: IncomingHttpHeaders) {
+              return headers;
+          },
+          getUpstream(req, base) {
+              return base;
+          },
+          onError(reply: FastifyReply<RawServerBase>, error) {
+              return reply.send(error.error);
+          }
+      });
+  });
+
+  await target.listen(0);
+  const port = (target.server.address() as AddressInfo).port;
+  instance.register(replyFrom, {
+      base: `http://localhost:${port}`,
+      http2: {
+        sessionOptions: {
+          rejectUnauthorized: false,
+        },
+      },
+  });
+  instance.register(replyFrom, {
+    base: `http://localhost:${port}`,
+    http2: true,
+});
+  await instance.listen(0);
+
+  const undiciInstance = fastify();
+  undiciInstance.register(replyFrom, {
+    base: "http://example2.com",
+    undici: {
+      pipelining: 10,
+      connections: 10
+    }
+  });
+  await undiciInstance.ready();
+
+  tap.pass('done');
+  tap.end();
+}
+
+main();

package/test/modifyCoreObjects-false.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify({ modifyCoreObjects: false })
+
+t.plan(10)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  t.equal(req.url, '/')
+  res.statusCode = 205
+  res.setHeader('Content-Type', 'text/plain')
+  res.setHeader('x-my-header', 'hello!')
+  res.end('hello world')
+})
+
+instance.get('/', (request, reply) => {
+  reply.from()
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, (err) => {
+  t.error(err)
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`
+  })
+
+  instance.listen(0, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'text/plain')
+      t.equal(res.headers['x-my-header'], 'hello!')
+      t.equal(res.statusCode, 205)
+      t.equal(data.toString(), 'hello world')
+    })
+  })
+})

package/test/no-body-opts-with-get.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+
+t.plan(6)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.fail('this should never get called')
+  res.end('hello world')
+})
+
+instance.get('/', (request, reply) => {
+  try {
+    reply.from(null, { body: 'this is the new body' })
+  } catch (e) {
+    t.equal(e.message, 'Rewriting the body when doing a GET is not allowed')
+    reply.send('hello world')
+  }
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, (err) => {
+  t.error(err)
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`
+  })
+
+  instance.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'GET'
+    }, (err, res, data) => {
+      t.error(err)
+      t.equal(res.statusCode, 200)
+      t.equal(data.toString(), 'hello world')
+    })
+  })
+})

package/test/no-body-opts-with-head.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+
+t.plan(7)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.fail('this should never get called')
+  res.end('hello world')
+})
+
+instance.head('/', (request, reply) => {
+  try {
+    reply.from(null, { body: 'this is the new body' })
+  } catch (e) {
+    t.equal(e.message, 'Rewriting the body when doing a HEAD is not allowed')
+    reply.header('x-http-error', '1')
+    reply.send('hello world')
+  }
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, (err) => {
+  t.error(err)
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`
+  })
+
+  instance.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'HEAD'
+    }, (err, res, data) => {
+      t.error(err)
+      t.equal(res.statusCode, 200)
+      t.equal(res.headers['x-http-error'], '1')
+      t.equal(data.toString(), '')
+    })
+  })
+})

package/test/no-stream-body-option.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+const Readable = require('stream').Readable
+
+const instance = Fastify()
+instance.register(From)
+
+t.plan(5)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.fail('the target server should never be called')
+  res.end()
+})
+
+instance.post('/', (request, reply) => {
+  const body = new Readable({
+    read: function () {
+      t.fail('the read function should never be called')
+    }
+  })
+
+  t.throws(() => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      body
+    })
+  })
+
+  // return a 500
+  reply.code(500).send({ an: 'error' })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      json: true,
+      body: {
+        hello: 'world'
+      }
+    }, (err, res) => {
+      t.error(err)
+      t.equal(res.statusCode, 500)
+    })
+  })
+})

package/test/on-error.js

@@ -0,0 +1,62 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+const FakeTimers = require('@sinonjs/fake-timers')
+
+const clock = FakeTimers.createClock()
+
+t.autoend(false)
+
+const target = Fastify()
+t.teardown(target.close.bind(target))
+
+target.get('/', (request, reply) => {
+  t.pass('request arrives')
+
+  clock.setTimeout(() => {
+    reply.status(200).send('hello world')
+    t.end()
+  }, 1000)
+})
+
+async function main () {
+  await target.listen(0)
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, { http: { requestOptions: { timeout: 100 } } })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`,
+      {
+        onError: (reply, { error }) => {
+          t.equal(error.status, 504)
+          reply.code(error.status).send(error)
+        }
+      })
+  })
+
+  await instance.listen(0)
+
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
+  } catch (err) {
+    t.equal(err.response.statusCode, 504)
+    t.match(err.response.headers['content-type'], /application\/json/)
+    t.same(JSON.parse(err.response.body), {
+      statusCode: 504,
+      error: 'Gateway Timeout',
+      message: 'Gateway Timeout'
+    })
+    clock.tick(1000)
+    return
+  }
+
+  t.fail()
+}
+
+main()

package/test/onResponse.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+instance.register(From)
+
+t.plan(8)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  res.statusCode = 200
+  res.end('hello world')
+})
+
+instance.get('/', (request1, reply) => {
+  reply.from(`http://localhost:${target.address().port}`, {
+    onResponse: (request2, reply, res) => {
+      t.equal(request1.raw, request2.raw)
+      reply.send(res)
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get(
+      `http://localhost:${instance.server.address().port}`,
+      (err, res, data) => {
+        t.error(err)
+        t.equal(res.statusCode, 200)
+        t.equal(data.toString(), 'hello world')
+      }
+    )
+  })
+})

package/test/padded-body.js

@@ -0,0 +1,64 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+instance.register(From)
+
+t.plan(9)
+t.teardown(instance.close.bind(instance))
+
+const bodyString = `{
+  "hello": "world"
+}`
+
+const parsedLength = Buffer.byteLength(JSON.stringify(JSON.parse(bodyString)))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'POST')
+  t.equal(req.headers['content-type'], 'application/json')
+  t.same(req.headers['content-length'], parsedLength)
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    t.same(JSON.parse(data), { hello: 'world' })
+    res.statusCode = 200
+    res.setHeader('content-type', 'application/json')
+    res.end(JSON.stringify({ something: 'else' }))
+  })
+})
+
+instance.post('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`)
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: bodyString
+    }, (err, res, data) => {
+      t.error(err)
+      const parsed = JSON.parse(data)
+      t.same(parsed, { something: 'else' })
+    })
+  })
+})

package/test/post-formbody.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+instance.register(From, {
+  contentTypesToEncode: ['application/x-www-form-urlencoded']
+})
+instance.register(require('fastify-formbody'))
+
+t.plan(9)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'POST')
+  t.equal(req.headers['content-type'], 'application/x-www-form-urlencoded')
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    const str = data.toString()
+    t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+    res.statusCode = 200
+    res.setHeader('content-type', 'application/x-www-form-urlencoded')
+    res.end(str)
+  })
+})
+
+instance.post('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`)
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      headers: { 'content-type': 'application/x-www-form-urlencoded' },
+      body: 'some=info&another=detail'
+    }, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'application/x-www-form-urlencoded')
+      t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+    })
+  })
+})

package/test/post-plain-text.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+instance.register(From)
+
+t.plan(9)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'POST')
+  t.equal(req.headers['content-type'], 'text/plain')
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    const str = data.toString()
+    t.same(str, 'this is plain text')
+    res.statusCode = 200
+    res.setHeader('content-type', 'text/plain')
+    res.end(str)
+  })
+})
+
+instance.post('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`)
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      headers: { 'content-type': 'text/plain' },
+      body: 'this is plain text'
+    }, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'text/plain')
+      t.same(data.toString(), 'this is plain text')
+    })
+  })
+})

package/test/post-with-custom-encoded-contenttype.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+const { parse } = require('querystring')
+
+const instance = Fastify()
+instance.register(From, {
+  contentTypesToEncode: ['application/x-www-form-urlencoded']
+})
+
+instance.addContentTypeParser(
+  'application/x-www-form-urlencoded',
+  { parseAs: 'buffer', bodyLimit: 1000 },
+  (req, body, done) => done(null, parse(body.toString()))
+)
+
+t.plan(9)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'POST')
+  t.equal(req.headers['content-type'], 'application/x-www-form-urlencoded')
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    const str = data.toString()
+    t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+    res.statusCode = 200
+    res.setHeader('content-type', 'application/x-www-form-urlencoded')
+    res.end(str)
+  })
+})
+
+instance.post('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`)
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      headers: { 'content-type': 'application/x-www-form-urlencoded' },
+      body: 'some=info&another=detail'
+    }, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'application/x-www-form-urlencoded')
+      t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+    })
+  })
+})