カスタムエラー

Result.fail() でエラーを作成する際、単純な文字列やジェネリックなErrorオブジェクトではなく、カスタムエラーの使用を強くお勧めします。このガイドでは、カスタムエラーとは何か、なぜ有益なのか、そして効果的に作成する方法を説明します。

カスタムエラーとは？

カスタムエラーは、ジェネリックなErrorオブジェクトよりも多くの構造とコンテキストを提供する特殊化されたエラークラスです。一般的に採用されるカスタムエラーには主に2つの形式があります。

1. カスタムエラークラス（推奨）

カスタムエラークラスは組み込みの Error クラスを継承し、追加の機能を提供する方法です。

import { import ResultResult } from '@praha/byethrow';
import { import zz } from 'zod';

class class ValidationErrorValidationError extends var Error: ErrorConstructorError {
  public override readonly ValidationError.name: "ValidationError"name = 'ValidationError';

  constructor(message: stringmessage: string, options: ErrorOptions | undefinedoptions?: ErrorOptions) {
    super(message: stringmessage, options: ErrorOptions | undefinedoptions);
  }
}

// Result.fail()での使用
const const validateEmail: (email: string) => Result.Result<string, ValidationError>validateEmail = (email: stringemail: string): import ResultResult.type Result<T, E> = Result.Success<T> | Result.Failure<E>A union type representing either a success or a failure.
@typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@exampleimport { Result } from '@praha/byethrow';

const doSomething = (): Result.Result<number, string> => {
  return Math.random() > 0.5
    ? { type: 'Success', value: 10 }
    : { type: 'Failure', error: 'Oops' };
};
@categoryCore  TypesResult<string, class ValidationErrorValidationError> => {
  return import ResultResult.const pipe: <string, Result.Result<string, readonly StandardSchemaV1<Input = unknown, Output = Input>.Issue[]>, Result.Result<string, ValidationError>>(a: string, ab: (a: string) => Result.Result<string, readonly StandardSchemaV1.Issue[]>, bc: (b: Result.Result<string, readonly StandardSchemaV1.Issue[]>) => Result.Result<string, ValidationError>) => Result.Result<string, ValidationError> (+25 overloads)pipe(
    email: stringemail,
    import ResultResult.const parse: <z.ZodString>(schema: z.ZodString) => (value: unknown) => Result.Result<string, readonly StandardSchemaV1<Input = unknown, Output = Input>.Issue[]> (+1 overload)parse(import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string().ZodString.email(params?: string | z.core.$ZodCheckEmailParams): z.ZodString@deprecatedUse  z.email() instead.email()),
    import ResultResult.const mapError: <Result.Result<string, readonly StandardSchemaV1<Input = unknown, Output = Input>.Issue[]>, ValidationError>(fn: (a: readonly StandardSchemaV1.Issue[]) => ValidationError) => (result: Result.Result<string, readonly StandardSchemaV1.Issue[]>) => Result.Result<string, ValidationError> (+1 overload)mapError((error: readonly StandardSchemaV1.Issue[]error) => new constructor ValidationError(message: string, options?: ErrorOptions): ValidationErrorValidationError('Invalid email format', { ErrorOptions.cause?: unknowncause: error: readonly StandardSchemaV1.Issue[]error })),
  );
};

2. 識別可能なタグを持つオブジェクト

プレーンなオブジェクトに識別可能なプロパティを持たせる事でエラー型として使用することもできます。

import { import ResultResult } from '@praha/byethrow';
import { import zz } from 'zod';

type type ValidationError = {
    type: "ValidationError";
    message: string;
    value: string;
}
ValidationError = {
  type: "ValidationError"type: 'ValidationError';
  message: stringmessage: string;
  value: stringvalue: string;
};

const const validateEmail: (email: string) => Result.Result<string, ValidationError>validateEmail = (email: stringemail: string): import ResultResult.type Result<T, E> = Result.Success<T> | Result.Failure<E>A union type representing either a success or a failure.
@typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@exampleimport { Result } from '@praha/byethrow';

