@fastify/reply-from 12.0.2 → 12.2.0

package/test/unix-http.test.js

@@ -1,17 +1,12 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
 const fs = require('node:fs')
 const querystring = require('node:querystring')
 const http = require('node:http')
-const get = require('simple-get').concat
-
-if (process.platform === 'win32') {
-  t.pass()
-  process.exit(0)
-}
 
 const socketPath = `${__filename}.socket`
 const upstream = `unix+http://${querystring.escape(socketPath)}/`
@@ -24,42 +19,39 @@ instance.register(From, {
   base: upstream
 })
 
-t.plan(10)
-t.teardown(instance.close.bind(instance))
-
-try {
-  fs.unlinkSync(socketPath)
-} catch (_) {
-}
+t.test('unix http', { skip: process.platform === 'win32' }, async (t) => {
+  t.plan(7)
+  t.after(() => instance.close())
+
+  try {
+    fs.unlinkSync(socketPath)
+  } catch (_) {
+  }
+
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/hello')
+    res.statusCode = 205
+    res.setHeader('Content-Type', 'text/plain')
+    res.setHeader('x-my-header', 'hello!')
+    res.end('hello world')
+  })
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/hello')
-  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('hello')
+  })
 
-instance.get('/', (_request, reply) => {
-  reply.from('hello')
-})
+  t.after(() => target.close())
 
-t.teardown(target.close.bind(target))
+  await instance.listen({ port: 0 })
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await new Promise(resolve => target.listen(socketPath, resolve))
 
-  target.listen(socketPath, (err) => {
-    t.error(err)
+  const result = await request(`http://localhost:${instance.server.address().port}`)
 
-    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')
-    })
-  })
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+  t.assert.strictEqual(result.statusCode, 205)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })

package/test/unix-https-undici.test.js

@@ -1,11 +1,11 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
 const From = require('..')
 const https = require('node:https')
-const get = require('simple-get').concat
 const fs = require('node:fs')
