Shorters y Proxy

Shorters

Los Shorters son una combinación simple de los métodos de Seyfert y la API de Discord, en Seyfert están destinados a facilitar el acceso de los usuarios a los métodos de todos los objetos de Discord sin necesidad de instanciar su clase representativa o incluso si esta no existe. Esto ahorra muchos recursos en accesos a datos innecesarios.

Supongamos que tenemos un sistema de bienvenida; en su base de datos ya tiene acceso al ID del canal donde enviar su mensaje, entonces, ¿por qué debería buscar ese canal en la caché? ¿Por qué debería obtener datos que no necesita solo para enviar un mensaje? Ahí es donde entran en juego los Shorters.

import { 
function createEvent<E extends ClientNameEvents | CustomEventsKeys>(data: {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}): {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent } from 'seyfert';

const 
const db: Map<string, string>
db = new 
var Map: MapConstructor
new <string, string>(iterable?: Iterable<readonly [string, string]> | null | undefined) => Map<string, string> (+3 overloads)
Map<string, string>();

export default 
createEvent<"guildMemberAdd">(data: {
    data: {
        name: "guildMemberAdd";
        once?: boolean;
    };
    run: (args_0: GuildMember, args_1: UsingClient, args_2: number) => any;
}): {
    ...;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent({
  
data: {
    name: "guildMemberAdd";
    once?: boolean;
}
data: { 
name: "guildMemberAdd"
name: 'guildMemberAdd' },
  
run: (args_0: GuildMember, args_1: UsingClient, args_2: number) => any
run: async (
member: GuildMember
member, 
client: UsingClient
client) => {
    const 
const channelId: string | undefined
channelId = 
const db: Map<string, string>
db.
Map<string, string>.get(key: string): string | undefined
Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
@returns ― Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
get(
member: GuildMember
member.
GuildMember.guildId: string
the choosen guild id
guildId);
    if (!
const channelId: string | undefined
channelId) {
      return;
    }

    await 
client: UsingClient
client.
BaseClient.messages: MessageShorter
messages.
MessageShorter.write(channelId: string, { files, ...body }: MessageCreateBodyRequest): Promise<MessageStructure>
write(
const channelId: string
channelId, {
      
content?: string | undefined
The message contents (up to 2000 characters)
content: `Welcome ${
member: GuildMember
member} :wave:`,
    });
  },
});

Esto se aplica a todo Seyfert: los métodos en las clases que representan objetos de Discord son solo una capa extra de los Shorters para facilitar el acceso. Por ejemplo, por defecto Seyfert no añade propiedades de caché a los objetos, pero proporciona facilidades para acceder a ellas.

import { 
function createEvent<E extends ClientNameEvents | CustomEventsKeys>(data: {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}): {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent } from 'seyfert';

const 
const db: Map<string, string>
db = new 
var Map: MapConstructor
new <string, string>(iterable?: Iterable<readonly [string, string]> | null | undefined) => Map<string, string> (+3 overloads)
Map<string, string>();

export default 
createEvent<"guildMemberAdd">(data: {
    data: {
        name: "guildMemberAdd";
        once?: boolean;
    };
    run: (args_0: GuildMember, args_1: UsingClient, args_2: number) => any;
}): {
    ...;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent({
  
data: {
    name: "guildMemberAdd";
    once?: boolean;
}
data: { 
name: "guildMemberAdd"
name: 'guildMemberAdd' },
  
run: (args_0: GuildMember, args_1: UsingClient, args_2: number) => any
run: async (
member: GuildMember
member, 
client: UsingClient
client) => {
    const 
const channelId: string | undefined
channelId = 
const db: Map<string, string>
db.
Map<string, string>.get(key: string): string | undefined
Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
@returns ― Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
get(
member: GuildMember
member.
GuildMember.guildId: string
the choosen guild id
guildId);
    if (!
const channelId: string | undefined
channelId) return;

    // this is a fetch request to cache (force if you want direct api fetch)
    const 
const guild: Guild<"api" | "cached">
guild = await 
member: GuildMember
member.
BaseGuildMember.guild(mode?: "rest" | "flow"): Promise<GuildStructure<"cached" | "api">> (+1 overload)
guild();

    await 
client: UsingClient
client.
BaseClient.messages: MessageShorter
messages.
MessageShorter.write(channelId: string, { files, ...body }: MessageCreateBodyRequest): Promise<MessageStructure>
write(
const channelId: string
channelId, {
      
content?: string | undefined
The message contents (up to 2000 characters)
content: `Welcome ${
member: GuildMember
member} to ${
const guild: Guild<"api" | "cached">
guild.
name: string
name} :wave:`,
    });
  },
});

Proxy

El objeto proxy es la capa que está debajo de los Shorters y se encarga de crear un camino con el código apoyándose en el autocompletado de TypeScript. Es básicamente la API de Discord convertida en un objeto increíblemente rápido.

¿Hay algo que no esté soportado en Seyfert? Entonces accédalo directamente, vamos a crear un hilo directamente con la API de Discord:

import { 
function createEvent<E extends ClientNameEvents | CustomEventsKeys>(data: {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}): {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent } from 'seyfert';

export default 
createEvent<"channelCreate">(data: {
    data: {
        name: "channelCreate";
        once?: boolean;
    };
    run: (args_0: AllChannels, args_1: UsingClient, args_2: number) => any;
}): {
    data: {
        ...;
    };
    run: (args_0: AllChannels, args_1: UsingClient, args_2: number) => any;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent({
  
data: {
    name: "channelCreate";
    once?: boolean;
}
data: { 
name: "channelCreate"
name: 'channelCreate' },
  
run: (args_0: AllChannels, args_1: UsingClient, args_2: number) => any
run: async (
channel: AllChannels
channel, 
client: UsingClient
client) => {
    if (!
channel: AllChannels
channel.
BaseNoEditableChannel<T extends ChannelType>.isThreadOnly(): this is ForumChannel | MediaChannel
isThreadOnly()) return;

    // assuming that channel.thread method does not exist
    // the "object" will follow the same structure as the discord endpoints have
    await 
client: UsingClient
client.
BaseClient.proxy: APIRoutes
proxy.
ChannelRoutes.channels(id: string): {
    get(args?: RestArgumentsNoBody): Promise<RESTGetAPIChannelResult>;
    patch(args: RestArguments<RESTPatchAPIChannelJSONBody>): Promise<RESTPatchAPIChannelResult>;
    delete(args?: RestArgumentsNoBody): Promise<RESTDeleteAPIChannelResult>;
    users: (id: "@me") => {
        threads: {
            archived: {
                private: {
                    get(args?: RestArgumentsNoBody<RESTGetAPIChannelThreadsArchivedQuery>): Promise<RESTGetAPIChannelUsersThreadsArchivedResult>;
                };
            };
        };
    };
    "thread-members": {
        get(args?: RestArgumentsNoBody<RESTGetAPIChannelThreadMembersQuery>): Promise<RESTGetAPIChannelThreadMembersResult>;
        (id: "@me"): {
            put(args?: RestArgumentsNoBody): Promise<RESTPutAPIChannelThreadMembersResult>;
            delete(args?: RestArgumentsNoBody): Promise<RESTDeleteAPIChannelThreadMembersResult>;
        };
        (id: string): {
            get(args?: RestArgumentsNoBody<RESTGetAPIChannelThreadMemberQuery>): Promise<RESTGetAPIChannelThreadMemberResult>;
            put(args?: RestArgumentsNoBody): Promise<RESTPutAPIChannelThreadMembersResult>;
            delete(args?: RestArgumentsNoBody): Promise<RESTDeleteAPIChannelThreadMembersResult>;
        };
    };
    threads: {
        post(args: RestArguments<RESTPostAPIChannelThreadsJSONBody | RESTPostAPIGuildForumThreadsJSONBody>): Promise<RESTPostAPIChannelThreadsResult>;
        archived: {
            public: {
                get(args?: RestArgumentsNoBody<RESTGetAPIChannelThreadsArchivedQuery>): Promise<RESTGetAPIChannelThreadsArchivedPublicResult ...
channels(
channel: MediaChannel | ForumChannel
channel.
DiscordBase<Data extends Record<string, any> = { id: string; }>.id: string
id).
threads: {
    post(args: RestArguments<RESTPostAPIChannelThreadsJSONBody | RESTPostAPIGuildForumThreadsJSONBody>): Promise<RESTPostAPIChannelThreadsResult>;
    archived: {
        public: {
            get(args?: RestArgumentsNoBody<RESTGetAPIChannelThreadsArchivedQuery>): Promise<RESTGetAPIChannelThreadsArchivedPublicResult>;
        };
        private: {
            get(args?: RestArgumentsNoBody<RESTGetAPIChannelThreadsArchivedQuery>): Promise<RESTGetAPIChannelThreadsArchivedPrivateResult>;
        };
    };
}
threads.
function post(args: RestArguments<RESTPostAPIChannelThreadsJSONBody | RESTPostAPIGuildForumThreadsJSONBody>): Promise<RESTPostAPIChannelThreadsResult>
post({
      
body: RESTPostAPIChannelThreadsJSONBody | RESTPostAPIGuildForumThreadsJSONBody
body: {
        
RESTPostAPIChannelMessagesThreadsJSONBody.name: string
1-100 character thread name
name: 'First thread!',
        
message: RESTPostAPIChannelMessageJSONBody
The initial message of the thread
message: {
          
RESTPostAPIChannelMessageJSONBody.content?: string | undefined
The message contents (up to 2000 characters)
content: 'Seyfert >',
        },
      },
      
reason?: string
reason: "I'm always the first",
    });
  },
});

El Proxy tiene acceso a todos los tipos de la API de Discord, por lo que siempre será una forma de mantenerse adelante, incluso dentro de las versiones de desarrollo.

Empezando

Comandos

i18n

Componentes e Interacciones

Recipes

Tips & Miscellaneous

Shorters y Proxy

Shorters

Proxy