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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @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

package/README.md

@@ -32,37 +32,26 @@ 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 = {
@@ -77,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: '',
@@ -95,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/index.d.ts

@@ -2,4 +2,5 @@ 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;AACxB,YAAY,EACV,cAAc,EACd,YAAY,EACZ,uBAAuB,GACxB,MAAM,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEZhc3RpZnlab2RPcGVuQXBpVHlwZVByb3ZpZGVyIH0gZnJvbSAnZmFzdGlmeS16b2Qtb3BlbmFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2Zhc3RpZnknO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgdHlwZSB7XG4gIEZhc3RpZnlSZXF1ZXN0LFxuICBGYXN0aWZ5UmVwbHksXG4gIEhvb2tIYW5kbGVyRG9uZUZ1bmN0aW9uLFxufSBmcm9tICdmYXN0aWZ5JztcbiJdfQ==
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/fastify-enhanced",
-  "version": "3.0.0",
+  "version": "3.1.0-d5b86d3e",
   "description": "a wrapper around fastify web framework to make it even better",
   "repository": {
     "type": "git",
@@ -30,6 +30,7 @@
   "dependencies": {
     "@fastify/swagger": "^9.5.1",
     "@fastify/swagger-ui": "^5.2.3",
+    "@rosen-bridge/abstract-logger": "^4.0.0",
     "fastify": "^5.3.3",
     "fastify-zod-openapi": "^4.1.2",
     "zod-openapi": "^4.2.4"