Business Logic Validation in Typescript

import { 
import z
z } from "zod";
import { 
function buildValidator(): FluentValidatorBuilder<any, {}, {}, "not-required">
buildValidator, type 
type InferCommandResult<TCommand extends Command<any, any, any, any, any>, TCondition extends "success" | "failure" | "all" = "all"> = TCommand extends Command<infer TSchema extends StandardSchemaV1<unknown, unknown>, any, infer TContext, infer TOutput, any> ? TCondition extends "success" ? {
    ...;
} & {
    ...;
} : TCondition extends "failure" ? {
    ...;
} & {
    ...;
} : CommandResult<...> : never
InferCommandResult } from "model-validator-ts";

interface 
interface User
User {
  
User.id: string
id: string;
  
User.role: "admin" | "customer"
role: "admin" | "customer";
  
User.email: string
email: string;
  
User.passwordHash: string
passwordHash: string;
}

declare const 
const userService: {
    findByEmail(email: string): Promise<User | null>;
    validatePassword(user: User, password: string): Promise<boolean>;
    generateToken(user: User): Promise<string>;
}
userService: {
  
function findByEmail(email: string): Promise<User | null>
findByEmail(
email: string
email: string): 
interface Promise<T>
Represents the completion of an asynchronous operation
Promise<
interface User
User | null>;
  
function validatePassword(user: User, password: string): Promise<boolean>
validatePassword(
user: User
user: 
interface User
User, 
password: string
password: string): 
interface Promise<T>
Represents the completion of an asynchronous operation
Promise<boolean>;
  
function generateToken(user: User): Promise<string>
generateToken(
user: User
user: 
interface User
User): 
interface Promise<T>
Represents the completion of an asynchronous operation
Promise<string>;
};

const 
const loginSchema: z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>
loginSchema = 
import z
z.
object<{
    email: z.ZodString;
    password: z.ZodString;
}>(shape: {
    email: z.ZodString;
    password: z.ZodString;
}, params?: z.RawCreateParams): z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    ...;
}, {
    ...;
}>
export object
object({
  
email: z.ZodString
email: 
import z
z.
function string(params?: z.RawCreateParams & {
    coerce?: true;
}): z.ZodString
export string
string().
ZodString.email(message?: errorUtil.ErrMessage): z.ZodString
email(),
  
password: z.ZodString
password: 
import z
z.
function string(params?: z.RawCreateParams & {
    coerce?: true;
}): z.ZodString
export string
string().
ZodString.min(minLength: number, message?: errorUtil.ErrMessage): z.ZodString
min(8),
});

const 
const loginCommand: Command<z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>, {}, {
    user: User;
}, {
    ...;
}, "not-required">
loginCommand = 
function buildValidator(): FluentValidatorBuilder<any, {}, {}, "not-required">
buildValidator()
  .
FluentValidatorBuilder<any, {}, {}, "not-required">.input<z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>>(schema: z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>): FluentValidatorBuilder<...>
input(
const loginSchema: z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>
loginSchema)
  .
