152 lines
4.0 KiB
TypeScript
152 lines
4.0 KiB
TypeScript
import { Interaction } from './src/structures/interactions.ts'
|
|
import {
|
|
SlashCommandsManager,
|
|
SlashClient,
|
|
SlashCommandHandlerCallback,
|
|
SlashCommandHandler
|
|
} from './src/interactions/mod.ts'
|
|
import {
|
|
InteractionResponseType,
|
|
InteractionType
|
|
} from './src/types/interactions.ts'
|
|
|
|
export interface DeploySlashInitOptions {
|
|
env?: boolean
|
|
publicKey?: string
|
|
token?: string
|
|
path?: string
|
|
}
|
|
|
|
/** Current Slash Client being used to handle commands */
|
|
let client: SlashClient
|
|
/** Manage Slash Commands right in Deploy */
|
|
let commands: SlashCommandsManager
|
|
|
|
/**
|
|
* Initialize Slash Commands Handler for [Deno Deploy](https://deno.com/deploy).
|
|
* Easily create Serverless Slash Commands on the fly.
|
|
*
|
|
* **Examples**
|
|
*
|
|
* ```ts
|
|
* init({
|
|
* publicKey: "my public key",
|
|
* token: "my bot's token", // only required if you want to manage slash commands in code
|
|
* })
|
|
* ```
|
|
*
|
|
* ```ts
|
|
* // takes up `PUBLIC_KEY` and `TOKEN` from ENV
|
|
* init({ env: true })
|
|
* ```
|
|
*
|
|
* @param options Initialization options
|
|
*/
|
|
export function init(options: { env: boolean; path?: string }): void
|
|
export function init(options: {
|
|
publicKey: string
|
|
token?: string
|
|
path?: string
|
|
}): void
|
|
export function init(options: DeploySlashInitOptions): void {
|
|
if (client !== undefined) throw new Error('Already initialized')
|
|
if (options.env === true) {
|
|
options.publicKey = Deno.env.get('PUBLIC_KEY')
|
|
options.token = Deno.env.get('TOKEN')
|
|
}
|
|
|
|
if (options.publicKey === undefined)
|
|
throw new Error('Public Key not provided')
|
|
|
|
client = new SlashClient({
|
|
token: options.token,
|
|
publicKey: options.publicKey
|
|
})
|
|
|
|
commands = client.commands
|
|
|
|
const cb = async (evt: {
|
|
respondWith: CallableFunction
|
|
request: Request
|
|
}): Promise<void> => {
|
|
if (options.path !== undefined) {
|
|
if (new URL(evt.request.url).pathname !== options.path) return
|
|
}
|
|
try {
|
|
// we have to wrap because there are some weird scope errors
|
|
const d = await client.verifyFetchEvent({
|
|
respondWith: (...args: any[]) => evt.respondWith(...args),
|
|
request: evt.request
|
|
})
|
|
if (d === false) {
|
|
await evt.respondWith(
|
|
new Response('Not Authorized', {
|
|
status: 400
|
|
})
|
|
)
|
|
return
|
|
}
|
|
|
|
if (d.type === InteractionType.PING) {
|
|
await d.respond({ type: InteractionResponseType.PONG })
|
|
client.emit('ping')
|
|
return
|
|
}
|
|
|
|
await (client as any)._process(d)
|
|
} catch (e) {
|
|
await client.emit('interactionError', e)
|
|
}
|
|
}
|
|
|
|
addEventListener('fetch', cb as any)
|
|
}
|
|
|
|
/**
|
|
* Register Slash Command handler.
|
|
*
|
|
* Example:
|
|
*
|
|
* ```ts
|
|
* handle("ping", (interaction) => {
|
|
* interaction.reply("Pong!")
|
|
* })
|
|
* ```
|
|
*
|
|
* Also supports Sub Command and Group handling out of the box!
|
|
* ```ts
|
|
* handle("command-name group-name sub-command", (i) => {
|
|
* // ...
|
|
* })
|
|
*
|
|
* handle("command-name sub-command", (i) => {
|
|
* // ...
|
|
* })
|
|
* ```
|
|
*
|
|
* @param cmd Command to handle. Either Handler object or command name followed by handler function in next parameter.
|
|
* @param handler Handler function (required if previous argument was command name)
|
|
*/
|
|
export function handle(
|
|
cmd: string | SlashCommandHandler,
|
|
handler?: SlashCommandHandlerCallback
|
|
): void {
|
|
if (client === undefined)
|
|
throw new Error('Slash Client not initialized. Call `init` first')
|
|
client.handle(cmd, handler)
|
|
}
|
|
|
|
export function interactions(cb: (i: Interaction) => any): void {
|
|
client.on('interaction', cb)
|
|
}
|
|
|
|
export { commands, client }
|
|
export * from './src/types/slashCommands.ts'
|
|
export * from './src/types/interactions.ts'
|
|
export * from './src/structures/slash.ts'
|
|
export * from './src/interactions/mod.ts'
|
|
export * from './src/types/channel.ts'
|
|
export * from './src/structures/interactions.ts'
|
|
export * from './src/structures/message.ts'
|
|
export * from './src/structures/embed.ts'
|