@zuplo/cli 6.72.2 → 6.72.7

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/types/example-async.tst.ts

@@ -0,0 +1,19 @@
+import { FastifyPluginAsync } from 'fastify'
+
+type FastifyExampleAsync = FastifyPluginAsync<fastifyExampleAsync.FastifyExampleAsyncOptions>
+
+declare namespace fastifyExampleAsync {
+
+  export interface FastifyExampleAsyncOptions {
+    foo?: 'bar'
+  }
+
+  export interface FastifyExampleAsyncPluginOptions extends FastifyExampleAsyncOptions {
+  }
+  export const fastifyExampleAsync: FastifyExampleAsync
+  export { fastifyExampleAsync as default }
+}
+
+declare function fastifyExampleAsync (...params: Parameters<FastifyExampleAsync>): ReturnType<FastifyExampleAsync>
+
+export default fastifyExampleAsync

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/types/example-callback.tst.ts

@@ -0,0 +1,19 @@
+import { FastifyPluginCallback } from 'fastify'
+
+type FastifyExampleCallback = FastifyPluginCallback<fastifyExampleCallback.FastifyExampleCallbackOptions>
+
+declare namespace fastifyExampleCallback {
+
+  export interface FastifyExampleCallbackOptions {
+    foo?: 'bar'
+  }
+
+  export interface FastifyExampleCallbackPluginOptions extends FastifyExampleCallbackOptions {
+  }
+  export const fastifyExampleCallback: FastifyExampleCallback
+  export { fastifyExampleCallback as default }
+}
+
+declare function fastifyExampleCallback (...params: Parameters<FastifyExampleCallback>): ReturnType<FastifyExampleCallback>
+
+export default fastifyExampleCallback

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/types/index.d.ts

@@ -0,0 +1,54 @@
+import {
+  FastifyPluginCallback,
+  FastifyPluginAsync,
+  FastifyPluginOptions,
+  RawServerBase,
+  RawServerDefault,
+  FastifyTypeProvider,
+  FastifyTypeProviderDefault,
+  FastifyBaseLogger,
+} from 'fastify'
+
+type FastifyPlugin = typeof fastifyPlugin
+
+declare namespace fastifyPlugin {
+  export interface PluginMetadata {
+    /** Bare-minimum version of Fastify for your plugin, just add the semver range that you need. */
+    fastify?: string,
+    name?: string,
+    /** Decorator dependencies for this plugin */
+    decorators?: {
+      fastify?: (string | symbol)[],
+      reply?: (string | symbol)[],
+      request?: (string | symbol)[]
+    },
+    /** The plugin dependencies */
+    dependencies?: string[],
+    encapsulate?: boolean
+  }
+
+  export const fastifyPlugin: FastifyPlugin
+  export { fastifyPlugin as default }
+}
+
+/**
+ * This function does three things for you:
+ *   1. Add the `skip-override` hidden property
+ *   2. Check bare-minimum version of Fastify
+ *   3. Pass some custom metadata of the plugin to Fastify
+ * @param fn Fastify plugin function
+ * @param options Optional plugin options
+ */
+
+declare function fastifyPlugin<
+  Options extends FastifyPluginOptions = Record<never, never>,
+  RawServer extends RawServerBase = RawServerDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  Fn extends FastifyPluginCallback<Options, RawServer, TypeProvider, Logger> | FastifyPluginAsync<Options, RawServer, TypeProvider, Logger> = FastifyPluginCallback<Options, RawServer, TypeProvider, Logger>
+> (
+  fn: Fn extends unknown ? Fn extends (...args: any) => Promise<any> ? FastifyPluginAsync<Options, RawServer, TypeProvider, Logger> : FastifyPluginCallback<Options, RawServer, TypeProvider, Logger> : Fn,
+  options?: fastifyPlugin.PluginMetadata | string
+): Fn
+
+export = fastifyPlugin

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/types/index.tst.ts