FluentValidatorBuilder<ZodObject<{ email: ZodString; password: ZodString; }, "strip", ZodTypeAny, { email: string; password: string; }, { email: string; password: string; }>, {}, {}, "not-required">.rule<ErrorBagFromInput<{
    email: string;
    password: string;
}> | {
    context: {
        user: User;
    };
}>(rule: ContextRuleDefinition<{
    email: string;
    password: string;
}, {}, {}, ErrorBagFromInput<{
    email: string;
    password: string;
}> | {
    context: {
        user: User;
    };
}>): FluentValidatorBuilder<...>
rule({
    
fn: ContextRuleFunction<{
    email: string;
    password: string;
}, {}, {}, ErrorBagFromInput<{
    email: string;
    password: string;
}> | {
    context: {
        user: User;
    };
}>
fn: async ({ 
data: {
    email: string;
    password: string;
}
data, 
bag: ErrorBagFromInput<{
    email: string;
    password: string;
}>
bag }) => {
      // Data is typed to the schema output
      const 
const user: User | null
user = await 
const userService: {
    findByEmail(email: string): Promise<User | null>;
    validatePassword(user: User, password: string): Promise<boolean>;
    generateToken(user: User): Promise<string>;
}
userService.
function findByEmail(email: string): Promise<User | null>
findByEmail(
data: {
    email: string;
    password: string;
}
data.
email: string
email);
      if (!
const user: User | null
user) {
        // The bag is where you put validation errors.
        // There is a global error (overall reason why the validation failed)
        // and there are field errors (errors for specific fields)
        return 
bag: ErrorBagFromInput<{
    email: string;
    password: string;
}>
bag.
ErrorBag<requiredKeys<baseObjectOutputType<{ email: ZodString; password: ZodString; }>>>.addGlobalError(message: string): ErrorBagFromInput<{
    email: string;
    password: string;
}>
addGlobalError("Invalid email or password");
      }
      if (!(await 
const userService: {
    findByEmail(email: string): Promise<User | null>;
    validatePassword(user: User, password: string): Promise<boolean>;
    generateToken(user: User): Promise<string>;
}
userService.
function validatePassword(user: User, password: string): Promise<boolean>
validatePassword(
const user: User
user, 
data: {
    email: string;
    password: string;
}
data.
password: string
password))) {
        return 
bag: ErrorBagFromInput<{
    email: string;
    password: string;
}>
bag.
ErrorBag<requiredKeys<baseObjectOutputType<{ email: ZodString; password: ZodString; }>>>.addError(key: requiredKeys<z.baseObjectOutputType<{
    email: z.ZodString;
    password: z.ZodString;
}>>, message: string): ErrorBagFromInput<{
    email: string;
    password: string;
}>
addError("password", "Invalid email or password");
      }
      // Now we are returning a user inside a context object.
      // This allows the next rule and command handler to access
      // the user object. The types are flowing through our pipeline
      return { 
context: {
    user: User;
}
context: { 
user: User
user } };
    },
  })
  .
FluentValidatorBuilder<ZodObject<{ email: ZodString; password: ZodString; }, "strip", ZodTypeAny, { email: string; password: string; }, { email: string; password: string; }>, {}, { ...; }, "not-required">.rule<ErrorBagFromInput<{
    email: string;
    password: string;
}> | undefined>(rule: ContextRuleDefinition<{
    email: string;
    password: string;
}, {}, {
    user: User;
}, ErrorBagFromInput<{
    email: string;
    password: string;
}> | undefined>): FluentValidatorBuilder<...>
rule({
    
id?: string
id: "named-rule",
    
description?: string
description: "This is a named rule",
    
fn: ContextRuleFunction<{
    email: string;
    password: string;
}, {}, {
    user: User;
}, ErrorBagFromInput<{
    email: string;
    password: string;
}> | undefined>
fn: async ({ 
data: {
    email: string;
    password: string;
}
data, 
bag: ErrorBagFromInput<{
    email: string;
    password: string;
}>
bag, 
context: {
    user: User;
}
context }) => {
      if (
context: {
    user: User;
}
context.
user: User
user.
User.email: string
email.
String.endsWith(searchString: string, endPosition?: number): boolean
Returns true if the sequence of elements of searchString converted to a String is the
same as the corresponding elements of this object (converted to a String) starting at
endPosition – length(this). Otherwise returns false.
endsWith("@blocked.com")) {
        return 
bag: ErrorBagFromInput<{
    email: string;
    password: string;
}>
bag.
ErrorBag<requiredKeys<baseObjectOutputType<{ email: ZodString; password: ZodString; }>>>.addError(key: requiredKeys<z.baseObjectOutputType<{
    email: z.ZodString;
    password: z.ZodString;
}>>, message: string): ErrorBagFromInput<{
    email: string;
    password: string;
}>
addError("email", "This email is blocked");
      }
      if (
context: {
    user: User;
}
context.
user: User
user.
User.role: "admin" | "customer"
role === "admin") {
        // You can also add errors to specific fields (typesafe).
        return 
bag: ErrorBagFromInput<{
    email: string;
    password: string;
}>
bag.
ErrorBag<requiredKeys<baseObjectOutputType<{ email: ZodString; password: ZodString; }>>>.addError(key: requiredKeys<z.baseObjectOutputType<{
    email: z.ZodString;
    password: z.ZodString;
}>>, message: string): ErrorBagFromInput<{
    email: string;
    password: string;
}>
addError("email", "Admin users cannot login with password");
      }
    },
  })
  .
