[Bug]: logform v2.7.0 breaks usages of its types without being a major version

[ItsHarper]

The problem

Code that uses logform types (in my case a custom Winston formatter) and previously passed type-checking in logform 2.6.1 can in some cases no longer pass type-checking with logform 2.7.0, because usages of any were replaced with unknown. #325 was a good change, but it should have been made in a major release of logform, whichwinston-transport and winston should not have updated to without bumping their major versions as well.

#325 should be reverted and postponed until logform 4.0.

What version of Logform presents the issue?

2.7.0

What version of Node are you using?

v20.18.0

If this is a TypeScript issue, what version of TypeScript are you using?

v5.5.4

If this worked in a previous version of Logform, which was it?

2.6.1

Minimum Working Example

import { format } from "winston";

// https://github.com/winstonjs/winston/issues/1660#issuecomment-512226578
const fixErrorsFormat = format((info) => {
    // Only modify the info it there was an error
    if (info.stack === undefined) {
        return info;
    }

    const { message } = info;

    // Get the original error message
    const errorMessage =
        info[Symbol.for("splat")] &&
        info[Symbol.for("splat")][0] &&
        info[Symbol.for("splat")][0].message;

    // Check that the original error message was concatenated to the message
    if (
        errorMessage === undefined ||
        message.length <= errorMessage.length ||
        !message.endsWith(errorMessage)
    ) {
        return info;
    }

    // Slice off the original error message from the log message
    info.message = message.slice(0, errorMessage.length * -1).trim();
    return info;
});

Additional information

No response

🔎 Search Terms

typescript, unknown, any, breaking change

[GianniCodato-PixartPrinting]

Same issue also on our codebase (but function printf instead of format)

[alumni]

yes, it's 55f3d8c changing any to unknown in TransformableInfo. Would be nice if TransformableInfo would be a generic, so we could pass it our own keys.

[Cooldude2606]

Issue also with changing any to unknown for opts param to TransformFunction which was introduced in 55f3d8c
Breaking change caused a build pipeline fail and required a hot patch.

[alexweej]

Same problem at my org. Is there actually anyone objecting to 'fixing' this in a new semver minor? Curious if there's consensus. Thanks all!

[apanjwani0]

Please fix this.
55f3d8c#commitcomment-148941012

[dscalzi]

@DABH

[ab-pm]

As a workaround, I've declaration-merged an overload for format and printf:

import type { Logform } from 'winston';


export interface MyCustomLogInfo extends Logform.TransformableInfo {
	level: LogLevel;
	message: string;
	error: Error | undefined;
	exception?: boolean;
	rejection?: boolean;
	timestamp?: string;
}
// Hacky workaround for https://github.com/winstonjs/logform/issues/336
declare module 'logform' {
	export function format(transform: (info: MyCustomLogInfo, opts?: unknown) => MyCustomLogInfo | boolean): FormatWrap;
	export namespace format {
		function printf(templateFunction: (info: MyCustomLogInfo) => string): Format;
	}
}

This made my Format-combination code work again. Of course this is far from perfect, the TransformFunction that format takes actually can do arbitrary transformations from T1 to T2, i.e. it should be

export type TransformFunction<T1 extends TransformableInfo, T2 extends TransformableInfo> = (info: T1, opts?: unknown) => T2 | boolean;

then format, FormatWrap and Format would need to get similar generic type parameters, and combine would get really complicated. So use this only if your formatting callbacks never really change the structure of the info object.

Notice that even the node.js Stream.Transform declaration shirks proper typing and uses any, so if you want to correctly typecheck a stream pipeline (like winston transports) you'll face an uphill battle.

[Alfagun74]

Me waiting for this to be fixed