Thanks for reporting!

Can you provide steps to reproduce? We often need a reproducible example, e.g. some code that allows someone else to recreate your problem by just copying and pasting it. If it involves more than a couple of different file, create a new repository on GitHub and add a link to that.

We have the same issue but its because we are assigning the fastify instance to a variable with type FastifyInstance. Since we don't specify the generics the logger type defaults to FastifyBaseLogger, which doesn't seem to be compatible with any pino instance. Seems like the new FastifyBaseLogger type is not correct.

We have the same issue but its because we are assigning the fastify instance to a variable with type FastifyInstance. Since we don't specify the generics the logger type defaults to FastifyBaseLogger, which doesn't seem to be compatible with any pino instance. Seems like the new FastifyBaseLogger type is not correct.

Yeah, we also assign the server to a variable of type FastifyInstance and it fails starting v4.20.0.

@mcollina this is example:

import { fastify, type FastifyInstance } from "fastify";
import { pino } from "pino";

// all latest versions
const log2 = pino();
const app2: FastifyInstance = fastify({
	logger: log2,
});

Maybe related to #4928

Why should it be related #4928?

@ziimakc I've literally tested your example with the top-most version of Fastify, Pino and TypeScript and I could not reproduce. Please provide a full repro including the tsconfig.json and all relevant assets.

@mcollina here it is: https://github.com/ZiiMakc/fastify-type-errr

run:

pnpm i
pnpm lint

This is confirmed only with "strict": true in the tsconfig.json.

There seem to be an issue with:

Type 'FastifyBaseLogger' is not assignable to type 'Logger<LoggerOptions | DestinationStream>'

Which I think it's due to:

not being compatible with

https://github.com/pinojs/pino/blob/91a3505cfaef323f565e3cfe93f5d5077320faff/pino.d.ts#L83

I don't know why this problem shows up only in strict mode and how to change this. At a first glance these seems very similar. However some of those generics are slightly different.

Anyhow, this fixes your problem:

import { fastify, type FastifyInstance, type FastifyBaseLogger } from "fastify";
import { pino } from "pino";

// all latest versions
const log = pino();
const app: FastifyInstance = fastify({
  logger: log as FastifyBaseLogger,
});

We faced the same problem, and the only solution is to use the as keyword which is not ideal, but it does the job for now.

In the

const log = pino();
const app: FastifyInstance = fastify({
  logger: log,
});

case, we are assigning FastifyInstance<..., pino.Logger, ...> to FastifyInstance<..., FastifyBaseLogger, ...>, so the type of FastifyInstance<..., pino.Logger, ...>.childLoggerFactory (or some other functions) need to be compatible with FastifyInstance<..., FastifyBaseLogger, ...>.childLoggerFactory.

And the childLoggerFactory function takes a this parameter as type FastifyInstance, so it means we need to assign a (this: FastifyInstance<..., pino.Logger, ...>): ... to (this: FastifyInstance<..., FastifyBaseLogger, ...>): ....

And function parameters in TypeScript are contravariant when strict: true or strictFunctionTypes: true, which means even though pino.Logger is the subtype of FastifyBaseLogger (FastifyBaseLogger is pino.BaseLogger with a child function), the function (this: FastifyInstance<..., pino.Logger, ...>): ... is the basetype of (this: FastifyInstance<..., FastifyBaseLogger, ...>): ..., and we can't assign a basetype to a subtype.

https://www.typescriptlang.org/docs/handbook/type-compatibility.html#comparing-two-functions

This should also work, app should be FastifyInstance<..., pino.Logger, ...> now.

const log = pino();
const app = fastify({
  logger: log,
});

How would you fix it?

@flakey5 could you take a look?

From my testing I believe I can second what @NotEvenANeko said about this.

It's not so much FastifyBaseLogger being incompatible with Logger<LoggerOptions | DestinationStream>, this works without error

const log = pino();
const a: FastifyBaseLogger = log;
const b: boolean | FastifyLoggerOptions<RawServerDefault> & PinoLoggerOptions | Logger = log; // type of the `logger` property in `FastifyOptions`

but instead pino.Logger becoming the base type rather than FastifyBaseLogger. So for example a function abc(logger: Logger) needs either an instance of a pino.Logger or something that extends pino.Logger.

It does appear to be connected to #4760, removing childLoggerFactory from the FastifyInstance type fixes the problem

Few things we can do to fix it (starting with good ending with bad),

1. Swapping this line

   fastify/types/instance.d.ts

   Line 484 in 9ab24be

   childLoggerFactory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;

   for childLoggerFactory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, FastifyBaseLogger, TypeProvider>; - Should be good, but it does throw off the precedent of just passing in Logger
2. Replace this line

   fastify/types/instance.d.ts

   Line 123 in 9ab24be

   Logger extends FastifyBaseLogger = FastifyBaseLogger,

   with Logger = any - Not great, decreased type safety and might be breaking
3. Remove Logger from FastifyInstance's generic fields and always use FastifyBaseLogger - Not great, definitely breaking

@flakey5 would you like to send a PR for option 1?