@@ -0,0 +1,249 @@
+import { expect } from 'tstyche'
+import fastifyPlugin from '.'
+import fastify, {
+  FastifyPluginCallback,
+  FastifyPluginAsync,
+  FastifyError,
+  FastifyInstance,
+  FastifyPluginOptions,
+  RawServerDefault,
+  FastifyTypeProviderDefault,
+  FastifyBaseLogger
+} from 'fastify'
+import { Server } from 'node:https'
+import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+import fastifyExampleCallback from './example-callback.tst'
+import fastifyExampleAsync from './example-async.tst'
+
+interface Options {
+  foo: string;
+}
+
+const testSymbol = Symbol('foobar')
+
+const pluginCallback: FastifyPluginCallback = (_fastify, _options, _next) => {}
+expect(fastifyPlugin(pluginCallback)).type.toBe<FastifyPluginCallback>()
+
+const pluginCallbackWithTypes = (
+  _fastify: FastifyInstance,
+  _options: FastifyPluginOptions,
+  _next: (error?: FastifyError) => void
+): void => {}
+expect(
+  fastifyPlugin(pluginCallbackWithTypes)
+).type.toBeAssignableTo<FastifyPluginCallback>()
+
+expect(
+  fastifyPlugin(
+    (
+      _fastify: FastifyInstance,
+      _options: FastifyPluginOptions,
+      _next: (error?: FastifyError) => void
+    ): void => {}
+  )
+).type.toBeAssignableTo<FastifyPluginCallback>()
+
+expect(fastifyPlugin(pluginCallback, '')).type.toBe<FastifyPluginCallback>()
+expect(
+  fastifyPlugin(pluginCallback, {
+    fastify: '',
+    name: '',
+    decorators: {
+      fastify: ['', testSymbol],
+      reply: ['', testSymbol],
+      request: ['', testSymbol]
+    },
+    dependencies: [''],
+    encapsulate: true
+  })
+).type.toBe<FastifyPluginCallback>()
+
+const pluginCallbackWithOptions: FastifyPluginCallback<Options> = (
+  _fastify,
+  options,
+  _next
+) => {
+  expect(options.foo).type.toBe<string>()
+}
+expect(fastifyPlugin(pluginCallbackWithOptions)).type.toBe<
+  FastifyPluginCallback<Options>
+>()
+
+const pluginCallbackWithServer: FastifyPluginCallback<Options, Server> = (
+  fastify,
+  _options,
+  _next
+) => {
+  expect(fastify.server).type.toBe<Server>()
+}
+expect(fastifyPlugin(pluginCallbackWithServer)).type.toBe<
+  FastifyPluginCallback<Options, Server>
+>()
+
+const pluginCallbackWithTypeProvider: FastifyPluginCallback<
+  Options,
+  Server,
+  TypeBoxTypeProvider
+> = (_fastify, _options, _next) => {}
+expect(fastifyPlugin(pluginCallbackWithTypeProvider)).type.toBe<
+  FastifyPluginCallback<Options, Server, TypeBoxTypeProvider>
+>();
+
+(async () => {
+  const pluginAsync: FastifyPluginAsync = async (_fastify, _options) => {}
+  expect(fastifyPlugin(pluginAsync)).type.toBe<FastifyPluginAsync>()
+
+  const pluginAsyncWithTypes = async (
+    _fastify: FastifyInstance,
+    _options: FastifyPluginOptions
+  ): Promise<void> => {}
+  expect(fastifyPlugin(pluginAsyncWithTypes)).type.toBe<
+    FastifyPluginAsync<
+      FastifyPluginOptions,
+      RawServerDefault,
+      FastifyTypeProviderDefault
+    >
+  >()
+
+  expect(
+    fastifyPlugin(
+      async (
+        _fastify: FastifyInstance,
+        _options: FastifyPluginOptions
+      ): Promise<void> => {}
+    )
+  ).type.toBe<
+    FastifyPluginAsync<
+      FastifyPluginOptions,
+      RawServerDefault,
+      FastifyTypeProviderDefault
+    >
+  >()
+
+  expect(fastifyPlugin(pluginAsync, '')).type.toBe<FastifyPluginAsync>()
+  expect(
+    fastifyPlugin(pluginAsync, {
+      fastify: '',
+      name: '',
+      decorators: {
+        fastify: ['', testSymbol],
+        reply: ['', testSymbol],
+        request: ['', testSymbol]
+      },
+      dependencies: [''],
+      encapsulate: true
+    })
+  ).type.toBe<FastifyPluginAsync>()
+
+  const pluginAsyncWithOptions: FastifyPluginAsync<Options> = async (
+    _fastify,
+    options
+  ) => {
+    expect(options.foo).type.toBe<string>()
+  }
+  expect(fastifyPlugin(pluginAsyncWithOptions)).type.toBe<
+    FastifyPluginAsync<Options>
+  >()
+
+  const pluginAsyncWithServer: FastifyPluginAsync<Options, Server> = async (
+    fastify,
+    _options
+  ) => {
+    expect(fastify.server).type.toBe<Server>()
+  }
+  expect(fastifyPlugin(pluginAsyncWithServer)).type.toBe<
+    FastifyPluginAsync<Options, Server>
+  >()
+
+  const pluginAsyncWithTypeProvider: FastifyPluginAsync<
+    Options,
+    Server,
+    TypeBoxTypeProvider
+  > = async (_fastify, _options) => {}
+  expect(fastifyPlugin(pluginAsyncWithTypeProvider)).type.toBe<
+    FastifyPluginAsync<Options, Server, TypeBoxTypeProvider>
+  >()
+
+  const server = fastify()
+  server.register(fastifyPlugin(pluginCallback))
+  server.register(fastifyPlugin(pluginCallbackWithTypes), { foo: 'bar' })
+  server.register(fastifyPlugin(pluginCallbackWithOptions), { foo: 'bar' })
+  server.register(fastifyPlugin(pluginCallbackWithServer), { foo: 'bar' })
+  server.register(fastifyPlugin(pluginCallbackWithTypeProvider), {
+    foo: 'bar'
+  })
+  server.register(fastifyPlugin(pluginAsync))
+  server.register(fastifyPlugin(pluginAsyncWithTypes), { foo: 'bar' })
+  server.register(fastifyPlugin(pluginAsyncWithOptions), { foo: 'bar' })
+  server.register(fastifyPlugin(pluginAsyncWithServer), { foo: 'bar' })
+  server.register(fastifyPlugin(pluginAsyncWithTypeProvider), { foo: 'bar' })
+
+  // Handling Callback and Async Inline
+  fastifyPlugin(function (fastify, options, next) {
+    expect(fastify).type.toBe<FastifyInstance>()
+    expect(options).type.toBe<Record<never, never>>()
+    expect(next).type.toBe<(err?: Error) => void>()
+  })
+
+  fastifyPlugin<Options>(function (fastify, options, next) {
+    expect(fastify).type.toBe<FastifyInstance>()
+    expect(options).type.toBe<Options>()
+    expect(next).type.toBe<(err?: Error) => void>()
+  })
+
+  fastifyPlugin<Options>(async function (fastify, options) {
+    expect(fastify).type.toBe<FastifyInstance>()
+    expect(options).type.toBe<Options>()
+  })
+
+  expect(
+    fastifyPlugin(async function (
+      _fastify: FastifyInstance,
+      _options: Options
+    ) {})
+  ).type.toBeAssignableTo<
+    FastifyPluginAsync<
+      Options,
+      RawServerDefault,
+      FastifyTypeProviderDefault,
+      FastifyBaseLogger
+    >
+  >()
+
+  fastifyPlugin(async function (fastify, options: Options) {
+    expect(fastify).type.toBe<FastifyInstance>()
+    expect(options).type.toBe<Options>()
+  })
+
+  fastifyPlugin(async function (fastify, options) {
+    expect(fastify).type.toBe<FastifyInstance>()
+    expect(options).type.toBe<Record<never, never>>()
+  })
+
+  // @ts-expect-error Target signature provides too few arguments
+  fastifyPlugin(async function (fastify, options, next) {})
+
+  expect(
+    fastifyPlugin(function (_fastify, _options, _next) {})
+  ).type.toBeAssignableTo<FastifyPluginCallback<Options>>()
+
+  fastifyPlugin(function (fastify, options: Options, next) {
+    expect(fastify).type.toBe<FastifyInstance>()
+    expect(options).type.toBe<Options>()
+    expect(next).type.toBe<(err?: Error) => void>()
+  })
+
+  // @ts-expect-error Target signature provides too few arguments
+  fastifyPlugin(function (fastify, options, next) {
+    return Promise.resolve()
+  })
+
+  server.register(fastifyExampleCallback, { foo: 'bar' })
+  expect(server.register).type.not.toBeCallableWith(fastifyExampleCallback, {
+    foo: 'baz'
+  })
+  server.register(fastifyExampleAsync, { foo: 'bar' })
+  expect(server.register).type.not.toBeCallableWith(fastifyExampleAsync, {
+    foo: 'baz'
+  })
+})()

