@fastify/reply-from 8.2.1 → 8.3.1

package/.github/workflows/ci.yml

@@ -15,3 +15,4 @@ jobs:
     uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
     with:
       license-check: true
+      lint: true

package/.taprc

@@ -1,5 +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

@@ -1,6 +1,6 @@
 # @fastify/reply-from
 
-![CI](https://github.com/fastify/fastify-reply-from/workflows/CI/badge.svg)
+[![CI](https://github.com/fastify/reply-fro/workflows/CI/badge.svg)](https://github.com/fastify/reply-fro/actions/workflows/ci.yml)
 [![NPM version](https://img.shields.io/npm/v/@fastify/reply-from.svg?style=flat)](https://www.npmjs.com/package/@fastify/reply-from)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
 
@@ -115,7 +115,7 @@ proxy.register(require('@fastify/reply-from'), {
 
 #### `http`
 
-Set the `http` option to `true` or to an Object to use 
+Set the `http` option to an Object to use 
 Node's [`http.request`](https://nodejs.org/api/http.html#http_http_request_options_callback)
 will be used if you do not enable [`http2`](#http2). To customize the `request`,
 you can pass in [`agentOptions`](https://nodejs.org/api/http.html#http_new_agent_options) and
@@ -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/{example.js → examples/example.js}

@@ -15,7 +15,7 @@ const proxy = Fastify({
 })
 
 // proxy.register(require('fastify-reply-from'), {
-proxy.register(require('.'), {
+proxy.register(require('..'), {
   base: 'http://localhost:3001/'
 })
 

package/index.js

@@ -1,8 +1,8 @@
 'use strict'
 
 const fp = require('fastify-plugin')
-const lru = require('tiny-lru')
-const querystring = require('querystring')
+const { lru } = require('tiny-lru')
+const querystring = require('fast-querystring')
 const Stream = require('stream')
 const buildRequest = require('./lib/request')
 const {
@@ -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

@@ -1,5 +1,4 @@
 'use strict'
-const semver = require('semver')
 const http = require('http')
 const https = require('https')
 const querystring = require('querystring')
@@ -48,12 +47,9 @@ function buildRequest (opts) {
   let agents
 
   if (isHttp2) {
-    if (semver.lt(process.version, '9.0.0')) {
-      throw new Error('Http2 support requires Node version >= 9.0.0')
-    }
-    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,15 +1,15 @@
 {
   "name": "@fastify/reply-from",
-  "version": "8.2.1",
+  "version": "8.3.1",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
-  "types": "index.d.ts",
+  "types": "types/index.d.ts",
   "scripts": {
-    "coverage": "tap -j8 test/*.js --cov --coverage-report=html",
+    "lint": "standard | snazzy",
     "lint:fix": "standard --fix",
-    "test": "standard | snazzy && tap test/*.js && npm run typescript",
-    "test:ci": "standard | snazzy && tap test/*.js --coverage-report=lcovonly && npm run typescript",
-    "typescript": "tsd"
+    "test": "npm run test:unit && npm run test:typescript",
+    "test:unit": "tap",
+    "test:typescript": "tsd"
   },
   "repository": {
     "type": "git",
@@ -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,21 +46,21 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.2.0",
-    "tsd": "^0.22.0",
-    "typescript": "^4.7.3"
+    "tsd": "^0.24.1"
   },
   "dependencies": {
     "@fastify/error": "^3.0.0",
     "end-of-stream": "^1.4.4",
+    "fast-querystring": "^1.0.0",
     "fastify-plugin": "^4.0.0",
     "pump": "^3.0.0",
-    "semver": "^7.3.7",
-    "tiny-lru": "^8.0.2",
+    "tiny-lru": "^10.0.0",
     "undici": "^5.5.1"
   },
-  "tsd": {
-    "directory": "test"
-  },
+  "pre-commit": [
+    "lint",
+    "test"
+  ],
   "publishConfig": {
     "access": "public"
   }

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

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+
+import {
+  FastifyRequest,
+  FastifyReply,
+  RawReplyDefaultExpression,
+  RawServerBase,
+  RequestGenericInterface,
+  HTTPMethods,
+  FastifyPluginCallback,
+} from 'fastify';
+
+import {
+  IncomingMessage,
+  IncomingHttpHeaders,
+  RequestOptions,
+  AgentOptions,
+  Agent,
+} from "http";
+import {
+  RequestOptions as SecureRequestOptions,
+  AgentOptions as SecureAgentOptions,
+  Agent as SecureAgent
+} from "https";
+import {
+  Http2ServerRequest,
+  IncomingHttpHeaders as Http2IncomingHttpHeaders,
+  ClientSessionRequestOptions,
+  ClientSessionOptions,
+  SecureClientSessionOptions,
+} from "http2";
+import { Pool } from 'undici'
+
+declare module "fastify" {
+  interface FastifyReply {
+    from(
+      source?: string,
+      opts?: fastifyReplyFrom.FastifyReplyFromHooks
+    ): this;
+  }
+}
+
+type FastifyReplyFrom = FastifyPluginCallback<fastifyReplyFrom.FastifyReplyFromOptions>
+
+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 const fastifyReplyFrom: FastifyReplyFrom
+  export { fastifyReplyFrom as default }
+}
+
+declare function fastifyReplyFrom(...params: Parameters<FastifyReplyFrom>): ReturnType<FastifyReplyFrom>
+export = fastifyReplyFrom

package/{test → types}/index.test-d.ts

@@ -1,4 +1,4 @@
-import replyFrom, { FastifyReplyFromOptions } from "../";
+import replyFrom, { FastifyReplyFromOptions } from "..";
 import fastify, {FastifyReply, RawServerBase} from "fastify";
 import { AddressInfo } from "net";
 import { IncomingHttpHeaders } from "http2";
@@ -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", {

package/index.d.ts

@@ -1,100 +0,0 @@
-/// <reference types="node" />
-
-import {
-  FastifyRequest,
-  FastifyReply,
-  RawReplyDefaultExpression,
-  RawServerBase,
-  RequestGenericInterface,
-  HTTPMethods,
-  FastifyPluginAsync,
-  FastifyPluginCallback,
-} from 'fastify';
-
-import {
-  IncomingMessage,
-  IncomingHttpHeaders,
-  RequestOptions,
-  AgentOptions,
-  Agent,
-} from "http";
-import {
-  RequestOptions as SecureRequestOptions,
-  AgentOptions as SecureAgentOptions,
-  Agent as SecureAgent
-} from "https";
-import {
-  Http2ServerRequest,
-  IncomingHttpHeaders as Http2IncomingHttpHeaders,
-  ClientSessionRequestOptions,
-  ClientSessionOptions,
-  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;
-  }
-}
-
-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;
-}
-
-declare const fastifyReplyFrom:
-  | FastifyPluginCallback<FastifyReplyFromOptions>
-  | FastifyPluginAsync<FastifyReplyFromOptions>;
-export default fastifyReplyFrom;