+const { request, Agent } = require('undici')
 const querystring = require('node:querystring')
 const path = require('node:path')
 const certs = {
@@ -13,11 +13,6 @@ const certs = {
   cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
 }
 
-if (process.platform === 'win32') {
-  t.pass()
-  process.exit(0)
-}
-
 const socketPath = `${__filename}.socket`
 
 try {
@@ -32,40 +27,40 @@ instance.register(From, {
   base: `unix+https://${querystring.escape(socketPath)}`
 })
 
-t.plan(10)
-t.teardown(instance.close.bind(instance))
+t.test('unix https undici', { skip: process.platform === 'win32' }, async (t) => {
+  t.plan(7)
+  t.after(() => instance.close())
 
-const target = https.createServer(certs, (req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/hello')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+  const target = https.createServer(certs, (req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/hello')
+    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('hello')
-})
+  instance.get('/', (_request, reply) => {
+    reply.from('hello')
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await instance.listen({ port: 0 })
 
-  target.listen(socketPath, (err) => {
-    t.error(err)
+  await new Promise(resolve => target.listen(socketPath, resolve))
 
-    get({
-      url: `https://localhost:${instance.server.address().port}`,
-      rejectUnauthorized: false
-    }, (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')
+  const result = await request(`https://localhost:${instance.server.address().port}`, {
+    dispatcher: new Agent({
+      connect: {
+        rejectUnauthorized: false
+      }
     })
   })
+
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+  t.assert.strictEqual(result.statusCode, 205)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })

package/test/unix-https.test.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
 const From = require('..')
 const https = require('node:https')
-const get = require('simple-get').concat
+const { request, Agent } = require('undici')
 const fs = require('node:fs')
 const querystring = require('node:querystring')
 const path = require('node:path')
@@ -13,11 +13,6 @@ const certs = {
   cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
 }
 
-if (process.platform === 'win32') {
-  t.pass()
-  process.exit(0)
-}
-
 const instance = Fastify({
   https: certs
 })
@@ -25,47 +20,47 @@ instance.register(From, {
   http: true
 })
 
-t.plan(10)
-t.teardown(instance.close.bind(instance))
+t.test('unix https', { skip: process.platform === 'win32' }, async (t) => {
+  t.plan(7)
+  t.after(() => instance.close())
 
-const socketPath = `${__filename}.socket`
+  const socketPath = `${__filename}.socket`
 
-try {
-  fs.unlinkSync(socketPath)
-} catch (_) {
-}
+  try {
+    fs.unlinkSync(socketPath)
+  } catch (_) {
+  }
 
-const target = https.createServer(certs, (req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/hello')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+  const target = https.createServer(certs, (req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/hello')
+    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(`unix+https://${querystring.escape(socketPath)}/hello`)
-})
+  instance.get('/', (_request, reply) => {
+    reply.from(`unix+https://${querystring.escape(socketPath)}/hello`)
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await instance.listen({ port: 0 })
 
-  target.listen(socketPath, (err) => {
-    t.error(err)
+  await new Promise(resolve => target.listen(socketPath, resolve))
 
-    get({
-      url: `https://localhost:${instance.server.address().port}`,
-      rejectUnauthorized: false
-    }, (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')
+  const result = await request(`https://localhost:${instance.server.address().port}`, {
+    dispatcher: new Agent({
+      connect: {
+        rejectUnauthorized: false
+      }
     })
   })
+
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+  t.assert.strictEqual(result.statusCode, 205)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })

package/types/index.d.ts

@@ -15,19 +15,20 @@ import {
   Agent,
   AgentOptions,
   IncomingHttpHeaders,
+  IncomingMessage,
   RequestOptions,
-} from 'http'
+} from 'node:http'
 import {
   ClientSessionOptions,
   ClientSessionRequestOptions,
   IncomingHttpHeaders as Http2IncomingHttpHeaders,
   SecureClientSessionOptions,
-} from 'http2'
+} from 'node:http2'
 import {
   Agent as SecureAgent,
   AgentOptions as SecureAgentOptions,
   RequestOptions as SecureRequestOptions
-} from 'https'
+} from 'node:https'
 import { Pool, ProxyAgent, Dispatcher } from 'undici'
 
 declare module 'fastify' {
@@ -55,6 +56,11 @@ declare namespace fastifyReplyFrom {
     retriesCount: number;
     getDefaultDelay: () => number | null;
   }
+
+  export type RawServerResponse<T extends RawServerBase> = RawReplyDefaultExpression<T> & {
+    stream: IncomingMessage
+  }
+
   export interface FastifyReplyFromHooks {
     queryString?: { [key: string]: unknown } | QueryStringFunction;
     contentType?: string;
@@ -63,7 +69,7 @@ declare namespace fastifyReplyFrom {
     onResponse?: (
       request: FastifyRequest<RequestGenericInterface, RawServerBase>,
       reply: FastifyReply<RouteGenericInterface, RawServerBase>,
-      res: RawReplyDefaultExpression<RawServerBase>
+      res: RawServerResponse<RawServerBase>
     ) => void;
     onError?: (
       reply: FastifyReply<RouteGenericInterface, RawServerBase>,
@@ -83,6 +89,7 @@ declare namespace fastifyReplyFrom {
       base: string
     ) => string;
     method?: HTTPMethods;
+    timeout?: number;
   }
 
   interface Http2Options {
@@ -99,12 +106,13 @@ declare namespace fastifyReplyFrom {
   }
 
   export interface FastifyReplyFromOptions {
-    base?: string;
+    base?: string | string[];
     cacheURLs?: number;
     disableCache?: boolean;
     http?: HttpOptions;
     http2?: Http2Options | boolean;
     undici?: Pool.Options & { proxy?: string | URL | ProxyAgent.Options } | { request: Dispatcher['request'] };
+    balancedPoolOptions?: Pool.Options & Record<string, unknown>;
     contentTypesToEncode?: string[];
     retryMethods?: (HTTPMethods | 'TRACE')[];
     maxRetriesOn503?: number;

package/types/index.test-d.ts

@@ -1,11 +1,11 @@
-import fastify, { FastifyReply, FastifyRequest, RawReplyDefaultExpression, RawServerBase, RequestGenericInterface, RouteGenericInterface } from 'fastify'
+import fastify, { FastifyReply, FastifyRequest, RawServerBase, RequestGenericInterface, RouteGenericInterface } from 'fastify'
 import * as http from 'node:http'
-import { IncomingHttpHeaders } from 'http2'
+import { IncomingHttpHeaders } from 'node:http2'
 import * as https from 'node:https'
-import { AddressInfo } from 'net'
+import { AddressInfo } from 'node:net'
 import { expectType } from 'tsd'
 import { Agent, Client, Dispatcher, Pool } from 'undici'
-import replyFrom, { FastifyReplyFromOptions } from '..'
+import replyFrom, { FastifyReplyFromOptions, RawServerResponse } from '..'
 // @ts-ignore
 import tap from 'tap'
 
@@ -70,6 +70,7 @@ async function main () {
   })
   server.get('/v3', (_request, reply) => {
     reply.from('/v3', {
+      timeout: 1000,
       body: { hello: 'world' },
       rewriteRequestHeaders (req, headers) {
         expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(req)
@@ -82,7 +83,7 @@ async function main () {
       onResponse (request, reply, res) {
         expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(request)
         expectType<FastifyReply<RouteGenericInterface, RawServerBase>>(reply)
-        expectType<RawReplyDefaultExpression<RawServerBase>>(res)
+        expectType<RawServerResponse<RawServerBase>>(res)
         expectType<number>(res.statusCode)
       }
     })
@@ -102,7 +103,6 @@ async function main () {
   instance.get('/http2', (_request, reply) => {
     reply.from('/', {
       method: 'POST',
-      // eslint-disable-next-line n/handle-callback-err -- Not a real request, not handling errors
       retryDelay: ({ req, res, getDefaultDelay }) => {
         const defaultDelay = getDefaultDelay()
         if (defaultDelay) return defaultDelay

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

@@ -1,55 +0,0 @@
-'use strict'
-
-const t = require('tap')
-const Fastify = require('fastify')
-const From = require('..')
-const http = require('node:http')
-const get = require('simple-get').concat
-
-const instance = Fastify()
-
-t.plan(11)
-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, '/')
-  t.equal(req.body, undefined)
-  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({ port: 0 }, (err) => {
-  t.error(err)
-
-  instance.register(From, {
-    base: `http://localhost:${target.address().port}`,
-    // Use node core HTTP, Undici requires spec compliance
-    http: {}
-  })
-
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
-
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'GET',
-      body: 'this is get body'
-    }, (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/head-with-body.test.js

@@ -1,57 +0,0 @@
-'use strict'
-
-const t = require('tap')
-const Fastify = require('fastify')
-const From = require('..')
-const http = require('node:http')
-const get = require('simple-get').concat
-
-const instance = Fastify()
-
-t.plan(13)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'HEAD')
-  t.equal(req.url, '/')
-  t.equal(req.headers['content-length'], '16')
-  t.equal(req.body, undefined)
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
-
-instance.head('/', (_request, reply) => {
-  t.pass('head received')
-  reply.from()
-})
-
-t.teardown(target.close.bind(target))
-
-target.listen({ port: 0 }, (err) => {
-  t.error(err)
-
-  instance.register(From, {
-    base: `http://localhost:${target.address().port}`,
-    // Use node core HTTP, Undici requires spec compliance
-    http: {}
-  })
-
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
-
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'HEAD',
-      body: 'this is get body'
-    }, (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(), '')
-    })
-  })
-})