Creating a universal wrapper function to serve as a logging tool?

Question

Creating a universal wrapper function to serve as a logging tool?

Currently, I am working on a generic JS function that can wrap any other function. The purpose of this wrapper is to execute the wrapped function, log the input and output events, and then return the output for "transparent" logging. However, as I attempt to transition this function to TypeScript while maintaining type information for both the wrapped function and its output, I am facing some complexity.

Here is my current progress:

const syncLogger = <T>(f: T) => (...args: unknown[]): ReturnType<T> => {
  let value;
  try {
    value = f(...args);
    functionLogger('info', f, value, ...args); //logging
  } catch (error) {
    functionLogger('error', f, error.message, ...args); //logging
    throw error;
  }
  return value;
};

and here is how it should be utilized:

const myLoggedFunction = syncLogger(originalFunction);

The main issue arises with the args, which are used as the input for functions. I am struggling to find a way to inform TypeScript that these arguments correspond precisely to the parameters of the original function being wrapped.

typescript generics typescript-generics

Answer 1

Answer №1

For a more versatile approach, I suggest making the syncLogger function generic in both the arguments tuple A and the return type R:

const syncLogger = <A extends any[], R>(f: (...a: A) => R) => (
  ...args: A
): R => {
  let value;
  try {
    value = f(...args);
    functionLogger("info", f, value, ...args); // actual logging
  } catch (error) {
    functionLogger("error", f, error.message, ...args); //actual logging
    throw error;
  }
  return value;
};

This modification allows for expected behavior:

function originalFunction(x: string, y: number): boolean {
  return (x <= y.toFixed())
}

const myLoggedFunction = syncLogger(originalFunction); // works fine
// const myLoggedFunction: (x: string, y: number) => boolean

const bool = myLoggedFunction("121", 123); // logs info: originalFunction, true, "121", 123
console.log(bool) // prints: true

In addition, TypeScript's support for higher-order type inference from generic functions starting with version 3.4 enables successful use cases even when the original function is generic:

const loggingItself = syncLogger(syncLogger);
// Prior to TS 3.4: 😢
// const loggingItself: (...args: any[]) => (...args: any[]) => {} 
// From TS 3.4 onwards: 😊
// const loggingItself: <A extends any[], R>(f: (...a: A) => R) => (...args: A) => R

I hope this information proves helpful. All the best!

Link to code

Answer 2

For a more versatile approach, I suggest making the syncLogger function generic in both the arguments tuple A and the return type R:

const syncLogger = <A extends any[], R>(f: (...a: A) => R) => (
  ...args: A
): R => {
  let value;
  try {
    value = f(...args);
    functionLogger("info", f, value, ...args); // actual logging
  } catch (error) {
    functionLogger("error", f, error.message, ...args); //actual logging
    throw error;
  }
  return value;
};

This modification allows for expected behavior:

function originalFunction(x: string, y: number): boolean {
  return (x <= y.toFixed())
}

const myLoggedFunction = syncLogger(originalFunction); // works fine
// const myLoggedFunction: (x: string, y: number) => boolean

const bool = myLoggedFunction("121", 123); // logs info: originalFunction, true, "121", 123
console.log(bool) // prints: true

In addition, TypeScript's support for higher-order type inference from generic functions starting with version 3.4 enables successful use cases even when the original function is generic:

const loggingItself = syncLogger(syncLogger);
// Prior to TS 3.4: 😢
// const loggingItself: (...args: any[]) => (...args: any[]) => {} 
// From TS 3.4 onwards: 😊
// const loggingItself: <A extends any[], R>(f: (...a: A) => R) => (...args: A) => R

I hope this information proves helpful. All the best!

Link to code

Creating a universal wrapper function to serve as a logging tool?

Answer №1

Similar questions

Developing a databound listview in Ionic: A step-by-step guide

Does the Typescript compiler sometimes skip adding braces?

Retrieve new data upon each screen entry

Transform TypeScript class into an object

Understanding the significance of an exclamation point preceding a period

Struggling with sluggish performance on a certain project within VS Code

What could be causing the Intellisense errors in Visual Studio 2015 that say "Cannot find module 'angular2/core'"?

Having trouble getting my Angular project up and running - facing issues with dependency tree resolution (ERESOLVE)

Ionic 2: Unveiling the Flipclock Component

The argument provided is a string type, which cannot be assigned to a parameter expecting an object with a 'results' property of type string

Create a class with additional attributes to support different types of options

TypeScript encounters a self-referencing type alias circularly

Accessing the currently operating WS server instance with NodeJS

Formatting numbers in Angular 2 to include a space every three zeros in a money amount

Unable to locate the Chart object within the chartjs-plugin-labels.js file

Consolidating Typescript modules into a single .js file

What is the best method for retrieving GET parameters in an Angular2 application?

Setting various colors for different plots within a single chart: A step-by-step guide

UI and `setState` out of sync

When using TypeScript, the tls.TLSSocket() function may trigger an error mentioning the absence of a "socket" parameter