const doSomething = (): Result.Result<number, string> => {
  return Math.random() > 0.5
    ? { type: 'Success', value: 10 }
    : { type: 'Failure', error: 'Oops' };
};
@categoryCore  TypesResult<string, type ValidationError = {
    type: "ValidationError";
    message: string;
    value: string;
}
ValidationError> => {
  return import ResultResult.const pipe: <string, Result.Result<string, readonly StandardSchemaV1<Input = unknown, Output = Input>.Issue[]>, Result.Result<string, {
    readonly type: "ValidationError";
    readonly message: "Invalid email format";
    readonly value: string;
}>>(a: string, ab: (a: string) => Result.Result<string, readonly StandardSchemaV1.Issue[]>, bc: (b: Result.Result<string, readonly StandardSchemaV1.Issue[]>) => Result.Result<string, {
    readonly type: "ValidationError";
    readonly message: "Invalid email format";
    readonly value: string;
}>) => Result.Result<...> (+25 overloads)
pipe(
    email: stringemail,
    import ResultResult.const parse: <z.ZodString>(schema: z.ZodString) => (value: unknown) => Result.Result<string, readonly StandardSchemaV1<Input = unknown, Output = Input>.Issue[]> (+1 overload)parse(import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string().ZodString.email(params?: string | z.core.$ZodCheckEmailParams): z.ZodString@deprecatedUse  z.email() instead.email()),
    import ResultResult.const mapError: <Result.Result<string, readonly StandardSchemaV1<Input = unknown, Output = Input>.Issue[]>, {
    readonly type: "ValidationError";
    readonly message: "Invalid email format";
    readonly value: string;
}>(fn: (a: readonly StandardSchemaV1.Issue[]) => {
    readonly type: "ValidationError";
    readonly message: "Invalid email format";
    readonly value: string;
}) => (result: Result.Result<string, readonly StandardSchemaV1.Issue[]>) => Result.Result<string, {
    readonly type: "ValidationError";
    readonly message: "Invalid email format";
    readonly value: string;
}> (+1 overload)
mapError((error: readonly StandardSchemaV1.Issue[]error) => ({
      type: "ValidationError"type: 'ValidationError',
      message: "Invalid email format"message: 'Invalid email format',
      value: stringvalue: email: stringemail,
    })),
  );
};

なぜカスタムエラークラスを使うのか？

どちらのアプローチでも機能しますが、以下の理由からカスタムErrorクラスの使用をお勧めします。

スタックトレースの利用可能性

カスタムErrorクラスは自動的にスタックトレースをキャプチャするため、デバッグが非常に容易になります。

import { import ResultResult } from '@praha/byethrow';

class class DatabaseErrorDatabaseError extends var Error: ErrorConstructorError {
  public override readonly DatabaseError.name: "DatabaseError"name = 'DatabaseError';

  constructor(message: stringmessage: string, options: ErrorOptions | undefinedoptions?: ErrorOptions) {
    super(message: stringmessage, options: ErrorOptions | undefinedoptions);
  }
}

const const fetchUser: (id: string) => Result.Result<User, DatabaseError>fetchUser = (id: stringid: string): import ResultResult.type Result<T, E> = Result.Success<T> | Result.Failure<E>A union type representing either a success or a failure.
@typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@exampleimport { Result } from '@praha/byethrow';

const doSomething = (): Result.Result<number, string> => {
  return Math.random() > 0.5
    ? { type: 'Success', value: 10 }
    : { type: 'Failure', error: 'Oops' };
};
@categoryCore  TypesResult<type User = {
    id: string;
    name: string;
}
User, class DatabaseErrorDatabaseError> => {
  try {
    // データベース操作...
  } catch (function (local var) error: unknownerror) {
    // スタックトレースはエラーが発生した正確な場所を示します
    return import ResultResult.const fail: <DatabaseError>(error: DatabaseError) => Result.Result<never, DatabaseError> (+1 overload)fail(new constructor DatabaseError(message: string, options?: ErrorOptions): DatabaseErrorDatabaseError('Failed to fetch user'));
  }
};

