カスタムエラー

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 = string, Message extends string = string, Fields extends ErrorFields = ErrorFields>(props: {
        name?: Name;
        message: Message | ((fields: Fields) => Message);
        fields?: Fields;
    }): ErrorConstructor<Name, Message, Fields>;
    fields<Fields extends ErrorFields>(): Fields;
}
A factory function that creates a base class for custom error types.
Extend the returned class to define a custom error with a consistent structure,
reducing boilerplate and ensuring type safety across your application.
@typeParamName  - Inferred as a string literal type from props.name when provided,
or defaults to string when name is omitted.@typeParamMessage  - Inferred as a string literal type from props.message when it is a string,
or defaults to string when message is a function.@typeParamFields  - Inferred from props.fields (via ErrorFactory.fields).
Defaults to the base ErrorFields constraint when fields is omitted.@paramprops  - Configuration for the error class.@paramprops .name - The value set as the name property on both the class and each instance.
When omitted, name is inferred as string and set to new.target.name at construction time,
which resolves to the name of the concrete subclass. Note that omitting name disables
type narrowing via the name property; use name explicitly or instanceof for narrowing.@paramprops .message - The error message. Can be a static string or a function that receives
the custom fields and returns a string, enabling dynamic message generation.@paramprops .fields - A type-level placeholder that declares the additional fields the error
instance will carry. Use ErrorFactory.fields to create this value.
When omitted, no additional fields are added to the instance.@returnsAn  abstract base class typed as ErrorConstructor that should be extended
to produce a concrete custom error class.@exampleBasic  usage
class NotFoundError extends ErrorFactory({
name: 'NotFoundError',
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name);    // "NotFoundError"
console.error(error.message); // "Resource not found"
@exampleOmitting  name
class NotFoundError extends ErrorFactory({
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name); // "NotFoundError" (resolved from new.target.name)
@exampleWith  cause
class DatabaseError extends ErrorFactory({
name: 'DatabaseError',
message: 'A database error occurred',
}) {}

const error = new DatabaseError({ cause: new Error('Connection failed') });
console.error(error.cause); // Error: Connection failed
@exampleWith  additional fields
class QueryError extends ErrorFactory({
name: 'QueryError',
message: 'An error occurred while executing a query',
fields: ErrorFactory.fields<{ query: string }>(),
}) {}

const error = new QueryError({ query: 'SELECT * FROM users' });
console.error(error.query); // "SELECT * FROM users"
@exampleDynamic  message
class ValidationError extends ErrorFactory({
name: 'ValidationError',
message: ({ field }) => `Validation failed for field '${field}'`,
fields: ErrorFactory.fields<{ field: string }>(),
}) {}

const error = new ValidationError({ field: 'email' });
console.error(error.message); // "Validation failed for field 'email'"
ErrorFactory } from '@praha/error-factory';

class class ValidationErrorValidationError extends ErrorFactory<"ValidationError", "Invalid input provided", ErrorFields>(props: {
    name?: "ValidationError" | undefined;
    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";
}
A factory function that creates a base class for custom error types.
Extend the returned class to define a custom error with a consistent structure,
reducing boilerplate and ensuring type safety across your application.
@typeParamName  - Inferred as a string literal type from props.name when provided,
or defaults to string when name is omitted.@typeParamMessage  - Inferred as a string literal type from props.message when it is a string,
or defaults to string when message is a function.@typeParamFields  - Inferred from props.fields (via ErrorFactory.fields).
Defaults to the base ErrorFields constraint when fields is omitted.@paramprops  - Configuration for the error class.@paramprops .name - The value set as the name property on both the class and each instance.
When omitted, name is inferred as string and set to new.target.name at construction time,
which resolves to the name of the concrete subclass. Note that omitting name disables
type narrowing via the name property; use name explicitly or instanceof for narrowing.@paramprops .message - The error message. Can be a static string or a function that receives
the custom fields and returns a string, enabling dynamic message generation.@paramprops .fields - A type-level placeholder that declares the additional fields the error
instance will carry. Use ErrorFactory.fields to create this value.
When omitted, no additional fields are added to the instance.@returnsAn  abstract base class typed as ErrorConstructor that should be extended
to produce a concrete custom error class.@exampleBasic  usage
class NotFoundError extends ErrorFactory({
name: 'NotFoundError',
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name);    // "NotFoundError"
console.error(error.message); // "Resource not found"
@exampleOmitting  name
class NotFoundError extends ErrorFactory({
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name); // "NotFoundError" (resolved from new.target.name)
@exampleWith  cause
class DatabaseError extends ErrorFactory({
name: 'DatabaseError',
message: 'A database error occurred',
}) {}

const error = new DatabaseError({ cause: new Error('Connection failed') });
console.error(error.cause); // Error: Connection failed
@exampleWith  additional fields
class QueryError extends ErrorFactory({
name: 'QueryError',
message: 'An error occurred while executing a query',
fields: ErrorFactory.fields<{ query: string }>(),
}) {}

const error = new QueryError({ query: 'SELECT * FROM users' });
console.error(error.query); // "SELECT * FROM users"
@exampleDynamic  message
class ValidationError extends ErrorFactory({
name: 'ValidationError',
message: ({ field }) => `Validation failed for field '${field}'`,
fields: ErrorFactory.fields<{ field: string }>(),
}) {}

const error = new ValidationError({ field: 'email' });
console.error(error.message); // "Validation failed for field 'email'"
ErrorFactory({
  name?: "ValidationError" | undefinedname: '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" | undefined;
    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";
}
A factory function that creates a base class for custom error types.
Extend the returned class to define a custom error with a consistent structure,
reducing boilerplate and ensuring type safety across your application.
@typeParamName  - Inferred as a string literal type from props.name when provided,
or defaults to string when name is omitted.@typeParamMessage  - Inferred as a string literal type from props.message when it is a string,
or defaults to string when message is a function.@typeParamFields  - Inferred from props.fields (via ErrorFactory.fields).
Defaults to the base ErrorFields constraint when fields is omitted.@paramprops  - Configuration for the error class.@paramprops .name - The value set as the name property on both the class and each instance.
When omitted, name is inferred as string and set to new.target.name at construction time,
which resolves to the name of the concrete subclass. Note that omitting name disables
type narrowing via the name property; use name explicitly or instanceof for narrowing.@paramprops .message - The error message. Can be a static string or a function that receives
the custom fields and returns a string, enabling dynamic message generation.@paramprops .fields - A type-level placeholder that declares the additional fields the error
instance will carry. Use ErrorFactory.fields to create this value.
When omitted, no additional fields are added to the instance.@returnsAn  abstract base class typed as ErrorConstructor that should be extended
to produce a concrete custom error class.@exampleBasic  usage
class NotFoundError extends ErrorFactory({
name: 'NotFoundError',
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name);    // "NotFoundError"
console.error(error.message); // "Resource not found"
@exampleOmitting  name
class NotFoundError extends ErrorFactory({
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name); // "NotFoundError" (resolved from new.target.name)
@exampleWith  cause
class DatabaseError extends ErrorFactory({
name: 'DatabaseError',
message: 'A database error occurred',
}) {}

const error = new DatabaseError({ cause: new Error('Connection failed') });
console.error(error.cause); // Error: Connection failed
@exampleWith  additional fields
class QueryError extends ErrorFactory({
name: 'QueryError',
message: 'An error occurred while executing a query',
fields: ErrorFactory.fields<{ query: string }>(),
}) {}

const error = new QueryError({ query: 'SELECT * FROM users' });
console.error(error.query); // "SELECT * FROM users"
@exampleDynamic  message
class ValidationError extends ErrorFactory({
name: 'ValidationError',
message: ({ field }) => `Validation failed for field '${field}'`,
fields: ErrorFactory.fields<{ field: string }>(),
}) {}

const error = new ValidationError({ field: 'email' });
console.error(error.message); // "Validation failed for field 'email'"
ErrorFactory({
  name?: "QueryError" | undefinedname: '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 = string, Message extends string = string, Fields extends ErrorFields = ErrorFields>(props: {
        name?: Name;
        message: Message | ((fields: Fields) => Message);
        fields?: Fields;
    }): ErrorConstructor<Name, Message, Fields>;
    fields<Fields extends ErrorFields>(): Fields;
}
A factory function that creates a base class for custom error types.
Extend the returned class to define a custom error with a consistent structure,
reducing boilerplate and ensuring type safety across your application.
@typeParamName  - Inferred as a string literal type from props.name when provided,
or defaults to string when name is omitted.@typeParamMessage  - Inferred as a string literal type from props.message when it is a string,
or defaults to string when message is a function.@typeParamFields  - Inferred from props.fields (via ErrorFactory.fields).
Defaults to the base ErrorFields constraint when fields is omitted.@paramprops  - Configuration for the error class.@paramprops .name - The value set as the name property on both the class and each instance.
When omitted, name is inferred as string and set to new.target.name at construction time,
which resolves to the name of the concrete subclass. Note that omitting name disables
type narrowing via the name property; use name explicitly or instanceof for narrowing.@paramprops .message - The error message. Can be a static string or a function that receives
the custom fields and returns a string, enabling dynamic message generation.@paramprops .fields - A type-level placeholder that declares the additional fields the error
instance will carry. Use ErrorFactory.fields to create this value.
When omitted, no additional fields are added to the instance.@returnsAn  abstract base class typed as ErrorConstructor that should be extended
to produce a concrete custom error class.@exampleBasic  usage
class NotFoundError extends ErrorFactory({
name: 'NotFoundError',
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name);    // "NotFoundError"
console.error(error.message); // "Resource not found"
@exampleOmitting  name
class NotFoundError extends ErrorFactory({
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name); // "NotFoundError" (resolved from new.target.name)
@exampleWith  cause
class DatabaseError extends ErrorFactory({
name: 'DatabaseError',
message: 'A database error occurred',
}) {}

const error = new DatabaseError({ cause: new Error('Connection failed') });
console.error(error.cause); // Error: Connection failed
@exampleWith  additional fields
class QueryError extends ErrorFactory({
name: 'QueryError',
message: 'An error occurred while executing a query',
fields: ErrorFactory.fields<{ query: string }>(),
}) {}

const error = new QueryError({ query: 'SELECT * FROM users' });
console.error(error.query); // "SELECT * FROM users"
@exampleDynamic  message
class ValidationError extends ErrorFactory({
name: 'ValidationError',
message: ({ field }) => `Validation failed for field '${field}'`,
fields: ErrorFactory.fields<{ field: string }>(),
}) {}

const error = new ValidationError({ field: 'email' });
console.error(error.message); // "Validation failed for field 'email'"
ErrorFactory.fields<{
    query: string;
}>(): {
    query: string;
}
fields<{ query: stringquery: string }>(),
}) {}

class class NotFoundErrorNotFoundError extends ErrorFactory<"NotFoundError", "Resource not found", ErrorFields>(props: {
    name?: "NotFoundError" | undefined;
    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";
}
A factory function that creates a base class for custom error types.
Extend the returned class to define a custom error with a consistent structure,
reducing boilerplate and ensuring type safety across your application.
@typeParamName  - Inferred as a string literal type from props.name when provided,
or defaults to string when name is omitted.@typeParamMessage  - Inferred as a string literal type from props.message when it is a string,
or defaults to string when message is a function.@typeParamFields  - Inferred from props.fields (via ErrorFactory.fields).
Defaults to the base ErrorFields constraint when fields is omitted.@paramprops  - Configuration for the error class.@paramprops .name - The value set as the name property on both the class and each instance.
When omitted, name is inferred as string and set to new.target.name at construction time,
which resolves to the name of the concrete subclass. Note that omitting name disables
type narrowing via the name property; use name explicitly or instanceof for narrowing.@paramprops .message - The error message. Can be a static string or a function that receives
the custom fields and returns a string, enabling dynamic message generation.@paramprops .fields - A type-level placeholder that declares the additional fields the error
instance will carry. Use ErrorFactory.fields to create this value.
When omitted, no additional fields are added to the instance.@returnsAn  abstract base class typed as ErrorConstructor that should be extended
to produce a concrete custom error class.@exampleBasic  usage
class NotFoundError extends ErrorFactory({
name: 'NotFoundError',
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name);    // "NotFoundError"
console.error(error.message); // "Resource not found"
@exampleOmitting  name
class NotFoundError extends ErrorFactory({
message: 'Resource not found',
}) {}

const error = new NotFoundError();
console.error(error.name); // "NotFoundError" (resolved from new.target.name)
@exampleWith  cause
class DatabaseError extends ErrorFactory({
name: 'DatabaseError',
message: 'A database error occurred',
}) {}

const error = new DatabaseError({ cause: new Error('Connection failed') });
console.error(error.cause); // Error: Connection failed
@exampleWith  additional fields
class QueryError extends ErrorFactory({
name: 'QueryError',
message: 'An error occurred while executing a query',
fields: ErrorFactory.fields<{ query: string }>(),
}) {}

const error = new QueryError({ query: 'SELECT * FROM users' });
console.error(error.query); // "SELECT * FROM users"
@exampleDynamic  message
class ValidationError extends ErrorFactory({
name: 'ValidationError',
message: ({ field }) => `Validation failed for field '${field}'`,
fields: ErrorFactory.fields<{ field: string }>(),
}) {}

const error = new ValidationError({ field: 'email' });
console.error(error.message); // "Validation failed for field 'email'"
ErrorFactory({
  name?: "NotFoundError" | undefinedname: '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: <Result.Result<{
    readonly id: string;
    readonly name: string;
}, ValidationError | QueryError | NotFoundError>>(result: Result.Result<{
    readonly id: string;
    readonly name: string;
}, ValidationError | QueryError | NotFoundError>) => result is Result.Success<{
    readonly id: string;
    readonly name: string;
}>
Type guard to check if a
Result
is a
Success 
.
@function@typeParamR  - The type of the result to check.@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: Consoleconsole.Console.log(...data: any[]): voidThe console.log() static method outputs a message to the console.
MDN Referencelog(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: Consoleconsole.Console.error(...data: any[]): voidThe console.error() static method outputs a message to the console at the "error" log level. The message is only displayed to the user if the console is configured to display error output. In most cases, the log level is configured within the console UI. The message may be formatted as an error, with red colors and call stack information.
MDN Referenceerror('Validation error:', const result: Result.Failure<ValidationError | QueryError | NotFoundError>result.error: ValidationErrorerror.Error.message: "Invalid input provided"message);
      break;
    case 'QueryError':
      var console: Consoleconsole.Console.error(...data: any[]): voidThe console.error() static method outputs a message to the console at the "error" log level. The message is only displayed to the user if the console is configured to display error output. In most cases, the log level is configured within the console UI. The message may be formatted as an error, with red colors and call stack information.
MDN Referenceerror('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: Consoleconsole.Console.error(...data: any[]): voidThe console.error() static method outputs a message to the console at the "error" log level. The message is only displayed to the user if the console is configured to display error output. In most cases, the log level is configured within the console UI. The message may be formatted as an error, with red colors and call stack information.
MDN Referenceerror('Not found error:', const result: Result.Failure<ValidationError | QueryError | NotFoundError>result.error: NotFoundErrorerror.Error.message: "Resource not found"message);
      break;
  }
}

#カスタムエラー