package/node_modules/@fastify/reply-from/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "12.6.2",
+  "version": "12.6.3",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "type": "commonjs",
@@ -10,7 +10,7 @@
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:unit": "c8 node --test --test-timeout=30000",
-    "test:typescript": "tsd"
+    "test:typescript": "tstyche"
   },
   "repository": {
     "type": "git",
@@ -59,10 +59,9 @@
   ],
   "devDependencies": {
     "@fastify/formbody": "^8.0.0",
-    "@fastify/multipart": "^9.0.0",
+    "@fastify/multipart": "^10.0.0",
     "@sinonjs/fake-timers": "^15.0.0",
-    "@types/node": "^25.0.3",
-    "@types/tap": "^18.0.0",
+    "@types/node": "^26.0.0",
     "c8": "^11.0.0",
     "eslint": "^9.17.0",
     "fastify": "^5.0.0",
@@ -73,14 +72,14 @@
     "proxy": "^4.0.0",
     "proxyquire": "^2.1.3",
     "split2": "^4.2.0",
-    "tsd": "^0.33.0"
+    "tstyche": "^7.0.0"
   },
   "dependencies": {
     "@fastify/error": "^4.0.0",
     "end-of-stream": "^1.4.4",
     "fast-content-type-parse": "^3.0.0",
     "fast-querystring": "^1.1.2",
-    "fastify-plugin": "^5.0.1",
+    "fastify-plugin": "^6.0.0",
     "toad-cache": "^3.7.0",
     "undici": "^7.0.0"
   },