`cause` オプションによるエラーチェイン

カスタムErrorクラスは cause オプションをサポートしており、元のエラーコンテキストを保持できます。

import { import ResultResult } from '@praha/byethrow';

class class DatabaseErrorDatabaseError extends var Error: ErrorConstructorError {
  public override readonly DatabaseError.name: "DatabaseError"name = 'DatabaseError';

  constructor(message: stringmessage: string, options: ErrorOptions | undefinedoptions?: ErrorOptions) {
    super(message: stringmessage, options: ErrorOptions | undefinedoptions);
  }
}

const const fetchUser: (id: string) => Result.Result<User, DatabaseError>fetchUser = (id: stringid: string): import ResultResult.type Result<T, E> = Result.Success<T> | Result.Failure<E>A union type representing either a success or a failure.
@typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@exampleimport { Result } from '@praha/byethrow';

const doSomething = (): Result.Result<number, string> => {
  return Math.random() > 0.5
    ? { type: 'Success', value: 10 }
    : { type: 'Failure', error: 'Oops' };
};
@categoryCore  TypesResult<type User = {
    id: string;
    name: string;
}
User, class DatabaseErrorDatabaseError> => {
  try {
    // データベース操作...
  } catch (function (local var) error: unknownerror) {
    // 元のエラーをcauseとして保持
    return import ResultResult.const fail: <DatabaseError>(error: DatabaseError) => Result.Result<never, DatabaseError> (+1 overload)fail(new constructor DatabaseError(message: string, options?: ErrorOptions): DatabaseErrorDatabaseError('Failed to fetch user', {
      ErrorOptions.cause?: unknowncause: function (local var) error: unknownerror 
    }));
  }
};

推奨：`@praha/error-factory` を使用する

カスタムエラークラスを効率的に作成するために、@praha/error-factory の使用をお勧めします。このライブラリはボイラープレートコードを削減し、一貫したエラー構造を保証します。

インストール

npm

yarn

pnpm

bun

deno

npm install @praha/error-factory

Resultとの基本的な使い方

まず、必要なカスタムエラーを定義します。

import { const ErrorFactory: {
    <Name extends string, Message extends string, Fields extends ErrorFields>(props: {
        name: Name;
        message: Message | ((fields: Fields) => Message);
        fields?: Fields;
    }): ErrorConstructor<Name, Message, Fields>;
    fields<Fields extends ErrorFields>(): Fields;
}
ErrorFactory } from '@praha/error-factory';

class class ValidationErrorValidationError extends ErrorFactory<"ValidationError", "Invalid input provided", ErrorFields>(props: {
    name: "ValidationError";
    message: "Invalid input provided" | ((fields: ErrorFields) => "Invalid input provided");
    fields?: ErrorFields | undefined;
}): (new (options?: ErrorOptions) => Error & Readonly<{
    name: "ValidationError";
    message: "Invalid input provided";
}>) & {
    name: "ValidationError";
}
ErrorFactory({
  name: "ValidationError"name: 'ValidationError',
  message: "Invalid input provided" | ((fields: ErrorFields) => "Invalid input provided")message: 'Invalid input provided',
}) {}