FluentValidatorBuilder<ZodObject<{ email: ZodString; password: ZodString; }, "strip", ZodTypeAny, { email: string; password: string; }, { email: string; password: string; }>, {}, { ...; }, "not-required">.command<{
    user: User;
    token: string;
}>(args: {
    execute: (params: {
        data: {
            email: string;
            password: string;
        };
        deps: {};
        context: {
            user: User;
        };
        bag: ErrorBagFromSchema<z.ZodObject<{
            email: z.ZodString;
            password: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            email: string;
            password: string;
        }, {
            ...;
        }>>;
    }) => {
        ...;
    } | Promise<...>;
}): Command<...>
command({
    // Handler to actually login once everything is valid
    
execute: (params: {
    data: {
        email: string;
        password: string;
    };
    deps: {};
    context: {
        user: User;
    };
    bag: ErrorBagFromSchema<z.ZodObject<{
        email: z.ZodString;
        password: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        email: string;
        password: string;
    }, {
        ...;
    }>>;
}) => {
    ...;
} | Promise<...>
execute: async ({ 
context: {
    user: User;
}
context, 
bag: ErrorBagFromSchema<z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>>
bag }) => {
      // We access the user object from the context -
      // no need to query the database again, we know it's
      // the same user we retrieved in the previous rule
      const { 
const user: User
user } = 
context: {
    user: User;
}
context;
      return {
        
user: User
user,
        
token: string
token: await 
const userService: {
    findByEmail(email: string): Promise<User | null>;
    validatePassword(user: User, password: string): Promise<boolean>;
    generateToken(user: User): Promise<string>;
}
userService.
function generateToken(user: User): Promise<string>
generateToken(
const user: User
user),
      };
    },
  });

// Type that can be used around our repo
type 
type LoginResult = {
    success: true;
    result: {
        user: User;
        token: string;
    };
    context: {
        user: User;
    };
} | {
    success: false;
    errors: ErrorBagFromInput<{
        email: string;
        password: string;
    }>;
    step: "validation" | "execution";
    rule?: {
        id?: string;
        description?: string;
    };
}
LoginResult = 
type InferCommandResult<TCommand extends Command<any, any, any, any, any>, TCondition extends "success" | "failure" | "all" = "all"> = TCommand extends Command<infer TSchema extends StandardSchemaV1<unknown, unknown>, any, infer TContext, infer TOutput, any> ? TCondition extends "success" ? {
    ...;
} & {
    ...;
} : TCondition extends "failure" ? {
    ...;
} & {
    ...;
} : CommandResult<...> : never
InferCommandResult<typeof 
const loginCommand: Command<z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>, {}, {
    user: User;
}, {
    ...;
}, "not-required">
loginCommand>;
type 
type LoginResultSuccess = {
    success: true;
    result: {
        user: User;
        token: string;
    };
    context: {
        user: User;
    };
} & {
    success: true;
}
LoginResultSuccess = 
type InferCommandResult<TCommand extends Command<any, any, any, any, any>, TCondition extends "success" | "failure" | "all" = "all"> = TCommand extends Command<infer TSchema extends StandardSchemaV1<unknown, unknown>, any, infer TContext, infer TOutput, any> ? TCondition extends "success" ? {
    ...;
} & {
    ...;
} : TCondition extends "failure" ? {
    ...;
} & {
    ...;
} : CommandResult<...> : never
InferCommandResult<typeof 
const loginCommand: Command<z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>, {}, {
    user: User;
}, {
    ...;
}, "not-required">
loginCommand, "success">;

