@techspikes/fastify-mock-fallback 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Techspikes <https://github.com/techspikes/>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# fastify-mock-fallback
+
+[![Node.js CI](https://github.com/techspikes/fastify-mock-fallback/actions/workflows/ci.yml/badge.svg)](https://github.com/techspikes/fastify-mock-fallback/actions/workflows/ci.yml)
+[![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard)
+
+Fastify plugin that registers fallback mock routes from OpenAPI request and response examples.
+
+Use it for spec-first development: keep real Fastify handlers for implemented operations, and let this plugin serve example responses for operations that are not implemented yet.
+
+## Scope
+
+**This plugin is intentionally short and simple.** It is designed for true agile teams where full-stack engineers develop both the frontend and backend while practicing XP.
+
+If you need a full-featured API mocking and testing platform, consider [Microcks](https://microcks.io/), a CNCF Incubating project.
+
+## Install
+
+```sh
+npm i @techspikes/fastify-mock-fallback
+```
+
+## Compatibility
+
+| Plugin version | Fastify version |
+| -------------- | --------------- |
+| `^1.0.x` | `^5.x` |
+
+## Supported Specification Versions
+
+* Supports OpenAPI 3.0.x documents.
+* OpenAPI 3.1.x is not officially supported.
+* Swagger/OpenAPI 2.0 documents are not supported for mock generation, even though the underlying parser may be able to parse them.
+
+## Usage
+
+Register the plugin with an OpenAPI 3.0.x YAML or JSON file.
+
+```js
+import Fastify from 'fastify'
+import { fastifyMockFallback } from '@techspikes/fastify-mock-fallback'
+
+const fastify = Fastify()
+
+fastify.get('/implemented', async () => {
+  return { source: 'real handler' }
+})
+
+await fastify.register(fastifyMockFallback, {
+  specification: './openapi.yaml',
+  enable: process.env.NODE_ENV !== 'production',
+})
+
+await fastify.listen({ port: 3000 })
+```
+
+Existing Fastify routes are not replaced. Register implemented routes before this plugin; if a generated mock route conflicts with an already registered route, the existing route wins. Registering an implemented route after a conflicting mock route causes Fastify to reject the duplicate route.
+
+### Options
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `specification` | `string` | required | Path to an OpenAPI YAML or JSON file. |
+| `enable` | `boolean` | `false` | Registers mock routes when set to `true`. |
+
+## OpenAPI Loading
+
+The plugin reads OpenAPI 3.0.x YAML and JSON files through `@apidevtools/swagger-parser`.
+
+Supported before route registration:
+
+* YAML anchors and aliases
+* local `$ref`
+* relative file `$ref`
+
+Remote `$ref` entries are disabled as a safety precaution and are not fetched.
+
+## Matching
+
+The plugin builds request examples from an operation's parameters and request body examples, then links responses to those request examples.
+
+Request examples can come only from named `examples` entries:
+
+| OpenAPI source | Fastify request field |
+| -------------- | --------------------- |
+| `path` parameters | `request.params` |
+| `query` parameters | `request.query` |
+| `header` parameters | lower-case `request.headers` |
+| `cookie` parameters | `request.cookies` |
+| `requestBody` examples | `request.body` |
+
+The singular OpenAPI `example` field and `externalValue` are not used for request matching. A request body example must also match the request `Content-Type`; omitting `Content-Type` does not match a request body example.
+
+Parameter, header, cookie, and query values are compared as strings. Request bodies are compared with deep strict equality. Cookie matching requires a cookie parser such as `@fastify/cookie`.
+
+Path-level parameters are included in request matching. Operation-level parameters override path-level parameters with the same `in` and `name` values.
+
+When request body examples with the same name are defined across multiple media types, request matching uses the client `Content-Type` header to select the matching request body media.
+
+### Response Matching
+
+Responses are linked in this priority order:
+
+1. response examples with `x-request-match`
+2. same-name response and request examples
+3. for operations without request examples, the first status `200` media entry with `example`
+4. for operations without request examples, the first status `200` media entry with `examples`
+
+Response media is selected from the request `Accept` header by using the `accepts` package. When `Accept` is omitted, `*/*` is assumed. After media selection, the first matching response entry in OpenAPI definition order is used.
+
+### Example
+
+```yaml
+openapi: "3.0.4"
+info:
+  title: Example API
+  version: "1.0.0"
+paths:
+  /pet/{petId}:
+    get:
+      operationId: getPetById
+      parameters:
+        - in: path
+          name: petId
+          required: true
+          schema: { type: integer }
+          examples:
+            rocky:
+              value: 1
+            daisy:
+              value: 2
+            missing:
+              value: 3
+      responses:
+        "200":
+          description: successful operation
+          content:
+            application/json:
+              examples:
+                default:
+                  x-request-match: rocky
+                  value: { id: 1, name: rocky }
+                daisy:
+                  value: { id: 2, name: daisy }
+        "404":
+          description: not found
+          content:
+            application/json:
+              examples:
+                missing:
+                  x-request-match: missing
+                  value: { code: 404, message: not found }
+  /pets:
+    get:
+      operationId: listPets
+      responses:
+        "200":
+          description: successful operation
+          content:
+            application/json:
+              example: [{ id: 1, name: rocky }, { id: 2, name: daisy }]
+```
+
+In this example:
+
+* `GET /pet/1` uses a response example with `x-request-match`.
+* `GET /pet/2` uses same-name matching.
+* `GET /pet/3` uses a response example with `x-request-match` and returns `404`.
+* `GET /pets` has no request examples, so it uses the status `200` response `example`.
+
+## Validation
+
+Explicit references are strict:
+
+* A truthy `x-request-match` on a response example must reference an existing request example.
+* `x-request-match` is interpreted only on response examples. It is rejected on parameter objects and examples, request and response media objects, and response objects; it is otherwise ignored.
+* response statuses must be concrete HTTP status codes from `100` to `599`.
+* each operation must define at least one response entry.
+
+Unsupported OpenAPI parameter locations throw during plugin registration.
+
+## Runtime Behavior
+
+* Converts OpenAPI paths such as `/pet/{petId}` to Fastify paths such as `/pet/:petId`.
+* Registers a `501` fallback route for operations without request examples when no usable response example exists. Operations with request examples but no linked response example are not registered and log a warning.
+* Checks `GET`, `POST`, `PUT`, `PATCH`, `DELETE`, `OPTIONS`, and `HEAD` in their OpenAPI definition order. Other methods, including `TRACE`, are not generated. When the same path defines both `HEAD` and `GET`, define `HEAD` first. If `GET` is defined first, Fastify's automatic `HEAD` route is used and the explicit `HEAD` mock is skipped with a warning.
+* Adds `x-mock-response: true` to generated mock responses.
+* Returns the matched response status code and body only when a response example supplies a body.
+* Returns `406` with `x-mock-response: true` when no response media type is acceptable.
+* Returns `501` with `x-mock-response: true` when no example matches.
+* Rejects invalid OpenAPI specs, including specs without `paths`.
+* Registers no routes for specs with empty `paths`.
+
+## Exports
+
+Both default and named exports are available.
+
+```js
+import mockFallback from '@techspikes/fastify-mock-fallback'
+import { fastifyMockFallback } from '@techspikes/fastify-mock-fallback'
+```
+
+## License
+
+Licensed under [MIT](./LICENSE).

package/index.js

@@ -0,0 +1,370 @@
+import { isDeepStrictEqual } from 'node:util'
+import fp from 'fastify-plugin'
+import SwaggerParser from '@apidevtools/swagger-parser'
+import accepts from 'accepts'
+
+const X_MOCK_RESPONSE_HEADER = 'x-mock-response'
+const X_REQUEST_MATCH = 'x-request-match'
+const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD'])
+
+// Normalizes media types for Accept and Content-Type comparisons.
+const MediaType = {
+  normalize (mediaType) {
+    return mediaType.split(';')[0].trim().toLowerCase()
+  },
+  compare (actual, expected) {
+    return MediaType.normalize(actual) === MediaType.normalize(expected)
+  },
+  negotiate (request, entries) {
+    const mediaTypes = [...new Set(entries.map(entry => MediaType.normalize(entry.mediaType)))]
+    return accepts({ headers: { ...request.headers } }).type(mediaTypes)
+  },
+}
+
+// Matches collected request example conditions against Fastify requests.
+const RequestMatcher = {
+  sources: {
+    path: 'params',
+    query: 'query',
+    header: 'header',
+    cookie: 'cookie',
+  },
+  params (request, condition) {
+    return String(request.params[condition.name]) === String(condition.value)
+  },
+  query (request, condition) {
+    return String(request.query[condition.name]) === String(condition.value)
+  },
+  header (request, condition) {
+    return request.headers[condition.name.toLowerCase()] === String(condition.value)
+  },
+  cookie (request, condition) {
+    return String((request.cookies ?? {})[condition.name]) === String(condition.value)
+  },
+  body (request, condition) {
+    return MediaType.compare(request.headers['content-type'] ?? '', condition.mediaType) &&
+      isDeepStrictEqual(request.body, condition.value)
+  },
+  findEntry (request, entries, acceptedMediaType) {
+    return entries.find(entry =>
+      MediaType.compare(acceptedMediaType, entry.mediaType) &&
+      entry.conditions.every(condition => RequestMatcher[condition.source](request, condition))
+    )
+  },
+}
+
+// Loads a local OpenAPI document and resolves supported refs before registration.
+async function loadOpenApiSpecification (specification) {
+  return await SwaggerParser.dereference(specification, {
+    resolve: {
+      http: false
+    },
+    dereference: {
+      circular: false,
+    },
+  })
+}
+
+// Rejects response examples that point to a missing request example.
+function rejectMissingRequestExample (requestExamples, matchName, operationName) {
+  if (requestExamples.has(matchName)) return
+
+  throw new Error(
+    `Request example "${matchName}" referenced by operation "${operationName}" does not exist`
+  )
+}
+
+// Keeps x-request-match constrained to response examples.
+function rejectInvalidRequestMatchLocation (target, operationName) {
+  if (target?.[X_REQUEST_MATCH] === undefined) return
+
+  throw new Error(
+    `${X_REQUEST_MATCH} is only supported on response examples for operation "${operationName}"`
+  )
+}
+
+// Accepts only concrete HTTP response status codes.
+function rejectInvalidResponseStatusCode (status, operationName) {
+  if (/^[1-5][0-9]{2}$/.test(status)) return
+
+  throw new Error(
+    `Response status "${status}" in operation "${operationName}" must be a concrete HTTP status code from 100 to 599`
+  )
+}
+
+// Limits matching to request locations Fastify can expose.
+function rejectUnsupportedParameterLocation (param, operationName) {
+  if (RequestMatcher.sources[param.in]) return
+
+  throw new Error(
+    `Unsupported OpenAPI parameter location "${param.in}" for parameter "${param.name}" in operation "${operationName}"`
+  )
+}
+
+// OpenAPI operations must define at least one response entry.
+function rejectMissingResponses (responses, operationName) {
+  if (responses.length !== 0) return
+
+  throw new Error(
+    `Operation "${operationName}" must define at least one response`
+  )
+}
+
+// Adds each response example as either an explicit match or a same-name match.
+function pushMatchedEntry (explicitEntries, sameNameEntries, exampleName, example, statusCode, mediaType, requestExamples, operationName) {
+  // Resolves a named request example before attaching its condition variants.
+  const getRequestExampleConditions = (requestExamples, matchName, operationName) => {
+    rejectMissingRequestExample(requestExamples, matchName, operationName)
+    return requestExamples.get(matchName)
+  }
+
+  // Explicit links take precedence over response example names.
+  if (example[X_REQUEST_MATCH]) {
+    getRequestExampleConditions(requestExamples, example[X_REQUEST_MATCH], operationName)
+      .forEach(conditions => {
+        explicitEntries.push({ conditions, statusCode, mediaType, body: example.value })
+      })
+  // Otherwise, a shared example name supplies the request conditions.
+  } else if (requestExamples.has(exampleName)) {
+    getRequestExampleConditions(requestExamples, exampleName, operationName)
+      .forEach(conditions => {
+        sameNameEntries.push({ conditions, statusCode, mediaType, body: example.value })
+      })
+  }
+}
+
+// Collects request examples into named condition variants used by responses.
+function collectRequestExamples (pathItem, operation, operationName) {
+  const collectParameters = () => {
+    const operationParameters = operation.parameters ?? []
+
+    // Operation parameters override path-level parameters with the same identity.
+    const isOverriddenByOperation = (pathParam) =>
+      operationParameters.some(operationParam =>
+        operationParam.in === pathParam.in &&
+        operationParam.name === pathParam.name
+      )
+
+    return [
+      ...(pathItem?.parameters ?? []).filter(pathParam => !isOverriddenByOperation(pathParam)),
+      ...operationParameters,
+    ]
+  }
+
+  const requestExamples = new Map()
+  const parameters = collectParameters()
+
+  // Parameters with the same example name combine into one condition set.
+  parameters.forEach(param => {
+    rejectInvalidRequestMatchLocation(param, operationName)
+    rejectUnsupportedParameterLocation(param, operationName)
+
+    const source = RequestMatcher.sources[param.in]
+
+    // Parameters without examples do not contribute matching conditions.
+    Object.entries(param.examples ?? {}).forEach(([exampleName, example]) => {
+      rejectInvalidRequestMatchLocation(example, operationName)
+
+      const requestExampleVariants = requestExamples.get(exampleName) ?? [[]]
+
+      requestExampleVariants.forEach(conditions => {
+        conditions.push({ source, name: param.name, value: example.value })
+      })
+
+      requestExamples.set(exampleName, requestExampleVariants)
+    })
+  })
+
+  // Request body examples add body conditions to matching request examples.
+  Object.entries(operation.requestBody?.content ?? {}).forEach(([mediaType, media]) => {
+    rejectInvalidRequestMatchLocation(media, operationName)
+
+    Object.entries(media.examples ?? {}).forEach(([exampleName, example]) => {
+      rejectInvalidRequestMatchLocation(example, operationName)
+
+      const existingVariants = requestExamples.get(exampleName) ?? [[]]
+
+      // Body examples attach to the parameter-only variant for the same name.
+      const parameterConditions = existingVariants.find(conditions =>
+        conditions.every(condition => condition.source !== 'body')
+      ) ?? existingVariants[0].filter(condition => condition.source !== 'body')
+
+      // Preserve existing body variants while adding this media type variant.
+      const requestExampleVariants = [
+        ...existingVariants.filter(conditions => conditions.some(condition => condition.source === 'body')),
+        [
+          ...parameterConditions,
+          { source: 'body', mediaType, value: example.value },
+        ],
+      ]
+
+      requestExamples.set(exampleName, requestExampleVariants)
+    })
+  })
+
+  return requestExamples
+}
+
+// Collects all response examples that can produce mock responses.
+function collectResponseEntries (pathItem, operation, operationName) {
+  // Keep each priority tier separate until all response examples are collected.
+  const matchedExampleEntries = []
+  const matchedSameNameEntries = []
+  const parameterlessEntries = []
+
+  // Read the declared response statuses in OpenAPI definition order.
+  const responses = Object.entries(operation.responses ?? {})
+
+  rejectMissingResponses(responses, operationName)
+
+  const requestExamples = collectRequestExamples(pathItem, operation, operationName)
+
+  responses.forEach(([status, response]) => {
+    // Validate each status before using it as Fastify's numeric reply code.
+    rejectInvalidRequestMatchLocation(response, operationName)
+    rejectInvalidResponseStatusCode(status, operationName)
+
+    const statusCode = Number(status)
+
+    // Each response media type can contribute independently negotiable entries.
+    Object.entries(response.content ?? {}).forEach(([mediaType, media]) => {
+      rejectInvalidRequestMatchLocation(media, operationName)
+
+      // Parameterless operations can use a plain 200 response example.
+      if (requestExamples.size === 0 && statusCode === 200) {
+        const exampleBody = Object.hasOwn(media, 'example') ? media.example : Object.values(media.examples ?? {})[0]?.value
+
+        if (exampleBody !== undefined) {
+          parameterlessEntries.push({ conditions: [], statusCode, mediaType, body: exampleBody })
+        }
+      }
+
+      // Link named response examples to their request example conditions.
+      Object.entries(media.examples ?? {}).forEach(([exampleName, example]) => {
+        pushMatchedEntry(
+          matchedExampleEntries,
+          matchedSameNameEntries,
+          exampleName,
+          example,
+          statusCode,
+          mediaType,
+          requestExamples,
+          operationName
+        )
+      })
+    })
+  })
+
+  return {
+    requestExamples,
+    // Explicit matches win over same-name matches, then parameterless fallbacks.
+    entries: [...matchedExampleEntries, ...matchedSameNameEntries, ...parameterlessEntries]
+  }
+}
+
+// Converts OpenAPI operations into Fastify route definitions.
+function buildMocks (api, onSkipOperation) {
+  const buildOperationMock = (rawPath, pathItem, httpMethod, operation) => {
+    // Use the declared operationId, or a stable method-and-path fallback.
+    const operationName = operation.operationId ?? `${httpMethod} ${rawPath}`
+    const { requestExamples, entries } = collectResponseEntries(pathItem, operation, operationName)
+
+    // Parameterized operations without linked responses are skipped.
+    if (requestExamples.size !== 0 && entries.length === 0) {
+      onSkipOperation(operationName)
+      return
+    }
+
+    // Convert OpenAPI path parameters to Fastify route parameters.
+    return {
+      fastifyPath: rawPath.replace(/\{([^}]+)\}/g, ':$1'),
+      httpMethod,
+      operationName,
+      entries,
+    }
+  }
+
+  // Preserve Path Item operation order so explicit HEAD can precede GET.
+  return Object.entries(api.paths).flatMap(([rawPath, pathItem]) =>
+    Object.entries(pathItem).flatMap(([operationMethod, operation]) => {
+      const httpMethod = operationMethod.toUpperCase()
+
+      // Ignore path-level metadata and unsupported operations.
+      if (!HTTP_METHODS.has(httpMethod)) return []
+
+      const mock = buildOperationMock(rawPath, pathItem, httpMethod, operation)
+
+      return mock ? [mock] : []
+    })
+  )
+}
+
+export const fastifyMockFallback = fp(async (app, options) => {
+  // Default to disabled so mocks are explicitly opted in per environment.
+  const { specification, enable = false } = options
+
+  // Leave the Fastify instance unchanged when fallback mocks are disabled.
+  if (!enable) {
+    app.log.info('mock fallback disabled, skipping')
+    return
+  }
+
+  // Resolve the specification before deriving route definitions from it.
+  const api = await loadOpenApiSpecification(specification)
+
+  // Build all mockable operations and report parameterized operations without examples.
+  const mocks = buildMocks(api, operationName => {
+    app.log.warn(`skip operation "${operationName}", no response example found for parameterized operation`)
+  })
+
+  // Register each mock unless the application already implements its route.
+  mocks.forEach(mock => {
+    const { fastifyPath, httpMethod, operationName, entries } = mock
+
+    // Real routes take precedence over generated fallback mocks.
+    if (app.hasRoute({ method: httpMethod, url: fastifyPath })) {
+      app.log.warn(`skip operation "${operationName}", already implemented`)
+      return
+    }
+
+    app.route({
+      method: httpMethod,
+      url: fastifyPath,
+      handler: async (request, reply) => {
+        reply.header(X_MOCK_RESPONSE_HEADER, 'true')
+
+        // Accept negotiation happens before request example matching.
+        const acceptedMediaType = MediaType.negotiate(request, entries)
+
+        if (!acceptedMediaType) {
+          return reply.status(406).send({
+            error: 'Not Acceptable',
+            message: `No acceptable response media type found for operation "${operationName}"`,
+          })
+        }
+
+        // A registered mock can still miss if request conditions do not match.
+        const matched = RequestMatcher.findEntry(request, entries, acceptedMediaType)
+
+        if (!matched) {
+          return reply.status(501).send({
+            error: 'Not Implemented',
+            message: `No matching example found for operation "${operationName}"`,
+          })
+        }
+
+        return reply.status(matched.statusCode).type(matched.mediaType).send(matched.body)
+      },
+    })
+
+    app.log.info(`registered mock operation: ${operationName}`)
+  })
+
+  // Signal that all enabled mock route registrations have completed.
+  app.log.info('finished registering mock routes')
+}, {
+  name: 'fastify-mock-fallback',
+  fastify: '5.x',
+})
+
+export default fastifyMockFallback

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@techspikes/fastify-mock-fallback",
+  "version": "1.0.0",
+  "description": "Fastify plugin that registers fallback mock routes from OpenAPI examples.",
+  "author": "knzbr <87257088+knzbr@users.noreply.github.com>",
+  "license": "MIT",
+  "type": "module",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "test": "npm run test:typescript && npm run test:unit",
+    "test:unit": "c8 --100 node --test test/*.test.js",
+    "test:typescript": "tstyche"
+  },
+  "dependencies": {
+    "@apidevtools/swagger-parser": "^12.1.0",
+    "accepts": "^1.3.8",
+    "fastify-plugin": "^5.1.0"
+  },
+  "peerDependencies": {
+    "fastify": "^5.8.5"
+  },
+  "devDependencies": {
+    "@fastify/cookie": "^11.0.2",
+    "c8": "^11.0.0",
+    "eslint": "^9.39.4",
+    "fastify": "^5.8.5",
+    "neostandard": "^0.13.0",
+    "tstyche": "^7.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/techspikes/fastify-mock-fallback.git"
+  },
+  "bugs": {
+    "url": "https://github.com/techspikes/fastify-mock-fallback/issues"
+  },
+  "homepage": "https://github.com/techspikes/fastify-mock-fallback#readme",
+  "keywords": [
+    "fastify",
+    "openapi",
+    "mock",
+    "spec-first"
+  ],
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "types/index.d.ts"
+  ],
+  "engines": {
+    "node": ">=22.18.0",
+    "npm": ">=10.9.3"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,32 @@
+import type { FastifyPluginAsync } from 'fastify'
+
+export type RequestExampleEntry = {
+  source: 'params' | 'query' | 'header' | 'cookie' | 'body' | 'unknown'
+  name?: string
+  value: unknown
+}
+
+export type RequestExampleMap = Map<string, RequestExampleEntry[]>
+
+export type MockEntry = {
+  matchName: string
+  statusCode: number
+  body?: unknown
+}
+
+export type OperationMock = {
+  fastifyPath: string
+  httpMethod: string
+  operationId: string
+  entries: MockEntry[]
+  requestExamples: RequestExampleMap
+}
+
+export type MockFallbackOptions = {
+  specification: string
+  enable?: boolean
+}
+
+export declare const fastifyMockFallback: FastifyPluginAsync<MockFallbackOptions>
+
+export default fastifyMockFallback