class class QueryErrorQueryError extends ErrorFactory<"QueryError", "An error occurred while executing a query", {
    query: string;
}>(props: {
    name: "QueryError";
    message: "An error occurred while executing a query" | ((fields: {
        query: string;
    }) => "An error occurred while executing a query");
    fields?: {
        query: string;
    } | undefined;
}): (new (options: ErrorOptions & {
    query: string;
}) => Error & Readonly<{
    name: "QueryError";
    message: "An error occurred while executing a query";
}> & Readonly<{
    query: string;
}>) & {
    name: "QueryError";
}
ErrorFactory({
  name: "QueryError"name: 'QueryError',
  message: "An error occurred while executing a query" | ((fields: {
    query: string;
}) => "An error occurred while executing a query")
message: 'An error occurred while executing a query',
  fields?: {
    query: string;
} | undefined
fields: const ErrorFactory: {
    <Name extends string, Message extends string, Fields extends ErrorFields>(props: {
        name: Name;
        message: Message | ((fields: Fields) => Message);
        fields?: Fields;
    }): ErrorConstructor<Name, Message, Fields>;
    fields<Fields extends ErrorFields>(): Fields;
}
ErrorFactory.fields<{
    query: string;
}>(): {
    query: string;
}
fields<{ query: stringquery: string }>(),
}) {}

class class NotFoundErrorNotFoundError extends ErrorFactory<"NotFoundError", "Resource not found", ErrorFields>(props: {
    name: "NotFoundError";
    message: "Resource not found" | ((fields: ErrorFields) => "Resource not found");
    fields?: ErrorFields | undefined;
}): (new (options?: ErrorOptions) => Error & Readonly<{
    name: "NotFoundError";
    message: "Resource not found";
}>) & {
    name: "NotFoundError";
}
ErrorFactory({
  name: "NotFoundError"name: 'NotFoundError',
  message: "Resource not found" | ((fields: ErrorFields) => "Resource not found")message: 'Resource not found',
}) {}

次に、先ほど定義したカスタムエラーと Result を一緒に返す関数を作成します。

import { import ResultResult } from '@praha/byethrow';
import { import zz } from 'zod';

// Result操作でカスタムエラーを使用
const const validateId: (id: string) => Result.Result<string, ValidationError>validateId = (id: stringid: string) => {
  return import ResultResult.const pipe: <string, Result.Result<string, readonly StandardSchemaV1<Input = unknown, Output = Input>.Issue[]>, Result.Result<string, ValidationError>>(a: string, ab: (a: string) => Result.Result<string, readonly StandardSchemaV1.Issue[]>, bc: (b: Result.Result<string, readonly StandardSchemaV1.Issue[]>) => Result.Result<string, ValidationError>) => Result.Result<string, ValidationError> (+25 overloads)pipe(
    id: stringid,
    import ResultResult.const parse: <z.ZodString>(schema: z.ZodString) => (value: unknown) => Result.Result<string, readonly StandardSchemaV1<Input = unknown, Output = Input>.Issue[]> (+1 overload)parse(import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string()._ZodString<$ZodStringInternals<string>>.startsWith(value: string, params?: string | z.core.$ZodCheckStartsWithParams): z.ZodStringstartsWith('u')),
    import ResultResult.const mapError: <Result.Result<string, readonly StandardSchemaV1<Input = unknown, Output = Input>.Issue[]>, ValidationError>(fn: (a: readonly StandardSchemaV1.Issue[]) => ValidationError) => (result: Result.Result<string, readonly StandardSchemaV1.Issue[]>) => Result.Result<string, ValidationError> (+1 overload)mapError((error: readonly StandardSchemaV1.Issue[]error) => new constructor ValidationError(options?: ErrorOptions): ValidationErrorValidationError({ ErrorOptions.cause?: unknowncause: error: readonly StandardSchemaV1.Issue[]error })),
  );
};

const const executeQuery: (sql: string) => Result.ResultAsync<QueryResult, QueryError>executeQuery = (sql: stringsql: string) => {
  return import ResultResult.try<() => Promise<QueryResult>, QueryError>(options: {
    try: () => Promise<QueryResult>;
    catch: (error: unknown) => QueryError;
}): Result.ResultAsync<QueryResult, QueryError> (+3 overloads)
export try
Executes a function that may throw and wraps the result in a
Result
or
ResultAsync
.
You can use either a custom catch handler or rely on the safe: true option
to assume the function cannot throw.
@function@typeParamT  - The function type to execute (sync or async) or a Promise type.@typeParamE  - The error type to return if catch is used.@returnsA  Result or ResultAsync wrapping the function's return value or the caught error.@exampleSync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => {
const x = Math.random() * 10 - 5;
if (x < 0) throw new Error('Negative!');
return x * 2;
},
catch: (error) => new Error('Oops!', { cause: error }),
});