const app: {
    post: (path: string, handler: (req: {
        body: unknown;
    }, res: {
        status: (code: number) => {
            json: (body: unknown) => void;
        };
    }) => Promise<unknown>) => void;
}
app.
post: (path: string, handler: (req: {
    body: unknown;
}, res: {
    status: (code: number) => {
        json: (body: unknown) => void;
    };
}) => Promise<unknown>) => void
post("/login", async (
req: {
    body: unknown;
}
req, 
res: {
    status: (code: number) => {
        json: (body: unknown) => void;
    };
}
res) => {
  const 
const result: CommandResult<{
    user: User;
    token: string;
}, {
    email: string;
    password: string;
}, {}>
result = await 
const loginCommand: Command<ZodObject<{
    email: ZodString;
    password: ZodString;
}, "strip", ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>, {}, {}, {
    user: User;
    token: string;
}, "not-required">
loginCommand.
Command<ZodObject<{ email: ZodString; password: ZodString; }, "strip", ZodTypeAny, { email: string; password: string; }, { email: string; password: string; }>, {}, {}, { ...; }, "not-required">.run: (input: unknown, opts?: ValidationOpts<{
    email: string;
    password: string;
}> | undefined) => Promise<CommandResult<{
    user: User;
    token: string;
}, {
    email: string;
    password: string;
}, {}>>
run(
req: {
    body: unknown;
}
req.
body: unknown
body);
  if (!
const result: CommandResult<{
    user: User;
    token: string;
}, {
    email: string;
    password: string;
}, {}>
result.
success: boolean
success) {
    return 
res: {
    status: (code: number) => {
        json: (body: unknown) => void;
    };
}
res.
status: (code: number) => {
    json: (body: unknown) => void;
}
status(400).
json: (body: unknown) => void
json({
      
success: boolean
success: false,
      
errors: {
    global: string | undefined;
    issues: Partial<Record<requiredKeys<{
        email: string;
        password: string;
    }>, string[]>>;
}
errors: 
const result: {
    success: false;
    errors: ErrorBagFromInput<{
        email: string;
        password: string;
    }>;
    step: "validation" | "execution";
    rule?: {
        id?: string;
        description?: string;
    };
}
result.
errors: ErrorBagFromInput<{
    email: string;
    password: string;
}>
errors.
ErrorBag<requiredKeys<{ email: string; password: string; }>>.toObject(): {
    global: string | undefined;
    issues: Partial<Record<requiredKeys<{
        email: string;
        password: string;
    }>, string[]>>;
}
toObject(),
    });
  }
  return 
res: {
    status: (code: number) => {
        json: (body: unknown) => void;
    };
}
res.
status: (code: number) => {
    json: (body: unknown) => void;
}
status(200).
json: (body: unknown) => void
json({
    
success: boolean
success: true,
    
result: {
    user: User;
    token: string;
}
result: 
const result: {
    success: true;
    result: {
        user: User;
        token: string;
    };
    context: {};
}
result.
result: {
    user: User;
    token: string;
}
result,
  });
});

const program: Command
program
  .
Command.command(nameAndArgs: string, opts?: CommandOptions): Command (+1 overload)
Define a command, implemented using an action handler.
@example 
program
  .command('clone <source> [destination]')
  .description('clone a repository into a newly created directory')
  .action((source, destination) => {
    console.log('clone command called');
  });
@param ― nameAndArgs - command name and arguments, args are  <required> or [optional] and last may also be variadic...
@param ― opts - configuration options
@returns ― new command
command("get:login-token")
  .