package/node_modules/@fastify/reply-from/test/incomplete-request.test.js

@@ -0,0 +1,142 @@
+'use strict'
+
+const { once } = require('node:events')
+const http = require('node:http')
+const net = require('node:net')
+const t = require('node:test')
+const Fastify = require('fastify')
+const From = require('..')
+
+for (const [name, options] of [
+  ['undici', {}],
+  ['node:http', { undici: false }]
+]) {
+  t.test(`closes the downstream connection when ${name} responds before the request is complete`, async (t) => {
+    const target = http.createServer((_req, res) => {
+      res.end('early')
+    })
+    const instance = Fastify()
+
+    t.after(async () => {
+      instance.server.closeAllConnections()
+      target.closeAllConnections()
+      await instance.close()
+      if (target.listening) await new Promise(resolve => target.close(resolve))
+    })
+
+    await new Promise(resolve => target.listen({ port: 0 }, resolve))
+
+    instance.register(From, options)
+    instance.addContentTypeParser('application/octet-stream', function (_request, payload, done) {
+      done(null, payload)
+    })
+    instance.post('/', (_request, reply) => {
+      reply.from(`http://localhost:${target.address().port}`)
+    })
+    await instance.listen({ port: 0 })
+
+    const socket = net.connect(instance.server.address().port, '127.0.0.1')
+    t.after(() => socket.destroy())
+    await once(socket, 'connect')
+
+    const responsePromise = new Promise((resolve, reject) => {
+      let response = ''
+      const timeout = setTimeout(() => {
+        reject(new Error('downstream connection was not closed'))
+      }, 5000)
+
+      socket.on('data', chunk => {
+        response += chunk.toString('latin1')
+      })
+      socket.once('error', err => {
+        clearTimeout(timeout)
+        reject(err)
+      })
+      socket.once('close', () => {
+        clearTimeout(timeout)
+        resolve(response)
+      })
+    })
+
+    socket.write([
+      'POST / HTTP/1.1',
+      'Host: localhost',
+      'Content-Type: application/octet-stream',
+      'Content-Length: 1048576',
+      'Connection: keep-alive',
+      '',
+      'a'
+    ].join('\r\n'))
+
+    const response = await responsePromise
+    t.assert.match(response, /^HTTP\/1\.1 200 OK\r\n/)
+    t.assert.match(response, /\r\nconnection: close\r\n/i)
+    t.assert.match(response, /\r\n\r\nearly$/)
+  })
+
+  t.test(`keeps the downstream connection reusable after ${name} consumes the request`, async (t) => {
+    const target = http.createServer((req, res) => {
+      req.resume()
+      req.on('end', () => res.end('complete'))
+    })
+    const agent = new http.Agent({ keepAlive: true, maxSockets: 1 })
+    const instance = Fastify()
+
+    t.after(async () => {
+      agent.destroy()
+      instance.server.closeAllConnections()
+      target.closeAllConnections()
+      await instance.close()
+      if (target.listening) await new Promise(resolve => target.close(resolve))
+    })
+
+    await new Promise(resolve => target.listen({ port: 0 }, resolve))
+
+    instance.register(From, options)
+    instance.addContentTypeParser('application/octet-stream', function (_request, payload, done) {
+      done(null, payload)
+    })
+    instance.post('/', (_request, reply) => {
+      reply.from(`http://localhost:${target.address().port}`)
+    })
+    await instance.listen({ port: 0 })
+
+    const first = await makeRequest(instance.server.address().port, agent, 'first')
+    t.assert.notStrictEqual(first.headers.connection, 'close')
+
+    const second = await makeRequest(instance.server.address().port, agent, 'second')
+    t.assert.strictEqual(second.reusedSocket, true)
+    t.assert.strictEqual(second.body, 'complete')
+  })
+}
+
+function makeRequest (port, agent, body) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      agent,
+      method: 'POST',
+      hostname: '127.0.0.1',
+      port,
+      path: '/',
+      headers: {
+        'content-length': Buffer.byteLength(body),
+        'content-type': 'application/octet-stream'
+      }
+    }, res => {
+      let responseBody = ''
+      res.setEncoding('utf8')
+      res.on('data', chunk => {
+        responseBody += chunk
+      })
+      res.on('end', () => {
+        resolve({
+          body: responseBody,
+          headers: res.headers,
+          reusedSocket: req.reusedSocket
+        })
+      })
+    })
+    req.on('error', reject)
+    req.end(body)
+  })
+}