// result is Result<number, Error>
@exampleSync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Math.random() + 1,
});

// result is Result<number, never>
@exampleAsync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => fetch('/api/data'),
catch: (error) => new Error('Fetch failed', { cause: error }),
});

// result is ResultAsync<Response, Error>
@exampleAsync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Promise.resolve('ok'),
});

// result is ResultAsync<string, never>
@categoryCreatorstry({
    try: () => Promise<QueryResult>try: () => const database: {
    query: (sql: string) => Promise<QueryResult>;
}
database.query: (sql: string) => Promise<QueryResult>query(sql: stringsql),
    catch: (error: unknown) => QueryErrorcatch: (error: unknownerror) => new constructor QueryError(options: ErrorOptions & {
    query: string;
}): QueryError
QueryError({ query: stringquery: sql: stringsql, ErrorOptions.cause?: unknowncause: error: unknownerror }),
  });
};

// すべてを組み合わせる
const const findUser: (id: string) => Result.ResultAsync<{
    readonly id: string;
    readonly name: string;
}, ValidationError | QueryError | NotFoundError>
findUser = (id: stringid: string) => {
  return import ResultResult.const pipe: <Result.Result<string, ValidationError>, Result.ResultAsync<QueryResult, ValidationError | QueryError>, Result.ResultAsync<{
    readonly id: string;
    readonly name: string;
}, ValidationError | QueryError | NotFoundError>>(a: Result.Result<string, ValidationError>, ab: (a: Result.Result<string, ValidationError>) => Result.ResultAsync<QueryResult, ValidationError | QueryError>, bc: (b: Result.ResultAsync<...>) => Result.ResultAsync<...>) => Result.ResultAsync<...> (+25 overloads)
pipe(
    const validateId: (id: string) => Result.Result<string, ValidationError>validateId(id: stringid),
    import ResultResult.const andThen: <Result.Result<string, ValidationError>, Result.ResultAsync<QueryResult, QueryError>>(fn: (a: string) => Result.ResultAsync<QueryResult, QueryError>) => (result: Result.Result<string, ValidationError>) => Result.ResultAsync<QueryResult, ValidationError | QueryError> (+1 overload)andThen((id: stringid) => const executeQuery: (sql: string) => Result.ResultAsync<QueryResult, QueryError>executeQuery(`SELECT * FROM users WHERE id = '${id: stringid}'`)),
    import ResultResult.const andThen: <Result.ResultAsync<QueryResult, ValidationError | QueryError>, Result.Failure<NotFoundError> | Result.Success<{
    readonly id: string;
    readonly name: string;
}>>(fn: (a: QueryResult) => Result.Failure<NotFoundError> | Result.Success<{
    readonly id: string;
    readonly name: string;
}>) => (result: Result.ResultAsync<QueryResult, ValidationError | QueryError>) => Result.ResultAsync<...> (+1 overload)
andThen((row: QueryResultrow) => {
      if (!row: QueryResultrow) {
        return import ResultResult.const fail: <NotFoundError>(error: NotFoundError) => Result.Result<never, NotFoundError> (+1 overload)fail(new constructor NotFoundError(options?: ErrorOptions): NotFoundErrorNotFoundError());
      }
      return import ResultResult.const succeed: <{
    readonly id: string;
    readonly name: string;
}>(value: {
    readonly id: string;
    readonly name: string;
}) => Result.Result<{
    readonly id: string;
    readonly name: string;
}, never> (+1 overload)
succeed({ id: stringid: row: QueryResultrow.stringid, name: stringname: row: QueryResultrow.stringname });
    }),
  );
};

