@fastify/reply-from 10.0.0 → 11.0.0

package/types/index.test-d.ts

@@ -1,12 +1,12 @@
-import replyFrom, { FastifyReplyFromOptions } from "..";
-import fastify, {FastifyReply, FastifyRequest, RawServerBase, RequestGenericInterface} from "fastify";
-import { AddressInfo } from "net";
-import { IncomingHttpHeaders } from "http2";
-import { expectType } from 'tsd';
+import fastify, { FastifyReply, FastifyRequest, RawReplyDefaultExpression, RawServerBase, RequestGenericInterface, RouteGenericInterface } from "fastify";
 import * as http from 'http';
+import { IncomingHttpHeaders } from "http2";
 import * as https from 'https';
+import { AddressInfo } from "net";
+import { expectType } from 'tsd';
+import replyFrom, { FastifyReplyFromOptions } from "..";
 // @ts-ignore
-import tap from 'tap'
+import tap from 'tap';
 
 const fullOptions: FastifyReplyFromOptions = {
   base: "http://example2.com",
@@ -38,15 +38,16 @@ const fullOptions: FastifyReplyFromOptions = {
   disableCache: false,
   undici: {
     connections: 100,
-    pipelining: 10
+    pipelining: 10,
+    proxy: 'http://example2.com:8080'
   },
   contentTypesToEncode: ['application/x-www-form-urlencoded'],
   retryMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
   maxRetriesOn503: 10,
   disableRequestLogging: false,
   globalAgent: false,
+  destroyAgent: true
 };
-tap.autoend(false);
 
 async function main() {
   const server = fastify();
@@ -59,6 +60,10 @@ async function main() {
 
   server.register(replyFrom, fullOptions);
 
+  server.register(replyFrom, { undici: { proxy: new URL('http://example2.com:8080') } });
+
+  server.register(replyFrom, { undici: { proxy: { uri: 'http://example2.com:8080' } } });
+
   server.get("/v1", (request, reply) => {
       expectType<FastifyReply>(reply.from());
   });
@@ -72,6 +77,12 @@ async function main() {
           getUpstream(req, base) {
               expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(req);
               return base;
+          },
+          onResponse(request, reply, res) {
+            expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(request);
+            expectType<FastifyReply<RouteGenericInterface, RawServerBase>>(reply);
+            expectType<RawReplyDefaultExpression<RawServerBase>>(res);
+            expectType<number>(res.statusCode);
           }
       });
   });
@@ -89,6 +100,16 @@ async function main() {
 
   instance.get("/http2", (request, reply) => {
       reply.from("/", {
+          method: "POST",
+          retryDelay: ({err, req, res, attempt, retriesCount, getDefaultDelay }) => {
+              const defaultDelay = getDefaultDelay();
+              if (defaultDelay) return defaultDelay;
+
+              if (res && res.statusCode === 500 && req.method === "GET") {
+                return 300;
+              }
+              return null;
+            },
           rewriteHeaders(headers, req) {
               return headers;
           },
@@ -98,9 +119,15 @@ async function main() {
           getUpstream(req, base) {
               return base;
           },
-          onError(reply: FastifyReply<RawServerBase>, error) {
+          onError(reply: FastifyReply<RouteGenericInterface, RawServerBase>, error) {
               return reply.send(error.error);
-          }
+          },
+          queryString(search, reqUrl, request) {
+              expectType<string | undefined>(search);
+              expectType<string>(reqUrl);
+              expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(request);
+              return '';
+          },
       });
   });