package/node_modules/@fastify/reply-from/types/index.tst.ts

@@ -0,0 +1,123 @@
+import { expect } from 'tstyche'
+import fastify, {
+  type FastifyReply,
+  type FastifyRequest,
+  type RawServerBase,
+  type RequestGenericInterface,
+  type RouteGenericInterface
+} from 'fastify'
+import * as http from 'node:http'
+import { type IncomingHttpHeaders } from 'node:http2'
+import * as https from 'node:https'
+import { Agent, Client, Dispatcher, Pool } from 'undici'
+import replyFrom, {
+  type FastifyReplyFromOptions,
+  type RawServerResponse
+} from '.'
+
+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,
+    proxy: 'http://example2.com:8080'
+  },
+  contentTypesToEncode: ['application/x-www-form-urlencoded'],
+  retryMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
+  maxRetriesOn503: 10,
+  disableRequestLogging: false,
+  globalAgent: false,
+  destroyAgent: true
+}
+
+const app = fastify()
+
+app.register(replyFrom)
+app.register(replyFrom, {})
+app.register(replyFrom, { http2: true })
+app.register(replyFrom, fullOptions)
+app.register(replyFrom, { undici: { proxy: new URL('http://example2.com:8080') } })
+app.register(replyFrom, { undici: { proxy: { uri: 'http://example2.com:8080' } } })
+
+app.register(replyFrom, { base: 'http://example.com', undici: new Agent() })
+app.register(replyFrom, { base: 'http://example.com', undici: new Pool('http://example.com') })
+app.register(replyFrom, { base: 'http://example.com', undici: new Client('http://example.com') })
+app.register(replyFrom, { base: 'http://example.com', undici: new Dispatcher() })
+
+app.get('/v1', (_request, reply) => {
+  expect(reply.from()).type.toBe<FastifyReply>()
+})
+
+app.get('/v3', (_request, reply) => {
+  reply.from('/v3', {
+    timeout: 1000,
+    body: { hello: 'world' },
+    rewriteRequestHeaders (req, headers) {
+      expect(req).type.toBe<FastifyRequest<RequestGenericInterface, RawServerBase>>()
+      return headers
+    },
+    getUpstream (req, base) {
+      expect(req).type.toBe<FastifyRequest<RequestGenericInterface, RawServerBase>>()
+      return base
+    },
+    onResponse (request, reply, res) {
+      expect(request).type.toBe<FastifyRequest<RequestGenericInterface, RawServerBase>>()
+      expect(reply).type.toBe<FastifyReply<RouteGenericInterface, RawServerBase>>()
+      expect(res).type.toBe<RawServerResponse<RawServerBase>>()
+      expect(res.statusCode).type.toBe<number>()
+    }
+  })
+})
+
+app.get('/http2', (_request, reply) => {
+  reply.from('/', {
+    method: 'POST',
+    retryDelay: ({ req, res, err, attempt, getDefaultDelay }) => {
+      const defaultDelay = getDefaultDelay(req, res, err, attempt)
+      expect(defaultDelay).type.toBe<number | null>()
+
+      if (res && res.statusCode === 500 && req.method === 'GET') {
+        return 300
+      }
+      return null
+    },
+    rewriteHeaders (headers) {
+      return headers
+    },
+    rewriteRequestHeaders (_req, headers: IncomingHttpHeaders) {
+      return headers
+    },
+    onError (reply: FastifyReply<RouteGenericInterface, RawServerBase>, error) {
+      return reply.send(error.error)
+    },
+    queryString (search, reqUrl, request) {
+      expect(search).type.toBe<string | undefined>()
+      expect(reqUrl).type.toBe<string>()
+      expect(request).type.toBe<FastifyRequest<RequestGenericInterface, RawServerBase>>()
+      return ''
+    },
+  })
+})
+
+expect<FastifyReplyFromOptions>().type.toBeAssignableFrom(fullOptions)
+expect<FastifyReplyFromOptions>().type.toBeAssignableFrom({ http2: true })