@rosen-bridge/fastify-enhanced 2.0.2 → 3.1.0-d5b86d3e

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @rosen-bridge/fastify-enhanced
 
+## 3.1.0-d5b86d3e
+
+### Minor Changes
+
+- Add support for using AbstractLogger in place of the default Fastify logger
+
+## 3.0.0
+
+### Major Changes
+
+- Remove @rosen-bridge/json-bigint dependency and jsonParser in facvor of zod's coerce functionality
+- Add apiKey securityScheme to swagger
+- Update the type of fastify-options argument of makeFastify to FastifyHttpOptions
+- Re-export fastify request and reply types
+
 ## 2.0.2
 
 ### Patch Changes

package/README.md

@@ -16,47 +16,42 @@ npm:
 
 ```sh
 npm i @rosen-bridge/fastify-enhanced
+
+# install compatible zod version
+npm i zod@^3.21.4
 ```
 
 yarn:
 
 ```sh
 yarn add @rosen-bridge/fastify-enhanced
+
+# install compatible zod version
+yarn add zod@^3.21.4
 ```
 
 ## Usage
 
-To use the enhanced Fastify, import `createFastify` and use it to create a fastify instance and register routes. Use data types defined under `types` object, to define validation constraints for requests and responses:
+To use the enhanced Fastify, import `makeFastify` and use it to create a fastify instance and register routes. Install and use zod to define schemas for validating requests and responses:
+
+> Note: For **BigInt** field types, since JSON does not support the BigInt data type, you should use `z.coerce.bigint()` in the schema, and the value in the data transfer object (DTO) should be either a **number** or a **string**; `coerce` allows Zod to validate and transform the number or string value into a BigInt. Also its preferred to use string for bigint types in the response schemas.
 
 ```ts
-import { FastifyBaseLogger, FastifyInstance } from 'fastify';
-import { IncomingMessage, Server, ServerResponse } from 'http';
-
-import {
-  ZodTypeProvider,
-  createFastify,
-  types,
-} from '@rosen-bridge/fastify-enhanced';
-
-const addTokenPaymentRoute = (
-  fastify: FastifyInstance<
-    Server<typeof IncomingMessage, typeof ServerResponse>,
-    IncomingMessage,
-    ServerResponse<IncomingMessage>,
-    FastifyBaseLogger,
-    ZodTypeProvider
-  >,
-) => {
-  const bodySchema = types.object({
-    tokenName: types.string(),
-    tokenAmount: types.bigint(),
-    tokenDecimals: types.number(),
+import { z } from 'zod';
+
+import { FastifyWithZod, makeFastify } from '@rosen-bridge/fastify-enhanced';
+
+const addTokenPaymentRoute = (fastify: FastifyWithZod) => {
+  const bodySchema = z.object({
+    tokenName: z.string(),
+    tokenAmount: z.coerce.bigint(),
+    tokenDecimals: z.number(),
   });
 
-  const res200Schema = types.object({
-    name: types.string(),
-    amount: types.bigint(),
-    decimal: types.number(),
+  const res200Schema = z.object({
+    name: z.string(),
+    amount: z.string(),
+    decimal: z.number(),
   });
 
   const payTokenOpts = {
@@ -71,15 +66,89 @@ const addTokenPaymentRoute = (
   fastify.post('/payToken', payTokenOpts, async (request, reply) => {
     return reply.status(200).send({
       name: request.body.tokenName,
-      amount: request.body.tokenAmount,
+      amount: request.body.tokenAmount.toString(),
       decimal: request.body.tokenDecimals,
     });
   });
+};
+
+const addDemoRoute = (fastify: FastifyWithZod) => {
+  const bodySchema = z.object({
+    numberField: z.number(),
+    bigintField: z.coerce.bigint(),
+    booleanField: z.boolean(),
+    stringField: z.string(),
+    optionalStringField: z.optional(z.string()),
+    objectField: z.object({
+      bigintField: z.coerce.bigint(),
+      // ...
+    }),
+    numberArrayField: z.array(z.number()),
+    stringArrayField: z.array(z.string()),
+    unionField: z.union([
+      z.string(),
+      z.object({
+        stringArrayField: z.array(z.string()),
+        // ...
+      }),
+    ]),
+  });
+
+  const qsSchema = z.object({
+    qs: z.union([z.string().transform((i) => [i]), z.array(z.string())]),
+  });
+
+  const res200Schema = z.object({
+    qs: z.array(z.string()),
+    numberField: z.number(),
+    bigintField: z.string(),
+    booleanField: z.boolean(),
+    stringField: z.string(),
+    optionalStringField: z.optional(z.string()),
+    objectField: z.object({
+      bigintField: z.string(),
+      // ...
+    }),
+    numberArrayField: z.array(z.number()),
+    stringArrayField: z.array(z.string()),
+    unionField: z.union([
+      z.string(),
+      z.object({
+        stringArrayField: z.array(z.string()),
+        // ...
+      }),
+    ]),
+  });
+
+  const routeOpts = {
+    schema: {
+      querystring: qsSchema,
+      body: bodySchema,
+      response: {
+        200: res200Schema,
+      },
+    },
+  };
 
-  return fastify;
+  fastify.post('/demo', routeOpts, async (request, reply) => {
+    return reply.status(200).send({
+      qs: request.query.qs,
+      numberField: request.body.numberField,
+      bigintField: request.body.bigintField.toString(),
+      booleanField: request.body.booleanField,
+      stringField: request.body.stringField,
+      optionalStringField: request.body.optionalStringField,
+      objectField: {
+        bigintField: request.body.objectField.bigintField.toString(),
+      },
+      numberArrayField: request.body.numberArrayField,
+      stringArrayField: request.body.stringArrayField,
+      unionField: request.body.unionField,
+    });
+  });
 };
 
-const fastify = await createFastify(
+const fastify = await makeFastify(
   {
     path: '/swagger',
     title: '',
@@ -89,27 +158,69 @@ const fastify = await createFastify(
   { logger: false },
 );
 addTokenPaymentRoute(fastify);
+// Or fastify.register(addTokenPaymentRoute);
+addDemoRoute(fastify);
 
 const start = async () => {
   try {
-    await fastify.listen({ port: 8000 });
+    await fastify.ready();
+    await fastify.listen({ host: '127.0.0.1', port: 8000 });
+    console.log(`listening http://127.0.0.1:8000`);
   } catch (err) {
-    console.log(err);
+    console.error(err);
     process.exit(1);
   }
 };
