Can a custom type be created in Typescript that permits objects but excludes Errors?

Question

Can a custom type be created in Typescript that permits objects but excludes Errors?

Currently working on resolving an odd scenario with a logger. Essentially, calls like log({ info: 'information' }) function as expected, but log(new Error()) falls short.
While no solution is readily available, the goal is to override the log method to accept all objects except errors as parameters. Is this achievable in Typescript?

An attempt was made using conditional types:

type NotError<T> = T extends Error ? never : T;

log(NotError<object>): void

Despite this approach, calling log(new Error()) still does not produce any errors or warnings.

Side note: The issue stems from all objects having non-enumerable properties, although our only encountered scenario involving such objects are Errors.

typescript

Answer 1

Answer №1

The issue lies in the fact that NotError<object> will simply be resolved to object. To achieve what you desire, it is necessary to make use of generics:

function log<T>(notError: NotError<T>): void {
  console.log(notError);
}

For further information, refer to: https://www.typescriptlang.org/docs/handbook/generics.html

Answer 2

The issue lies in the fact that NotError<object> will simply be resolved to object. To achieve what you desire, it is necessary to make use of generics:

function log<T>(notError: NotError<T>): void {
  console.log(notError);
}

For further information, refer to: https://www.typescriptlang.org/docs/handbook/generics.html

Answer 3

Answer №2

Take a look at this illustrative case

const { createLogger, format } = require('winston');
const LEVEL = Symbol.for('level');

/**
 * Capture only the messages that correspond to the specified `level`.
 */
function filterOnly(level) {
  return format(function (info) {
    if (info[LEVEL] === level) {
      return info;
    }
  })();
}

const logger = createLogger({
  format: zformat,
  transports: [
    // specifically for 'info' level
    new transprts.File({
      level: 'info',
      format: filterOnly('info'),
      filename: 'logs/access.log',
    })name: 'logs/combined.log',
    })
  ]
});

For additional information, refer to filtering object details

Answer 4

Take a look at this illustrative case

const { createLogger, format } = require('winston');
const LEVEL = Symbol.for('level');

/**
 * Capture only the messages that correspond to the specified `level`.
 */
function filterOnly(level) {
  return format(function (info) {
    if (info[LEVEL] === level) {
      return info;
    }
  })();
}

const logger = createLogger({
  format: zformat,
  transports: [
    // specifically for 'info' level
    new transprts.File({
      level: 'info',
      format: filterOnly('info'),
      filename: 'logs/access.log',
    })name: 'logs/combined.log',
    })
  ]
});

For additional information, refer to filtering object details

Can a custom type be created in Typescript that permits objects but excludes Errors?

Answer №1

Answer №2

Similar questions

Splitting Angular modules into separate projects with identical configurations

What is the process of creating a callback in Angular using TypeScript?

Unauthorized error encountered when making an Ajax GET request to Azure Ad Graph API

Can TestCafe be used to simulate pressing the key combination (Ctrl + +)?

Challenges with Typescript Integration in Visual Studio 2013

Issue with Datepicker validation in Angular 5 and Angular Material

Sorting orders using Firebase

Extract TypeScript classes and interfaces from a consolidated file

An error has occurred: Type 'x' is not compatible with type 'x' (during Vercel deployment)

Navigating the request body within an API route in next.js

What is the best way to pass a state within a route component in react-router?

TypeScript type that accommodates all object interfaces

Error encountered when attempting to utilize ngTemplate to embed filter within a table

Error: This property is not available on either 'false' or 'HTMLAudioElement' types

Required Field Validation - Ensuring a Field is Mandatory Based on Property Length Exceeding 0

Managing Observable<Person[]> in ng-bootstrap typeahead instead of Observable<string[]>: a complete guide

Revamping a function

Explore Angular's ability to transform a nested observable object into a different object

Master your code with Rxjs optimization

Exploring the Material Drawer functionality within an Angular application