@fastify/reply-from 8.3.0 → 8.3.1

package/.taprc

@@ -1,8 +1,11 @@
 ts: false
 jsx: false
 flow: false
-coverage: true
-check-coverage: false
+
+functions: 97
+lines: 96
+statements: 96
+branches: 96
 
 files:
   - test/**/*.js

package/README.md

@@ -203,8 +203,7 @@ This only applies when a custom [`body`](#body) is not passed in. Defaults to:
 
 ```js
 [ 
-  'application/json',
-  'application/x-www-form-urlencoded'
+  'application/json'
 ]
 ```
 

package/index.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const fp = require('fastify-plugin')
-const lru = require('tiny-lru')
+const { lru } = require('tiny-lru')
 const querystring = require('fast-querystring')
 const Stream = require('stream')
 const buildRequest = require('./lib/request')
@@ -21,7 +21,7 @@ const {
   InternalServerError
 } = require('./lib/errors')
 
-module.exports = fp(function from (fastify, opts, next) {
+const fastifyReplyFrom = fp(function from (fastify, opts, next) {
   const contentTypesToEncode = new Set([
     'application/json',
     ...(opts.contentTypesToEncode || [])
@@ -33,12 +33,17 @@ module.exports = fp(function from (fastify, opts, next) {
 
   const cache = opts.disableCache ? undefined : lru(opts.cacheURLs || 100)
   const base = opts.base
-  const { request, close, retryOnError } = buildRequest({
+  const requestBuilt = buildRequest({
     http: opts.http,
     http2: opts.http2,
     base,
     undici: opts.undici
   })
+  if (requestBuilt instanceof Error) {
+    next(requestBuilt)
+    return
+  }
+  const { request, close, retryOnError } = requestBuilt
   const disableRequestLogging = opts.disableRequestLogging || false
 
   fastify.decorateReply('from', function (source, opts) {
@@ -60,8 +65,9 @@ module.exports = fp(function from (fastify, opts, next) {
     const dest = getUpstream(req, base)
     let url
     if (cache) {
-      url = cache.get(source) || buildURL(source, dest)
-      cache.set(source, url)
+      const cacheKey = dest + source
+      url = cache.get(cacheKey) || buildURL(source, dest)
+      cache.set(cacheKey, url)
     } else {
       url = buildURL(source, dest)
     }
@@ -274,3 +280,7 @@ function createRequestRetry (requestImpl, reply, retriesCount, retryOnError, max
 
   return requestRetry
 }
+
+module.exports = fastifyReplyFrom
+module.exports.default = fastifyReplyFrom
+module.exports.fastifyReplyFrom = fastifyReplyFrom

package/lib/request.js

@@ -47,9 +47,9 @@ function buildRequest (opts) {
   let agents
 
   if (isHttp2) {
-    if (!opts.base) throw new Error('Option base is required when http2 is true')
+    if (!opts.base) return new Error('Option base is required when http2 is true')
     if (opts.base.startsWith('unix+')) {
-      throw new Error('Unix socket destination is not supported when http2 is true')
+      return new Error('Unix socket destination is not supported when http2 is true')
     }
   } else {
     agents = httpOpts.agents || {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "8.3.0",
+  "version": "8.3.1",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -31,7 +31,7 @@
     "@fastify/formbody": "^7.0.1",
     "@fastify/multipart": "^7.1.0",
     "@fastify/pre-commit": "^2.0.2",
-    "@sinonjs/fake-timers": "^9.1.2",
+    "@sinonjs/fake-timers": "^10.0.0",
     "@types/node": "^18.0.0",
     "@types/tap": "^15.0.7",
     "fastify": "^4.0.2",
@@ -46,7 +46,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.2.0",
-    "tsd": "^0.23.0"
+    "tsd": "^0.24.1"
   },
   "dependencies": {
     "@fastify/error": "^3.0.0",
@@ -54,7 +54,7 @@
     "fast-querystring": "^1.0.0",
     "fastify-plugin": "^4.0.0",
     "pump": "^3.0.0",
-    "tiny-lru": "^8.0.2",
+    "tiny-lru": "^10.0.0",
     "undici": "^5.5.1"
   },
   "pre-commit": [

package/test/get-upstream-cache.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+
+async function createTarget (i) {
+  const target = Fastify({
+    keepAliveTimeout: 1
+  })
+
+  target.get('/test', async () => {
+    return `Hello from target ${i}`
+  })
+
+  t.teardown(() => target.close())
+  await target.listen({ port: 3000 + i })
+}
+
+t.plan(4)
+
+async function run () {
+  await Promise.all([
+    createTarget(1),
+    createTarget(2)
+  ])
+
+  const instance = Fastify({
+    keepAliveTimeout: 1
+  })
+
+  instance.register(From, {
+    base: 'http://localhost',
+    http: true
+  })
+
+  instance.get('/', (req, reply) => {
+    const hostNumber = parseInt(req.headers['x-host-number'])
+    const port = 3000 + hostNumber
+
+    reply.from('/test', {
+      getUpstream () {
+        return `http://localhost:${port}`
+      }
+    })
+  })
+
+  t.teardown(() => instance.close())
+  await instance.listen({ port: 3000 })
+
+  const res1 = await instance.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'x-host-number': 1
+    }
+  })
+  t.equal(res1.statusCode, 200)
+  t.equal(res1.body, 'Hello from target 1')
+
+  const res2 = await instance.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'x-host-number': 2
+    }
+  })
+  t.equal(res2.statusCode, 200)
+  t.equal(res2.body, 'Hello from target 2')
+}
+
+run()

package/test/http2-invalid-base.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('../index')
+
+test('http2 invalid base', async (t) => {
+  const instance = Fastify()
+
+  await t.rejects(instance.register(From, {
+    http2: { requestTimeout: 100 }
+  }), new Error('Option base is required when http2 is true'))
+})

package/test/http2-unix-socket.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('../index')
+
+test('throw an error if http2 is used with a Unix socket destination', async t => {
+  t.plan(1)
+
+  const instance = Fastify()
+
+  await t.rejects(instance.register(From, {
+    base: 'unix+http://localhost:1337',
+    http2: { requestTimeout: 100 }
+  }), new Error('Unix socket destination is not supported when http2 is true'))
+})

package/test/post-with-octet-stream.js

@@ -0,0 +1,131 @@
+'use strict'
+
+const test = require('tap').test
+const Fastify = require('fastify')
+const From = require('../index')
+const http = require('http')
+const get = require('simple-get').concat
+const { parse } = require('querystring')
+
+test('with explicitly set content-type application/octet-stream', t => {
+  const instance = Fastify()
+  instance.register(From, {
+    contentTypesToEncode: ['application/octet-stream']
+  })
+
+  instance.addContentTypeParser(
+    'application/octet-stream',
+    { 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/octet-stream')
+    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/octet-stream')
+      res.end(str)
+    })
+  })
+
+  instance.post('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`)
+  })
+
+  t.teardown(target.close.bind(target))
+
+  instance.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    target.listen({ port: 0 }, (err) => {
+      t.error(err)
+
+      get({
+        url: `http://localhost:${instance.server.address().port}`,
+        method: 'POST',
+        headers: { 'content-type': 'application/octet-stream' },
+        body: 'some=info&another=detail'
+      }, (err, res, data) => {
+        t.error(err)
+        t.equal(res.headers['content-type'], 'application/octet-stream')
+        t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+      })
+    })
+  })
+})
+
+test('with implicit content-type application/octet-stream', t => {
+  const instance = Fastify()
+  instance.register(From, {
+    contentTypesToEncode: ['application/octet-stream']
+  })
+
+  instance.addContentTypeParser(
+    'application/octet-stream',
+    { parseAs: 'buffer', bodyLimit: 1000 },
+    (req, body, done) => done(null, parse(body.toString()))
+  )
+
+  instance.addContentTypeParser(
+    '*',
+    { 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/octet-stream')
+    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/octet-stream')
+      res.end(str)
+    })
+  })
+
+  instance.post('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`)
+  })
+
+  t.teardown(target.close.bind(target))
+
+  instance.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    target.listen({ port: 0 }, (err) => {
+      t.error(err)
+
+      get({
+        url: `http://localhost:${instance.server.address().port}`,
+        method: 'POST',
+        body: 'some=info&another=detail'
+      }, (err, res, data) => {
+        t.error(err)
+        t.equal(res.headers['content-type'], 'application/octet-stream')
+        t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+      })
+    })
+  })
+})

package/test/utils-filter-pseudo-headers.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const test = require('tap').test
+const filterPseudoHeaders = require('../lib/utils').filterPseudoHeaders
+
+test('filterPseudoHeaders', t => {
+  t.plan(1)
+  const headers = {
+    accept: '*/*',
+    'Content-Type': 'text/html; charset=UTF-8',
+    ':method': 'GET'
+  }
+
+  t.strictSame(filterPseudoHeaders(headers), {
+    accept: '*/*',
+    'content-type': 'text/html; charset=UTF-8'
+  })
+})

package/types/index.d.ts

@@ -30,68 +30,76 @@ import {
   SecureClientSessionOptions,
 } from "http2";
 import { Pool } from 'undici'
-type QueryStringFunction = (search: string | undefined, reqUrl: string) => string;
-export interface FastifyReplyFromHooks {
-  queryString?: { [key: string]: unknown } | QueryStringFunction;
-  contentType?: string;
-  onResponse?: (
-    request: FastifyRequest<RequestGenericInterface, RawServerBase>,
-    reply: FastifyReply<RawServerBase>,
-    res: RawReplyDefaultExpression<RawServerBase>
-  ) => void;
-  onError?: (
-      reply: FastifyReply<RawServerBase>,
-      error: { error: Error }
-  ) => void;
-  body?: unknown;
-  rewriteHeaders?: (
-    headers: Http2IncomingHttpHeaders | IncomingHttpHeaders,
-    req?: Http2ServerRequest | IncomingMessage
-  ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
-  rewriteRequestHeaders?: (
-    req: Http2ServerRequest | IncomingMessage,
-    headers: Http2IncomingHttpHeaders | IncomingHttpHeaders
-  ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
-  getUpstream?: (
-      req: Http2ServerRequest | IncomingMessage,
-      base: string
-  ) => string;
-}
 
 declare module "fastify" {
   interface FastifyReply {
     from(
       source?: string,
-      opts?: FastifyReplyFromHooks
-    ): void;
+      opts?: fastifyReplyFrom.FastifyReplyFromHooks
+    ): this;
   }
 }
 
-interface Http2Options {
-  sessionTimeout?: number;
-  requestTimeout?: number;
-  sessionOptions?: ClientSessionOptions | SecureClientSessionOptions;
-  requestOptions?: ClientSessionRequestOptions;
-}
+type FastifyReplyFrom = FastifyPluginCallback<fastifyReplyFrom.FastifyReplyFromOptions>
 
-interface HttpOptions {
-  agentOptions?: AgentOptions | SecureAgentOptions;
-  requestOptions?: RequestOptions | SecureRequestOptions;
-  agents?: { 'http:': Agent, 'https:': SecureAgent }
-}
+declare namespace fastifyReplyFrom {
+  type QueryStringFunction = (search: string | undefined, reqUrl: string) => string;
+  export interface FastifyReplyFromHooks {
+    queryString?: { [key: string]: unknown } | QueryStringFunction;
+    contentType?: string;
+    onResponse?: (
+      request: FastifyRequest<RequestGenericInterface, RawServerBase>,
+      reply: FastifyReply<RawServerBase>,
+      res: RawReplyDefaultExpression<RawServerBase>
+    ) => void;
+    onError?: (
+      reply: FastifyReply<RawServerBase>,
+      error: { error: Error }
+    ) => void;
+    body?: unknown;
+    rewriteHeaders?: (
+      headers: Http2IncomingHttpHeaders | IncomingHttpHeaders,
+      req?: Http2ServerRequest | IncomingMessage
+    ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
+    rewriteRequestHeaders?: (
+      req: Http2ServerRequest | IncomingMessage,
+      headers: Http2IncomingHttpHeaders | IncomingHttpHeaders
+    ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
+    getUpstream?: (
+      req: Http2ServerRequest | IncomingMessage,
+      base: string
+    ) => string;
+  }
+
+  interface Http2Options {
+    sessionTimeout?: number;
+    requestTimeout?: number;
+    sessionOptions?: ClientSessionOptions | SecureClientSessionOptions;
+    requestOptions?: ClientSessionRequestOptions;
+  }
+
+  interface HttpOptions {
+    agentOptions?: AgentOptions | SecureAgentOptions;
+    requestOptions?: RequestOptions | SecureRequestOptions;
+    agents?: { 'http:': Agent, 'https:': SecureAgent }
+  }
+
+  export interface FastifyReplyFromOptions {
+    base?: string;
+    cacheURLs?: number;
+    disableCache?: boolean;
+    http?: HttpOptions;
+    http2?: Http2Options | boolean;
+    undici?: Pool.Options;
+    contentTypesToEncode?: string[];
+    retryMethods?: (HTTPMethods | 'TRACE')[];
+    maxRetriesOn503?: number;
+    disableRequestLogging?: boolean;
+  }
 
-export interface FastifyReplyFromOptions {
-  base?: string;
-  cacheURLs?: number;
-  disableCache?: boolean;
-  http?: HttpOptions;
-  http2?: Http2Options | boolean;
-  undici?: Pool.Options;
-  contentTypesToEncode?: string[];
-  retryMethods?: (HTTPMethods | 'TRACE')[];
-  maxRetriesOn503?: number;
-  disableRequestLogging?: boolean;
+  export const fastifyReplyFrom: FastifyReplyFrom
+  export { fastifyReplyFrom as default }
 }
 
-declare const fastifyReplyFrom: FastifyPluginCallback<FastifyReplyFromOptions>;
-export default fastifyReplyFrom;
+declare function fastifyReplyFrom(...params: Parameters<FastifyReplyFrom>): ReturnType<FastifyReplyFrom>
+export = fastifyReplyFrom

package/types/index.test-d.ts

@@ -60,7 +60,7 @@ async function main() {
   server.register(replyFrom, fullOptions);
 
   server.get("/v1", (request, reply) => {
-      reply.from();
+      expectType<FastifyReply>(reply.from());
   });
   server.get("/v3", (request, reply) => {
       reply.from("/v3", {