最後に、関数を実行して適切にハンドリングします。

// 実行してエラーをハンドリング
const const result: Result.Result<{
    readonly id: string;
    readonly name: string;
}, ValidationError | QueryError | NotFoundError>
result = await const findUser: (id: string) => Result.ResultAsync<{
    readonly id: string;
    readonly name: string;
}, ValidationError | QueryError | NotFoundError>
findUser('u123');
if (import ResultResult.const isSuccess: <{
    readonly id: string;
    readonly name: string;
}>(result: Result.Result<{
    readonly id: string;
    readonly name: string;
}, unknown>) => result is Result.Success<{
    readonly id: string;
    readonly name: string;
}>
Type guard to check if a
Result
is a
Success
.
@function@typeParamT  - The type of the success value.@paramresult  - The Result to check.@returnstrue if the result is a Success, otherwise false.@exampleimport { Result } from '@praha/byethrow';

const result: Result.Result<number, string> = { type: 'Success', value: 10 };
if (Result.isSuccess(result)) {
  console.log(result.value); // Safe access to value
}
@categoryType  GuardsisSuccess(const result: Result.Result<{
    readonly id: string;
    readonly name: string;
}, ValidationError | QueryError | NotFoundError>
result)) {
  var console: ConsoleThe console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr

Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@seesourceconsole.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout

See util.format() for more information.
@sincev0 .1.100log(const result: Result.Success<{
    readonly id: string;
    readonly name: string;
}>
result.value: {
    readonly id: string;
    readonly name: string;
}
value);
} else {
  // 各エラータイプを個別にハンドリング
  switch (const result: Result.Failure<ValidationError | QueryError | NotFoundError>result.error: ValidationError | QueryError | NotFoundErrorerror.Error.name: "ValidationError" | "QueryError" | "NotFoundError"name) {
    case 'ValidationError':
      var console: ConsoleThe console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr

Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@seesourceconsole.Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)Prints to stderr with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const code = 5;
console.error('error #%d', code);
// Prints: error #5, to stderr
console.error('error', code);
// Prints: error 5, to stderr

If formatting elements (e.g. %d) are not found in the first string then
util.inspect() is called on each argument and the
resulting string values are concatenated. See util.format()
for more information.
@sincev0 .1.100error('Validation error:', const result: Result.Failure<ValidationError | QueryError | NotFoundError>result.error: ValidationErrorerror.Error.message: "Invalid input provided"message);
      break;
    case 'QueryError':
      var console: ConsoleThe console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr

Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@seesourceconsole.Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)Prints to stderr with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const code = 5;
console.error('error #%d', code);
// Prints: error #5, to stderr
console.error('error', code);
// Prints: error 5, to stderr

If formatting elements (e.g. %d) are not found in the first string then
util.inspect() is called on each argument and the
resulting string values are concatenated. See util.format()
for more information.
@sincev0 .1.100error('Query error:', const result: Result.Failure<ValidationError | QueryError | NotFoundError>result.error: QueryErrorerror.Error.message: "An error occurred while executing a query"message, 'Query:', const result: Result.Failure<ValidationError | QueryError | NotFoundError>result.error: QueryErrorerror.query: stringquery);
      break;
    case 'NotFoundError':
      var console: ConsoleThe console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr

Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@seesourceconsole.Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)Prints to stderr with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const code = 5;
console.error('error #%d', code);
// Prints: error #5, to stderr
console.error('error', code);
// Prints: error 5, to stderr

If formatting elements (e.g. %d) are not found in the first string then
util.inspect() is called on each argument and the
resulting string values are concatenated. See util.format()
for more information.
@sincev0 .1.100error('Not found error:', const result: Result.Failure<ValidationError | QueryError | NotFoundError>result.error: NotFoundErrorerror.Error.message: "Resource not found"message);
      break;
  }
}

#カスタムエラー