+
 start();
+
+/*
+curl --request POST \
+  --url 'http://localhost:8000/demo?qs=key1&qs=key2' \
+  --header 'content-type: application/json' \
+  --data '{
+  "numberField": 10,
+  "bigintField": "10000",
+  "booleanField": true,
+  "stringField": "str",
+  "objectField": {
+    "bigintField": 10
+  },
+  "numberArrayField": [
+    0,
+    100,
+    1000
+  ],
+  "stringArrayField": [
+    "str1",
+    "str2"
+  ],
+  "unionField": {
+    "stringArrayField": [
+      "str1",
+      "str2"
+    ]
+  }
+}'
+*/
 ```
 
-To define a nested route don't forget to add `ZodTypeProvider` to the Fastify instance that is passed to the `register` method, to enable Zod typing validation:
+In order to use an instance of **AbstractLogger** instead of the default fastify logger, set the `logger` property of the fastify options to `false` and pass the **AbstractLogger** instance (wrapped in **FastifyLogger** class) to the `loggerInstance` property. **FastifyLogger** is an adapter for Pino interface compliance used in fastify.
 
 ```ts
-fastify.register(
-  (instance, opts, next) => {
-    const subFastify = instance.withTypeProvider<ZodTypeProvider>();
-    addTokenPaymentRoute(subFastify);
-    next();
+import { ConsoleLogger } from '@rosen-bridge/abstract-logger';
+import { makeFastify, FastifyLogger } from '@rosen-bridge/fastify-enhanced';
+
+const fastify = await makeFastify(
+  {
+    path: '/swagger',
+    title: '',
+    description: '',
+    version: '0.0.1',
+  },
+  {
+    logger: false,
+    loggerInstance: new FastifyLogger(new ConsoleLogger()),
   },
-  { prefix: 'subroute' },
 );
 ```

package/dist/fastify.d.ts

@@ -1,16 +1,9 @@
+import { FastifyBaseLogger, FastifyHttpOptions } from 'fastify';
 import 'zod-openapi/extend';
-import { FastifyWithZod, SwaggerOpts } from './types';
+import { FastifyWithZod, FastifyWithZodServer, SwaggerOpts } from './types';
 /**
  * creates an instance of Fastify with Zod validation library as validator and
  * type provider
  */
-export declare const makeFastify: (swaggerOpts?: SwaggerOpts, opts?: {
-    logger: boolean;
-}, jsonHandler?: {
-    parse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
-    stringify: {
-        (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
-        (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
-    };
-}) => Promise<FastifyWithZod>;
+export declare const makeFastify: (swaggerOpts?: SwaggerOpts, opts?: FastifyHttpOptions<FastifyWithZodServer, FastifyBaseLogger>) => Promise<FastifyWithZod>;
 //# sourceMappingURL=fastify.d.ts.map

package/dist/fastify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fastify.d.ts","sourceRoot":"","sources":["../lib/fastify.ts"],"names":[],"mappings":"AAOA,OAAO,oBAAoB,CAAC;AAM5B,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,cAAa,WAKZ,EACD;;CAAuB,EACvB;;;;;;CAIE,KACD,OAAO,CAAC,cAAc,CAkBxB,CAAC"}
+{"version":3,"file":"fastify.d.ts","sourceRoot":"","sources":["../lib/fastify.ts"],"names":[],"mappings":"AAAA,OAAgB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAOzE,OAAO,oBAAoB,CAAC;AAG5B,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,cAAa,WAKZ,EACD,OAAM,kBAAkB,CAAC,oBAAoB,EAAE,iBAAiB,CAE/D,KACA,OAAO,CAAC,cAAc,CAYxB,CAAC"}

package/dist/fastify.js

@@ -1,8 +1,6 @@
 import Fastify from 'fastify';
 import { fastifyZodOpenApiPlugin, serializerCompiler, validatorCompiler, } from 'fastify-zod-openapi';
 import 'zod-openapi/extend';
-import { JsonBigIntFactory } from '@rosen-bridge/json-bigint';
-import { makeJsonParser } from './jsonParser';
 import { registerSwagger } from './swagger';
 /**
  * creates an instance of Fastify with Zod validation library as validator and
@@ -13,17 +11,14 @@ export const makeFastify = async (swaggerOpts = {
     title: 'api',
     description: '',
     version: '0.0.1',
-}, opts = { logger: true }, jsonHandler = JsonBigIntFactory({
-    alwaysParseAsBig: false,
-    useNativeBigInt: true,
-    storeAsString: true,
-})) => {
+}, opts = {
+    logger: true,
+}) => {
     const fastify = Fastify(opts).withTypeProvider();
     fastify.setValidatorCompiler(validatorCompiler);
     fastify.setSerializerCompiler(serializerCompiler);
     await fastify.register(fastifyZodOpenApiPlugin);
-    fastify.addContentTypeParser('application/json', { parseAs: 'string' }, makeJsonParser(jsonHandler));
     await registerSwagger(fastify, swaggerOpts);
     return fastify;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export type { FastifyZodOpenApiTypeProvider } from 'fastify-zod-openapi';
 export * from './fastify';
 export * from './types';
+export type { FastifyRequest, FastifyReply, HookHandlerDoneFunction, } from 'fastify';
+export * from './logger';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACzE,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACzE,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,YAAY,EACV,cAAc,EACd,YAAY,EACZ,uBAAuB,GACxB,MAAM,SAAS,CAAC;AACjB,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from './fastify';
 export * from './types';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEZhc3RpZnlab2RPcGVuQXBpVHlwZVByb3ZpZGVyIH0gZnJvbSAnZmFzdGlmeS16b2Qtb3BlbmFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2Zhc3RpZnknO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=
+export * from './logger';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUM7QUFNeEIsY0FBYyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEZhc3RpZnlab2RPcGVuQXBpVHlwZVByb3ZpZGVyIH0gZnJvbSAnZmFzdGlmeS16b2Qtb3BlbmFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2Zhc3RpZnknO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgdHlwZSB7XG4gIEZhc3RpZnlSZXF1ZXN0LFxuICBGYXN0aWZ5UmVwbHksXG4gIEhvb2tIYW5kbGVyRG9uZUZ1bmN0aW9uLFxufSBmcm9tICdmYXN0aWZ5JztcbmV4cG9ydCAqIGZyb20gJy4vbG9nZ2VyJztcbiJdfQ==

package/dist/logger.d.ts

@@ -0,0 +1,94 @@
+import { FastifyBaseLogger, LogLevel } from 'fastify';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+export declare class FastifyLogger implements FastifyBaseLogger {
+    protected logger: AbstractLogger;
+    level: LogLevel;
+    /**
+     * creates a new instance
+     *
+     * @param logger - the underlying logger to delegate to
+     * @param level - for FastifyBaseLogger interface compliance
+     */
+    constructor(logger: AbstractLogger, level?: LogLevel);
+    /**
+     * no-op silent logger method (for Pino interface compliance)
+     * logs nothing regardless of input
+     */
+    silent: () => void;
+    /**
+     * logs a trace-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    trace: (...args: unknown[]) => void;
+    /**
+     * logs a debug-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    debug: (...args: unknown[]) => void;
+    /**
+     * logs an info-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    info: (...args: unknown[]) => void;
+    /**
+     * logs a warning-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    warn: (...args: unknown[]) => void;
+    /**
+     * logs an error-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    error: (...args: unknown[]) => void;
+    /**
+     * logs a critical/fatal-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    fatal: (...args: unknown[]) => void;
+    /**
+     * creates a child logger with bindings and optional configuration
+     * conforms to the Pino/Fastify logger interface
+     *
+     * @param bindings - Key-value pairs to attach to all logs from the child logger
+     * @returns A new FastifyBaseLogger instance (child logger)
+     */
+    child: (bindings: Record<string, unknown>) => FastifyBaseLogger;
+    /**
+     * utility function to map and serialize the arguments of fastify logger functions
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     */
+    private parseArgs;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../lib/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAKtD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,qBAAa,aAAc,YAAW,iBAAiB;IAQnD,SAAS,CAAC,MAAM,EAAE,cAAc;IACzB,KAAK,EAAE,QAAQ;IARxB;;;;;OAKG;gBAES,MAAM,EAAE,cAAc,EACzB,KAAK,GAAE,QAAiB;IAGjC;;;OAGG;IACH,MAAM,aAEJ;IAEF;;;;;;;;OAQG;IACH,KAAK,GAAI,GAAG,MAAM,OAAO,EAAE,UAGzB;IAEF;;;;;;;;OAQG;IACH,KAAK,GAAI,GAAG,MAAM,OAAO,EAAE,UAGzB;IAEF;;;;;;;;OAQG;IACH,IAAI,GAAI,GAAG,MAAM,OAAO,EAAE,UAGxB;IAEF;;;;;;;;OAQG;IACH,IAAI,GAAI,GAAG,MAAM,OAAO,EAAE,UAGxB;IAEF;;;;;;;;OAQG;IACH,KAAK,GAAI,GAAG,MAAM,OAAO,EAAE,UAGzB;IAEF;;;;;;;;OAQG;IACH,KAAK,GAAI,GAAG,MAAM,OAAO,EAAE,UAGzB;IAEF;;;;;;OAMG;IACH,KAAK,GAAI,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,iBAAiB,CAG5D;IAEF;;;;;OAKG;IACH,OAAO,CAAC,SAAS,CAwBf;CACH"}

package/dist/logger.js

@@ -0,0 +1,142 @@
+import { serializers } from 'fastify/lib/logger-pino.js';
+export class FastifyLogger {
+    logger;
+    level;
+    /**
+     * creates a new instance
+     *
+     * @param logger - the underlying logger to delegate to
+     * @param level - for FastifyBaseLogger interface compliance
+     */
+    constructor(logger, level = 'info') {
+        this.logger = logger;
+        this.level = level;
+    }
+    /**
+     * no-op silent logger method (for Pino interface compliance)
+     * logs nothing regardless of input
+     */
+    silent = () => {
+        // No-op
+    };
+    /**
+     * logs a trace-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    trace = (...args) => {
+        const { message, ...context } = this.parseArgs(...args);
+        this.logger.trace(message, context);
+    };
+    /**
+     * logs a debug-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    debug = (...args) => {
+        const { message, ...context } = this.parseArgs(...args);
+        this.logger.debug(message, context);
+    };
+    /**
+     * logs an info-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    info = (...args) => {
+        const { message, ...context } = this.parseArgs(...args);
+        this.logger.info(message, context);
+    };
+    /**
+     * logs a warning-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    warn = (...args) => {
+        const { message, ...context } = this.parseArgs(...args);
+        this.logger.warn(message, context);
+    };
+    /**
+     * logs an error-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    error = (...args) => {
+        const { message, ...context } = this.parseArgs(...args);
+        this.logger.error(message, context);
+    };
+    /**
+     * logs a critical/fatal-level message
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     *
+     * @param obj: object to be serialized
+     * @param msg: the log message to write
+     */
+    fatal = (...args) => {
+        const { message, ...context } = this.parseArgs(...args);
+        this.logger.critical(message, context);
+    };
+    /**
+     * creates a child logger with bindings and optional configuration
+     * conforms to the Pino/Fastify logger interface
+     *
+     * @param bindings - Key-value pairs to attach to all logs from the child logger
+     * @returns A new FastifyBaseLogger instance (child logger)
+     */
+    child = (bindings) => {
+        const childLogger = this.logger.child(JSON.stringify(bindings));
+        return new FastifyLogger(childLogger, this.level);
+    };
+    /**
+     * utility function to map and serialize the arguments of fastify logger functions
+     *
+     * the LogFn used in fastify logger has multiple signatures, for
+     *  more info see {@link FastifyLogFn}
+     */
+    parseArgs = (...args) => {
+        const [arg0, arg1] = args;
+        if (!arg0)
+            throw new Error('Fastify log parse failed');
+        let info = {};
+        if (typeof arg0 === 'string') {
+            // format: message [...splat]
+            info.message = arg0;
+        }
+        else {
+            // format: meta [message] [...splat]
+            info = arg0;
+            if (arg0 instanceof Error)
+                info = { err: arg0, message: arg0.message };
+            // serialize fastify req, res, err
+            for (const key in info) {
+                if (serializers[key])
+                    info[key] = serializers[key](info[key]);
+            }
+            if (arg1)
+                info.message = arg1;
+        }
+        return info;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../lib/logger.ts"],"names":[],"mappings":"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","sourcesContent":["import { FastifyBaseLogger, LogLevel } from 'fastify';\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { FastifyLogFn } from 'fastify';\nimport { serializers } from 'fastify/lib/logger-pino.js';\n\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\n\nexport class FastifyLogger implements FastifyBaseLogger {\n  /**\n   * creates a new instance\n   *\n   * @param logger - the underlying logger to delegate to\n   * @param level - for FastifyBaseLogger interface compliance\n   */\n  constructor(\n    protected logger: AbstractLogger,\n    public level: LogLevel = 'info',\n  ) {}\n\n  /**\n   * no-op silent logger method (for Pino interface compliance)\n   * logs nothing regardless of input\n   */\n  silent = () => {\n    // No-op\n  };\n\n  /**\n   * logs a trace-level message\n   *\n   * the LogFn used in fastify logger has multiple signatures, for\n   *  more info see {@link FastifyLogFn}\n   *\n   * @param obj: object to be serialized\n   * @param msg: the log message to write\n   */\n  trace = (...args: unknown[]) => {\n    const { message, ...context } = this.parseArgs(...args);\n    this.logger.trace(message as string, context);\n  };\n\n  /**\n   * logs a debug-level message\n   *\n   * the LogFn used in fastify logger has multiple signatures, for\n   *  more info see {@link FastifyLogFn}\n   *\n   * @param obj: object to be serialized\n   * @param msg: the log message to write\n   */\n  debug = (...args: unknown[]) => {\n    const { message, ...context } = this.parseArgs(...args);\n    this.logger.debug(message as string, context);\n  };\n\n  /**\n   * logs an info-level message\n   *\n   * the LogFn used in fastify logger has multiple signatures, for\n   *  more info see {@link FastifyLogFn}\n   *\n   * @param obj: object to be serialized\n   * @param msg: the log message to write\n   */\n  info = (...args: unknown[]) => {\n    const { message, ...context } = this.parseArgs(...args);\n    this.logger.info(message as string, context);\n  };\n\n  /**\n   * logs a warning-level message\n   *\n   * the LogFn used in fastify logger has multiple signatures, for\n   *  more info see {@link FastifyLogFn}\n   *\n   * @param obj: object to be serialized\n   * @param msg: the log message to write\n   */\n  warn = (...args: unknown[]) => {\n    const { message, ...context } = this.parseArgs(...args);\n    this.logger.warn(message as string, context);\n  };\n\n  /**\n   * logs an error-level message\n   *\n   * the LogFn used in fastify logger has multiple signatures, for\n   *  more info see {@link FastifyLogFn}\n   *\n   * @param obj: object to be serialized\n   * @param msg: the log message to write\n   */\n  error = (...args: unknown[]) => {\n    const { message, ...context } = this.parseArgs(...args);\n    this.logger.error(message as string, context);\n  };\n\n  /**\n   * logs a critical/fatal-level message\n   *\n   * the LogFn used in fastify logger has multiple signatures, for\n   *  more info see {@link FastifyLogFn}\n   *\n   * @param obj: object to be serialized\n   * @param msg: the log message to write\n   */\n  fatal = (...args: unknown[]) => {\n    const { message, ...context } = this.parseArgs(...args);\n    this.logger.critical(message as string, context);\n  };\n\n  /**\n   * creates a child logger with bindings and optional configuration\n   * conforms to the Pino/Fastify logger interface\n   *\n   * @param bindings - Key-value pairs to attach to all logs from the child logger\n   * @returns A new FastifyBaseLogger instance (child logger)\n   */\n  child = (bindings: Record<string, unknown>): FastifyBaseLogger => {\n    const childLogger = this.logger.child(JSON.stringify(bindings));\n    return new FastifyLogger(childLogger, this.level);\n  };\n\n  /**\n   * utility function to map and serialize the arguments of fastify logger functions\n   *\n   * the LogFn used in fastify logger has multiple signatures, for\n   *  more info see {@link FastifyLogFn}\n   */\n  private parseArgs = (...args: unknown[]): Record<string, unknown> => {\n    const [arg0, arg1] = args;\n    if (!arg0) throw new Error('Fastify log parse failed');\n\n    let info: Record<string, unknown> = {};\n\n    if (typeof arg0 === 'string') {\n      // format: message [...splat]\n      info.message = arg0;\n    } else {\n      // format: meta [message] [...splat]\n      info = arg0 as Record<string, unknown>;\n\n      if (arg0 instanceof Error) info = { err: arg0, message: arg0.message };\n\n      // serialize fastify req, res, err\n      for (const key in info) {\n        if (serializers[key]) info[key] = serializers[key](info[key]);\n      }\n\n      if (arg1) info.message = arg1;\n    }\n\n    return info;\n  };\n}\n"]}

package/dist/swagger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swagger.d.ts","sourceRoot":"","sources":["../lib/swagger.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,4BAA4B,EAG7B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,4BAA4B,CACxD,WAAW,CAqCZ,CAAC"}
+{"version":3,"file":"swagger.d.ts","sourceRoot":"","sources":["../lib/swagger.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,4BAA4B,EAG7B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,4BAA4B,CACxD,WAAW,CA2CZ,CAAC"}

package/dist/swagger.js

@@ -13,6 +13,15 @@ export const registerSwagger = async (fastify, opts) => {
                 description: opts.description,
                 version: opts.version,
             },
+            components: {
+                securitySchemes: {
+                    apiKey: {
+                        type: 'apiKey',
+                        name: 'Api-Key',
+                        in: 'header',
+                    },
+                },
+            },
         },
         transform: fastifyZodOpenApiTransform,
         transformObject: fastifyZodOpenApiTransformObject,
@@ -33,11 +42,8 @@ export const registerSwagger = async (fastify, opts) => {
         },
         staticCSP: true,
         transformStaticCSP: (header) => header,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        transformSpecification: (swaggerObject, request, reply) => {
-            return swaggerObject;
-        },
+        transformSpecification: (swaggerObject) => swaggerObject,
         transformSpecificationClone: true,
     });
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types.d.ts

@@ -1,11 +1,12 @@
 import { FastifyBaseLogger, FastifyInstance } from 'fastify';
 import type { FastifyZodOpenApiTypeProvider } from 'fastify-zod-openapi';
 import * as http from 'http';
-export type FastifyWithZod = FastifyInstance<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>, http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, FastifyBaseLogger, FastifyZodOpenApiTypeProvider>;
-export interface SwaggerOpts {
+export type FastifyWithZodServer = http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+export type FastifyWithZod = FastifyInstance<FastifyWithZodServer, http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, FastifyBaseLogger, FastifyZodOpenApiTypeProvider>;
+export type SwaggerOpts = {
     path: string;
     title: string;
     description: string;
     version: string;
-}
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,MAAM,MAAM,cAAc,GAAG,eAAe,CAC1C,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,eAAe,EAAE,OAAO,IAAI,CAAC,cAAc,CAAC,EACpE,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,EACzC,iBAAiB,EACjB,6BAA6B,CAC9B,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAC5C,OAAO,IAAI,CAAC,eAAe,EAC3B,OAAO,IAAI,CAAC,cAAc,CAC3B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,eAAe,CAC1C,oBAAoB,EACpB,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,EACzC,iBAAiB,EACjB,6BAA6B,CAC9B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC"}

package/dist/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZhc3RpZnlCYXNlTG9nZ2VyLCBGYXN0aWZ5SW5zdGFuY2UgfSBmcm9tICdmYXN0aWZ5JztcbmltcG9ydCB0eXBlIHsgRmFzdGlmeVpvZE9wZW5BcGlUeXBlUHJvdmlkZXIgfSBmcm9tICdmYXN0aWZ5LXpvZC1vcGVuYXBpJztcbmltcG9ydCAqIGFzIGh0dHAgZnJvbSAnaHR0cCc7XG5cbmV4cG9ydCB0eXBlIEZhc3RpZnlXaXRoWm9kID0gRmFzdGlmeUluc3RhbmNlPFxuICBodHRwLlNlcnZlcjx0eXBlb2YgaHR0cC5JbmNvbWluZ01lc3NhZ2UsIHR5cGVvZiBodHRwLlNlcnZlclJlc3BvbnNlPixcbiAgaHR0cC5JbmNvbWluZ01lc3NhZ2UsXG4gIGh0dHAuU2VydmVyUmVzcG9uc2U8aHR0cC5JbmNvbWluZ01lc3NhZ2U+LFxuICBGYXN0aWZ5QmFzZUxvZ2dlcixcbiAgRmFzdGlmeVpvZE9wZW5BcGlUeXBlUHJvdmlkZXJcbj47XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3dhZ2dlck9wdHMge1xuICBwYXRoOiBzdHJpbmc7XG4gIHRpdGxlOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIHZlcnNpb246IHN0cmluZztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZhc3RpZnlCYXNlTG9nZ2VyLCBGYXN0aWZ5SW5zdGFuY2UgfSBmcm9tICdmYXN0aWZ5JztcbmltcG9ydCB0eXBlIHsgRmFzdGlmeVpvZE9wZW5BcGlUeXBlUHJvdmlkZXIgfSBmcm9tICdmYXN0aWZ5LXpvZC1vcGVuYXBpJztcbmltcG9ydCAqIGFzIGh0dHAgZnJvbSAnaHR0cCc7XG5cbmV4cG9ydCB0eXBlIEZhc3RpZnlXaXRoWm9kU2VydmVyID0gaHR0cC5TZXJ2ZXI8XG4gIHR5cGVvZiBodHRwLkluY29taW5nTWVzc2FnZSxcbiAgdHlwZW9mIGh0dHAuU2VydmVyUmVzcG9uc2Vcbj47XG5cbmV4cG9ydCB0eXBlIEZhc3RpZnlXaXRoWm9kID0gRmFzdGlmeUluc3RhbmNlPFxuICBGYXN0aWZ5V2l0aFpvZFNlcnZlcixcbiAgaHR0cC5JbmNvbWluZ01lc3NhZ2UsXG4gIGh0dHAuU2VydmVyUmVzcG9uc2U8aHR0cC5JbmNvbWluZ01lc3NhZ2U+LFxuICBGYXN0aWZ5QmFzZUxvZ2dlcixcbiAgRmFzdGlmeVpvZE9wZW5BcGlUeXBlUHJvdmlkZXJcbj47XG5cbmV4cG9ydCB0eXBlIFN3YWdnZXJPcHRzID0ge1xuICBwYXRoOiBzdHJpbmc7XG4gIHRpdGxlOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIHZlcnNpb246IHN0cmluZztcbn07XG4iXX0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/fastify-enhanced",
-  "version": "2.0.2",
+  "version": "3.1.0-d5b86d3e",
   "description": "a wrapper around fastify web framework to make it even better",
   "repository": {
     "type": "git",
@@ -30,12 +30,17 @@
   "dependencies": {
     "@fastify/swagger": "^9.5.1",
     "@fastify/swagger-ui": "^5.2.3",
-    "@rosen-bridge/json-bigint": "^1.1.0",
+    "@rosen-bridge/abstract-logger": "^4.0.0",
     "fastify": "^5.3.3",
     "fastify-zod-openapi": "^4.1.2",
-    "zod": "^3.25.56",
     "zod-openapi": "^4.2.4"
   },
+  "devDependencies": {
+    "zod": "^3.21.4"
+  },
+  "peerDependencies": {
+    "zod": "^3.21.4"
+  },
   "engines": {
     "node": ">=22.18.0",
     "npm": "11.6.2"

package/dist/jsonParser.d.ts

@@ -1,4 +0,0 @@
-import { ContentTypeParserDoneFunction } from 'fastify/types/content-type-parser';
-import { JsonBigIntFactory } from '@rosen-bridge/json-bigint';
-export declare const makeJsonParser: (jsonHandler: ReturnType<typeof JsonBigIntFactory>) => (req: unknown, body: string, done: ContentTypeParserDoneFunction) => void;
-//# sourceMappingURL=jsonParser.d.ts.map

package/dist/jsonParser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonParser.d.ts","sourceRoot":"","sources":["../lib/jsonParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAElF,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,eAAO,MAAM,cAAc,GACzB,aAAa,UAAU,CAAC,OAAO,iBAAiB,CAAC,MAEzC,KAAK,OAAO,EAAE,MAAM,MAAM,EAAE,MAAM,6BAA6B,SAgBxE,CAAC"}

package/dist/jsonParser.js

@@ -1,18 +0,0 @@
-export const makeJsonParser = (jsonHandler) => {
-    return (req, body, done) => {
-        try {
-            const json = jsonHandler.parse(body);
-            done(null, json);
-        }
-        catch (err) {
-            if (err instanceof Error || err === null) {
-                done(err, undefined);
-            }
-            else {
-                const wrappedErr = new Error(`An unexpected error occurred while trying to parse request body`, { cause: err });
-                done(wrappedErr, undefined);
-            }
-        }
-    };
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvblBhcnNlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL2xpYi9qc29uUGFyc2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUM1QixXQUFpRCxFQUNqRCxFQUFFO0lBQ0YsT0FBTyxDQUFDLEdBQVksRUFBRSxJQUFZLEVBQUUsSUFBbUMsRUFBRSxFQUFFO1FBQ3pFLElBQUksQ0FBQztZQUNILE1BQU0sSUFBSSxHQUFHLFdBQVcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDckMsSUFBSSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztRQUNuQixDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLElBQUksR0FBRyxZQUFZLEtBQUssSUFBSSxHQUFHLEtBQUssSUFBSSxFQUFFLENBQUM7Z0JBQ3pDLElBQUksQ0FBQyxHQUFHLEVBQUUsU0FBUyxDQUFDLENBQUM7WUFDdkIsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLE1BQU0sVUFBVSxHQUFHLElBQUksS0FBSyxDQUMxQixpRUFBaUUsRUFDakUsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLENBQ2YsQ0FBQztnQkFDRixJQUFJLENBQUMsVUFBVSxFQUFFLFNBQVMsQ0FBQyxDQUFDO1lBQzlCLENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQyxDQUFDO0FBQ0osQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udGVudFR5cGVQYXJzZXJEb25lRnVuY3Rpb24gfSBmcm9tICdmYXN0aWZ5L3R5cGVzL2NvbnRlbnQtdHlwZS1wYXJzZXInO1xuXG5pbXBvcnQgeyBKc29uQmlnSW50RmFjdG9yeSB9IGZyb20gJ0Byb3Nlbi1icmlkZ2UvanNvbi1iaWdpbnQnO1xuXG5leHBvcnQgY29uc3QgbWFrZUpzb25QYXJzZXIgPSAoXG4gIGpzb25IYW5kbGVyOiBSZXR1cm5UeXBlPHR5cGVvZiBKc29uQmlnSW50RmFjdG9yeT4sXG4pID0+IHtcbiAgcmV0dXJuIChyZXE6IHVua25vd24sIGJvZHk6IHN0cmluZywgZG9uZTogQ29udGVudFR5cGVQYXJzZXJEb25lRnVuY3Rpb24pID0+IHtcbiAgICB0cnkge1xuICAgICAgY29uc3QganNvbiA9IGpzb25IYW5kbGVyLnBhcnNlKGJvZHkpO1xuICAgICAgZG9uZShudWxsLCBqc29uKTtcbiAgICB9IGNhdGNoIChlcnIpIHtcbiAgICAgIGlmIChlcnIgaW5zdGFuY2VvZiBFcnJvciB8fCBlcnIgPT09IG51bGwpIHtcbiAgICAgICAgZG9uZShlcnIsIHVuZGVmaW5lZCk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICBjb25zdCB3cmFwcGVkRXJyID0gbmV3IEVycm9yKFxuICAgICAgICAgIGBBbiB1bmV4cGVjdGVkIGVycm9yIG9jY3VycmVkIHdoaWxlIHRyeWluZyB0byBwYXJzZSByZXF1ZXN0IGJvZHlgLFxuICAgICAgICAgIHsgY2F1c2U6IGVyciB9LFxuICAgICAgICApO1xuICAgICAgICBkb25lKHdyYXBwZWRFcnIsIHVuZGVmaW5lZCk7XG4gICAgICB9XG4gICAgfVxuICB9O1xufTtcbiJdfQ==