Skip to content

Transformers

What is a transformer?

Basically, a transformer is a function that takes an object and transforms it into another value. In Seyfert, transformers are used to transform data coming from Discord into any values you need.

How are they used?

Let’s look at an example of a transformer.

import { 
const Transformers: {
    AnonymousGuild(client: UsingClient, data: APIPartialGuild): AnonymousGuildStructure;
    ... 29 more ...;
    Entitlement(client: UsingClient, data: APIEntitlement): EntitlementStructure;
}
Transformers } from 'seyfert';


const Transformers: {
    AnonymousGuild(client: UsingClient, data: APIPartialGuild): AnonymousGuildStructure;
    ... 29 more ...;
    Entitlement(client: UsingClient, data: APIEntitlement): EntitlementStructure;
}
Transformers.
function User(client: UsingClient, data: APIUser): UserStructure
User = (
client: UsingClient
client, 
data: APIUser
data) => {
    return {
        
MyUser.username: string
username: 
data: APIUser
data.
APIUser.username: string
The user's username, not unique across the platform
username,
        
MyUser.isAdmin: boolean
isAdmin: 
var Math: Math
An intrinsic object that provides basic mathematics functionality and constants.
Math.
Math.random(): number
Returns a pseudorandom number between 0 and 1.
random() > 0.5,
        
MyUser.raw(): Promise<APIUser>
raw() {
            return 
client: UsingClient
client.
BaseClient.users: UsersShorter
users.
UsersShorter.raw(userId: string, force?: boolean): Promise<APIUser>
raw(
data: APIUser
data.
APIUser.id: string
The user's id
id);
        },
    };
};


/*
At this point, you should have a `declare module "seyfert"` in your project,
if not, add it.
*/
declare module "seyfert" {
// Declaring the type this way will reflect in the typing throughout the entire project.
    interface 
interface CustomStructures
CustomStructures {
        
CustomStructures.User: MyUser
User: 
interface MyUser
MyUser;
    }
// You can add as many transformers as you like with any type.
}

Let the autocomplete of your editor guide you and discover all the possibilities you have.

import { 
const Transformers: {
    AnonymousGuild(client: UsingClient, data: APIPartialGuild): AnonymousGuildStructure;
    ... 29 more ...;
    Entitlement(client: UsingClient, data: APIEntitlement): EntitlementStructure;
}
Transformers } from 'seyfert';


const Transformers: {
    AnonymousGuild(client: UsingClient, data: APIPartialGuild): AnonymousGuildStructure;
    ... 29 more ...;
    Entitlement(client: UsingClient, data: APIEntitlement): EntitlementStructure;
}
Transformers.Guil dMember
Guild
GuildBan
GuildEmoji
GuildMember
GuildRole

How can I use them?

For example, we defined a transformer for the user earlier, now let’s see how we can use it.

import { type 
class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
CommandContext, 
class Command
Command, 
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare } from 'seyfert';


@
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare({
    
name: string
name: 'ping',
    
description: string
description: 'Ping!',
})
class 
class Ping
Ping extends 
class Command
Command {
    async 
Ping.run(ctx: CommandContext): Promise<void>
run(
ctx: CommandContext<{}, never>
ctx: 
class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
CommandContext) {
        const 
const result: APIUser
result = await 
ctx: CommandContext<{}, never>
ctx.
CommandContext<{}, never>.author: MyUser
author. 
MyUser.raw(): Promise<APIUser>
raw();
isAdmin
raw
username
        
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
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(
const result: APIUser
result.
APIUser.id: string
The user's id
id, 
const result: APIUser
result.
APIUser.username: string
The user's username, not unique across the platform
username);
    }
}

A seyfert transformer