Command.option(flags: string, description?: string, defaultValue?: string | boolean | string[]): Command (+2 overloads)
Define option with flags, description, and optional argument parsing function or defaultValue or both.
The flags string contains the short and/or long flags, separated by comma, a pipe or space. A required
option-argument is indicated by <> and an optional option-argument by [].
See the README for more details, and see also addOption() and requiredOption().
@example 
program
    .option('-p, --pepper', 'add pepper')
    .option('--pt, --pizza-type <TYPE>', 'type of pizza') // required option-argument
    .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
    .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
@returns ― this command for chaining
option("-e, --email <email>", "The email of the user")
  .
Command.option(flags: string, description?: string, defaultValue?: string | boolean | string[]): Command (+2 overloads)
Define option with flags, description, and optional argument parsing function or defaultValue or both.
The flags string contains the short and/or long flags, separated by comma, a pipe or space. A required
option-argument is indicated by <> and an optional option-argument by [].
See the README for more details, and see also addOption() and requiredOption().
@example 
program
    .option('-p, --pepper', 'add pepper')
    .option('--pt, --pizza-type <TYPE>', 'type of pizza') // required option-argument
    .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
    .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
@returns ― this command for chaining
option("-p, --password <password>", "The password of the user")
  .
Command.action(fn: (this: Command, ...args: any[]) => void | Promise<void>): Command
Register callback fn for the command.
@example 
program
  .command('serve')
  .description('start service')
  .action(function() {
    // do work here
  });
@returns ― this command for chaining
action(async (
options: {
    email: string;
    password: string;
}
options: { 
email: string
email: string; 
password: string
password: string }) => {
    const 
const result: CommandResult<{
    user: User;
    token: string;
}, {
    email: string;
    password: string;
}, {}>
result = await 
const loginCommand: Command<ZodObject<{
    email: ZodString;
    password: ZodString;
}, "strip", ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>, {}, {}, {
    user: User;
    token: string;
}, "not-required">
loginCommand.
Command<ZodObject<{ email: ZodString; password: ZodString; }, "strip", ZodTypeAny, { email: string; password: string; }, { email: string; password: string; }>, {}, {}, { ...; }, "not-required">.run: (input: unknown, opts?: ValidationOpts<{
    email: string;
    password: string;
}> | undefined) => Promise<CommandResult<{
    user: User;
    token: string;
}, {
    email: string;
    password: string;
}, {}>>
run({
      
email: string
email: 
options: {
    email: string;
    password: string;
}
options.
email: string
email,
      
password: string
password: 
options: {
    email: string;
    password: string;
}
options.
password: string
password,
    });
    if (!
const result: CommandResult<{
    user: User;
    token: string;
}, {
    email: string;
    password: string;
}, {}>
result.
success: boolean
success) {
      
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
@see ― source
console.
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.
@since ― v0.1.100
error(
const result: {
    success: false;
    errors: ErrorBagFromInput<{
        email: string;
        password: string;
    }>;
    step: "validation" | "execution";
    rule?: {
        id?: string;
        description?: string;
    };
}
result.
errors: ErrorBagFromInput<{
    email: string;
    password: string;
}>
errors.
ErrorBag<requiredKeys<{ email: string; password: string; }>>.toObject(): {
    global: string | undefined;
    issues: Partial<Record<requiredKeys<{
        email: string;
        password: string;
    }>, string[]>>;
}
toObject());
      
const process: {
    exit(code: number): never;
}
process.
function exit(code: number): never
exit(1);
    }
    // TypeScript knows result.success is true here, so result.result exists
    
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
@see ― source
console.
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.
@since ― v0.1.100
log(`Login token: ${
const result: {
    success: true;
    result: {
        user: User;
        token: string;
    };
    context: {};
}
result.
result: {
    user: User;
    token: string;
}
result.
token: string
token}`);
  });