#Custom 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);
  }
}

// Usage with 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.@example
import { 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 })),
  );
};

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.@example
import { 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, {
    type: "ValidationError";
    message: string;
    value: string;
}>>(a: string, ab: (a: string) => Result.Result<string, readonly StandardSchemaV1.Issue[]>, bc: (b: Result.Result<string, readonly StandardSchemaV1.Issue[]>) => Result.Result<string, {
    type: "ValidationError";
    message: string;
    value: string;
}>) => Result.Result<string, {
    type: "ValidationError";
    message: string;
    value: string;
}> (+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[]>, {
    type: "ValidationError";
    message: string;
    value: string;
}>(fn: (a: readonly StandardSchemaV1.Issue[]) => {
    type: "ValidationError";
    message: string;
    value: string;
}) => (result: Result.Result<string, readonly StandardSchemaV1.Issue[]>) => Result.Result<string, {
    type: "ValidationError";
    message: string;
    value: string;
}> (+1 overload)
mapError((
error: readonly StandardSchemaV1.Issue[]error) => ({
      
type: "ValidationError"type: 'ValidationError',
      
message: stringmessage: 'Invalid email format',
      
value: stringvalue: 
email: stringemail,
    })),
  );
};

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.@example
import { 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 {
    // Database operation...
  } catch (
function (local var) error: unknownerror) {
    // The stack trace will show exactly where the error occurred
    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'));
  }
};

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.@example
import { 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 {
    // Database operation...
  } catch (
function (local var) error: unknownerror) {
    // Preserve the original error as 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 
    }));
  }
};

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',
}) {}

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

// Use custom errors in Result operations
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: {
    immediate: true;
    try: () => Promise<QueryResult>;
    catch: (error: unknown) => QueryError;
}): Result.ResultAsync<QueryResult, QueryError> (+7 overloads)
export try
Wraps a function execution (sync or async) or a Promise in a
Result
or
ResultAsync
type,
capturing errors and returning them in a structured way.
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.@example
Sync  try-catch
import { Result } from '@praha/byethrow';

const fn = Result.try({
try: (x: number) => {
if (x < 0) throw new Error('Negative!');
return x * 2;
},
catch: (error) => new Error('Oops!', { cause: error }),
});

const result = fn(5); // Result.Result<number, Error>
@example
Sync  try-catch with immediate execution
import { Result } from '@praha/byethrow';

const result = Result.try({
immediate: true,
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>
@example
Sync  safe
import { Result } from '@praha/byethrow';

const fn = Result.try({
safe: true,
try: (x: number) => x + 1,
});

const result = fn(1); // Result.Result<number, never>
@example
Sync  safe with immediate execution
import { Result } from '@praha/byethrow';

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

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

const fn = Result.try({
try: async (id: string) => await fetch(`/api/data/${id}`),
catch: (error) => new Error('Oops!', { cause: error }),
});

const result = await fn('abc'); // Result.ResultAsync<Response, Error>
@example
Async  try-catch with immediate execution
import { Result } from '@praha/byethrow';

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

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

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

const result = await fn(); // Result.ResultAsync<string, never>
@example
Async  safe with immediate execution
import { Result } from '@praha/byethrow';

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

// result is ResultAsync<string, never>
@categoryCreatorstry({
    
immediate: trueimmediate: true,
    
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 }),
  });
};

// Combine everything
const 
const findUser: (id: string) => Result.ResultAsync<{
    id: string;
    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<{
    id: string;
    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<{
    id: string;
    name: string;
}>>(fn: (a: QueryResult) => Result.Failure<NotFoundError> | Result.Success<{
    id: string;
    name: string;
}>) => (result: Result.ResultAsync<QueryResult, ValidationError | QueryError>) => Result.ResultAsync<{
    id: string;
    name: string;
}, ValidationError | ... 1 more ... | NotFoundError> (+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: <{
    id: string;
    name: string;
}>(value: {
    id: string;
    name: string;
}) => Result.Result<{
    id: string;
    name: string;
}, never> (+1 overload)
succeed({ 
id: stringid: 
row: QueryResultrow.
stringid, 
name: stringname: 
row: QueryResultrow.
stringname });
    }),
  );
};

// Execute and handle errors
const 
const result: Result.Result<{
    id: string;
    name: string;
}, ValidationError | QueryError | NotFoundError>
result = await 
const findUser: (id: string) => Result.ResultAsync<{
    id: string;
    name: string;
}, ValidationError | QueryError | NotFoundError>
findUser('u123');
if (
import ResultResult.
const isSuccess: <{
    id: string;
    name: string;
}>(result: Result.Result<{
    id: string;
    name: string;
}, unknown>) => result is Result.Success<{
    id: string;
    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.@example
import { 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<{
    id: string;
    name: string;
}, ValidationError | QueryError | NotFoundError>
result)) {
  
var console: Console
The 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<{
    id: string;
    name: string;
}>
result.
value: {
    id: string;
    name: string;
}
value);
} else {
  // Handle each error type separately.
  switch (
const result: Result.Failure<ValidationError | QueryError | NotFoundError>result.
error: ValidationError | QueryError | NotFoundErrorerror.
Error.name: "ValidationError" | "QueryError" | "NotFoundError"name) {
    case 'ValidationError':
      
var console: Console
The 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: Console
The 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: Console
The 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;
  }
}