@mostfeatured/dbi 0.1.1 → 0.1.3

package/src/methods/hookInteractionListeners.ts

@@ -1,59 +1,115 @@
 import { DBI } from "../DBI";
-import Discord from "discord.js";
+import Discord, { CommandInteractionOption } from "discord.js";
 import { parseCustomId } from "../utils/customId";
 import { NamespaceEnums } from "../../generated/namespaceData";
 
-const componentTypes = ["Button", "StringSelectMenu", "UserSelectMenu", "RoleSelectMenu", "ChannelSelectMenu", "MentionableSelectMenu", "Modal"]
+const componentTypes = [
+  "Button",
+  "StringSelectMenu",
+  "UserSelectMenu",
+  "RoleSelectMenu",
+  "ChannelSelectMenu",
+  "MentionableSelectMenu",
+  "Modal",
+];
 
 export function hookInteractionListeners(dbi: DBI<NamespaceEnums>): () => any {
   async function handle(inter: Discord.Interaction<"cached">) {
     const dbiInter =
-      (inter as any).dbiChatInput ?? dbi.data.interactions.find(i => {
-        let isUsesCustomId = (inter.isButton() || inter.isAnySelectMenu() || inter.isModalSubmit());
-        let parsedId = isUsesCustomId ? parseCustomId(dbi, (inter as any).customId) : null;
+      (inter as any).dbiChatInput ??
+      dbi.data.interactions.find((i) => {
+        let isUsesCustomId =
+          inter.isButton() || inter.isAnySelectMenu() || inter.isModalSubmit();
+        let parsedId = isUsesCustomId
+          ? parseCustomId(dbi, (inter as any).customId)
+          : null;
         return (
-          (
-            i.type == "ChatInput"
-            && (inter.isChatInputCommand() || inter.isAutocomplete())
-            && i.name == [inter.commandName, inter.options.getSubcommandGroup(false), inter.options.getSubcommand(false)].filter(i => !!i).join(" ")
-          )
-          ||
-          (
-            (i.type == "MessageContextMenu" || i.type == "UserContextMenu")
-            && (inter.isMessageContextMenuCommand() || inter.isUserContextMenuCommand())
-            && inter.commandName == i.name
-          )
-          ||
-          (
-            componentTypes.includes(i.type)
-            && isUsesCustomId
-            && parsedId?.name == i.name
-          )
-        )
+          (i.type == "ChatInput" &&
+            (inter.isChatInputCommand() || inter.isAutocomplete()) &&
+            i.name ==
+              [
+                inter.commandName,
+                inter.options.getSubcommandGroup(false),
+                inter.options.getSubcommand(false),
+              ]
+                .filter((i) => !!i)
+                .join(" ")) ||
+          ((i.type == "MessageContextMenu" || i.type == "UserContextMenu") &&
+            (inter.isMessageContextMenuCommand() ||
+              inter.isUserContextMenuCommand()) &&
+            inter.commandName == i.name) ||
+          (componentTypes.includes(i.type) &&
+            isUsesCustomId &&
+            parsedId?.name == i.name)
+        );
       });
-    
+
     if (!dbiInter) return;
 
     let userLocaleName = inter.locale.split("-")[0];
-    let userLocale = dbi.data.locales.has(userLocaleName) ? dbi.data.locales.get(userLocaleName) : dbi.data.locales.get(dbi.config.defaults.locale);
-
-    let guildLocaleName = inter.guild ? inter.guild.preferredLocale.split("-")[0] : null;
-    let guildLocale = guildLocaleName ? (dbi.data.locales.has(guildLocaleName) ? dbi.data.locales.get(guildLocaleName) : dbi.data.locales.get(dbi.config.defaults.locale)) : null;
+    let userLocale = dbi.data.locales.has(userLocaleName)
+      ? dbi.data.locales.get(userLocaleName)
+      : dbi.data.locales.get(dbi.config.defaults.locale);
+
+    let guildLocaleName = inter.guild
+      ? inter.guild.preferredLocale.split("-")[0]
+      : null;
+    let guildLocale = guildLocaleName
+      ? dbi.data.locales.has(guildLocaleName)
+        ? dbi.data.locales.get(guildLocaleName)
+        : dbi.data.locales.get(dbi.config.defaults.locale)
+      : null;
 
     let locale = {
       user: userLocale,
-      guild: guildLocale
+      guild: guildLocale,
     };
 
-    let data = (inter.isButton() || inter.isAnySelectMenu() || inter.isModalSubmit()) ? parseCustomId(dbi, inter.customId).data : undefined;
+    let data =
+      inter.isButton() || inter.isAnySelectMenu() || inter.isModalSubmit()
+        ? parseCustomId(dbi, inter.customId).data
+        : undefined;
 
     let other = {};
 
-    if (!(await dbi.events.trigger("beforeInteraction", { dbi, interaction: inter, locale, setRateLimit, data, other, dbiInteraction: dbiInter }))) return;
-    
+    if (
+      !(await dbi.events.trigger("beforeInteraction", {
+        dbi,
+        interaction: inter,
+        locale,
+        setRateLimit,
+        data,
+        other,
+        dbiInteraction: dbiInter,
+      }))
+    )
+      return;
+
     if (inter.isAutocomplete()) {
       let focussed = inter.options.getFocused(true);
-      let option = (dbiInter.options as any[]).find(i => i.name == focussed.name);
+      let option = (dbiInter.options as any[]).find(
+        (i) => i.name == focussed.name
+      );
+      if (option?.validate) {
+        const res = await option.validate({
+          value: focussed.value,
+          interaction: inter,
+          dbiInteraction: dbiInter,
+          dbi,
+          data,
+          other,
+          locale,
+          step: "Autocomplete",
+        });
+
+        if (Array.isArray(res) && res.length > 0) {
+          await inter.respond(res);
+          return;
+        }
+
+        if (res !== true) return;
+      }
+
       if (option?.onComplete) {
         let response = await option.onComplete({
           value: focussed.value,
@@ -62,7 +118,7 @@ export function hookInteractionListeners(dbi: DBI<NamespaceEnums>): () => any {
           dbi,
           data,
           other,
-          locale
+          locale,
         });
         await inter.respond(response);
       }
@@ -70,12 +126,12 @@ export function hookInteractionListeners(dbi: DBI<NamespaceEnums>): () => any {
     }
 
     let rateLimitKeyMap = {
-      "User": `${dbiInter.name}_${inter.user.id}`,
-      "Channel": `${dbiInter.name}_${inter.channelId || "Channel"}`,
-      "Guild": `${dbiInter.name}_${inter.guildId || "Guild"}`,
-      "Member": `${dbiInter.name}_${inter.user.id}_${inter.guildId || "Guild"}`,
-      "Message": `${dbiInter.name}_${(inter as any)?.message?.id}`
-    }
+      User: `${dbiInter.name}_${inter.user.id}`,
+      Channel: `${dbiInter.name}_${inter.channelId || "Channel"}`,
+      Guild: `${dbiInter.name}_${inter.guildId || "Guild"}`,
+      Member: `${dbiInter.name}_${inter.user.id}_${inter.guildId || "Guild"}`,
+      Message: `${dbiInter.name}_${(inter as any)?.message?.id}`,
+    };
 
     for (const type in rateLimitKeyMap) {
       // @ts-ignore
@@ -86,29 +142,57 @@ export function hookInteractionListeners(dbi: DBI<NamespaceEnums>): () => any {
         val = null;
       }
       if (val) {
-        if ((await dbi.events.trigger("interactionRateLimit", {
-          dbi,
-          interaction: inter,
-          dbiInteraction: dbiInter,
-          locale,
-          data,
-          rateLimit: {
-            type: key,
-            ...val
-          }
-        })) === true) return;
+        if (
+          (await dbi.events.trigger("interactionRateLimit", {
+            dbi,
+            interaction: inter,
+            dbiInteraction: dbiInter,
+            locale,
+            data,
+            rateLimit: {
+              type: key,
+              ...val,
+            },
+          })) === true
+        )
+          return;
       }
     }
 
     async function setRateLimit(type: string, duration: number) {
       // @ts-ignore
-      await dbi.config.store.set(`RateLimit["${rateLimitKeyMap[type]}"]`, { at: Date.now(), duration });
+      await dbi.config.store.set(`RateLimit["${rateLimitKeyMap[type]}"]`, {
+        at: Date.now(),
+        duration,
+      });
     }
 
     for (const rateLimit of dbiInter.rateLimits) {
       await setRateLimit(rateLimit.type, rateLimit.duration);
     }
 
+    if (inter.isChatInputCommand()) {
+      let dcOptions = (inter.options as any)
+        ._hoistedOptions as CommandInteractionOption[];
+      let dbiOptions = dbiInter.options as any[];
+      for (const dcOption of dcOptions) {
+        const dbiOption = dbiOptions.find((i) => i.name == dcOption.name);
+        if (dbiOption?.validate) {
+          const res = await dbiOption.validate({
+            value: dcOption.value,
+            interaction: inter,
+            dbiInteraction: dbiInter,
+            dbi,
+            data,
+            other,
+            locale,
+            step: "Result",
+          });
+          if (res !== true) return;
+        }
+      }
+    }
+
     let arg = {
       // @ts-ignore
       dbi,
@@ -123,7 +207,7 @@ export function hookInteractionListeners(dbi: DBI<NamespaceEnums>): () => any {
       // @ts-ignore
       data,
       // @ts-ignore
-      other
+      other,
     };
 
     if (dbi.config.strict) {
@@ -135,21 +219,32 @@ export function hookInteractionListeners(dbi: DBI<NamespaceEnums>): () => any {
         await dbiInter.onExecute(arg);
       } catch (error) {
         // @ts-ignore
-        await dbi.events.trigger("interactionError", Object.assign(arg, { error }));
+        await dbi.events.trigger(
+          "interactionError",
+          Object.assign(arg, { error })
+        );
       }
     }
-    
+
     // @ts-ignore
-    dbi.events.trigger("afterInteraction", { dbi, interaction: inter, dbiInteraction: dbiInter, locale, setRateLimit, data, other });
+    dbi.events.trigger("afterInteraction", {
+      dbi,
+      interaction: inter,
+      dbiInteraction: dbiInter,
+      locale,
+      setRateLimit,
+      data,
+      other,
+    });
   }
 
-  dbi.data.clients.forEach(d=>{
+  dbi.data.clients.forEach((d) => {
     d.client.on("interactionCreate", handle);
   });
 
-  return () => { 
-    dbi.data.clients.forEach(d=>{
+  return () => {
+    dbi.data.clients.forEach((d) => {
       d.client.off("interactionCreate", handle);
     });
   };
-}
+}

package/src/types/ChatInput/ChatInputOptions.ts

@@ -3,23 +3,76 @@ import { NamespaceEnums } from "../../../generated/namespaceData";
 import { DBI } from "../../DBI";
 import { IDBIBaseExecuteCtx } from "../Interaction";
 
-export type TDBIValueName<T> = { value: T, name: string };
-export type TDBIBaseOption = { name: string, description: string, required?: boolean };
+export type TDBIValueName<T> = { value: T; name: string };
+export type TDBIBaseOption = {
+  name: string;
+  description: string;
+  required?: boolean;
+};
 
-export type TDBIMinMaxLength = { maxLength?: number, minLength?: number };
-export type TDBIMinMaxValue = { maxValue?: number, minValue?: number };
+export type TDBIMinMaxLength = { maxLength?: number; minLength?: number };
+export type TDBIMinMaxValue = { maxValue?: number; minValue?: number };
 
-export interface IDBICompleteCtx<TNamespace extends NamespaceEnums, TValueType = string | number> extends IDBIBaseExecuteCtx<TNamespace> { 
-  interaction: Discord.AutocompleteInteraction;
+export type TDBIValidator<
+  TExtends,
+  TValue,
+  TStep extends string,
+  TExpectedResponse = boolean
+> = {
+  validate?: (
+    cfg: TExtends & { value: TValue; step: TStep }
+  ) => Promise<TExpectedResponse> | TExpectedResponse;
+};
+
+export interface IDBIValuedInteraction<
+  TNamespace extends NamespaceEnums,
+  TInteractionType extends Discord.Interaction,
+  TValueType = string | number
+> extends IDBIBaseExecuteCtx<TNamespace> {
   value: TValueType;
+  interaction: TInteractionType;
 }
 
+export type TDBICompleteCtx<
+  TNamespace extends NamespaceEnums,
+  TValueType = string | number
+> = IDBIValuedInteraction<
+  TNamespace,
+  Discord.AutocompleteInteraction,
+  TValueType
+>;
+
+export type TDBIValidateCtx<
+  TNamespace extends NamespaceEnums,
+  TValueType = string | number
+> = IDBIValuedInteraction<TNamespace, Discord.Interaction, TValueType>;
+
+export type TDBICompleter<
+  TNamespace extends NamespaceEnums,
+  TValueType extends number | string
+> = {
+  onComplete(
+    ctx: TDBICompleteCtx<TNamespace, string>
+  ): Promise<TDBIValueName<TValueType>[]> | TDBIValueName<TValueType>[];
+};
+
 export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
   dbi: DBI<TNamespace>;
   constructor(dbi: DBI<TNamespace>) {
     this.dbi = dbi;
   }
-  stringAutocomplete(cfg: TDBIBaseOption & TDBIMinMaxLength & { onComplete(ctx: IDBICompleteCtx<TNamespace, string>): Promise<TDBIValueName<string>[]> | TDBIValueName<string>[], messageCommands?: { rest?: boolean } }) {
+  stringAutocomplete(
+    cfg: TDBIBaseOption &
+      TDBIMinMaxLength & {
+        messageCommands?: { rest?: boolean };
+      } & TDBIValidator<
+        TDBIValidateCtx<TNamespace, string>,
+        string,
+        "Autocomplete" | "Result",
+        boolean | TDBIValueName<string>
+      > &
+      TDBICompleter<TNamespace, string>
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.String,
       name: cfg.name,
@@ -30,10 +83,22 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       max_length: cfg.maxLength,
       minLength: cfg.minLength,
       min_length: cfg.minLength,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
-  stringChoices(cfg: TDBIBaseOption & TDBIMinMaxLength & { choices: TDBIValueName<string>[], messageCommands?: { rest?: boolean } }) {
+  stringChoices(
+    cfg: TDBIBaseOption &
+      TDBIMinMaxLength & {
+        choices: TDBIValueName<string>[];
+        messageCommands?: { rest?: boolean };
+      } & TDBIValidator<
+        TDBIValidateCtx<TNamespace, string>,
+        string,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.String,
       name: cfg.name,
@@ -43,11 +108,22 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       max_length: cfg.maxLength,
       minLength: cfg.minLength,
       min_length: cfg.minLength,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
 
-  string(cfg: TDBIBaseOption & TDBIMinMaxLength & { messageCommands?: { rest?: boolean } }) {
+  string(
+    cfg: TDBIBaseOption &
+      TDBIMinMaxLength & {
+        messageCommands?: { rest?: boolean };
+      } & TDBIValidator<
+        TDBIValidateCtx<TNamespace, string>,
+        string,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.String,
       name: cfg.name,
@@ -57,11 +133,22 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       minLength: cfg.minLength,
       min_length: cfg.minLength,
       required: cfg.required,
-      messageCommands: cfg.messageCommands
+      messageCommands: cfg.messageCommands,
+      validate: cfg.validate,
     };
   }
 
-  numberAutocomplete(cfg: TDBIBaseOption & TDBIMinMaxValue & { onComplete(ctx: IDBICompleteCtx<TNamespace, string>): Promise<TDBIValueName<number>[]> | TDBIValueName<number>[] }) {
+  numberAutocomplete(
+    cfg: TDBIBaseOption &
+      TDBIMinMaxValue &
+      TDBIValidator<
+        TDBIValidateCtx<TNamespace, number>,
+        number,
+        "Autocomplete" | "Result",
+        boolean | TDBIValueName<number>
+      > &
+      TDBICompleter<TNamespace, number>
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.Number,
       name: cfg.name,
@@ -72,11 +159,20 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       max_value: cfg.maxValue,
       minValue: cfg.minValue,
       min_value: cfg.minValue,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
 
-  numberChoices(cfg: TDBIBaseOption & TDBIMinMaxValue & { choices: TDBIValueName<number>[] }) {
+  numberChoices(
+    cfg: TDBIBaseOption &
+      TDBIMinMaxValue & { choices: TDBIValueName<number>[] } & TDBIValidator<
+        TDBIValidateCtx<TNamespace, number>,
+        number,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.Number,
       name: cfg.name,
@@ -86,11 +182,21 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       max_value: cfg.maxValue,
       minValue: cfg.minValue,
       min_value: cfg.minValue,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
 
-  number(cfg: TDBIBaseOption & TDBIMinMaxValue) {
+  number(
+    cfg: TDBIBaseOption &
+      TDBIMinMaxValue &
+      TDBIValidator<
+        TDBIValidateCtx<TNamespace, number>,
+        number,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.Number,
       name: cfg.name,
@@ -99,11 +205,22 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       max_value: cfg.maxValue,
       minValue: cfg.minValue,
       min_value: cfg.minValue,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
 
-  integerAutocomplete(cfg: TDBIBaseOption & TDBIMinMaxValue & { onComplete(ctx: IDBICompleteCtx<TNamespace, string>): Promise<TDBIValueName<number>[]> | TDBIValueName<number>[] }) {
+  integerAutocomplete(
+    cfg: TDBIBaseOption &
+      TDBIMinMaxValue &
+      TDBIValidator<
+        TDBIValidateCtx<TNamespace, number>,
+        number,
+        "Autocomplete" | "Result",
+        boolean | TDBIValueName<number>
+      > &
+      TDBICompleter<TNamespace, number>
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.Integer,
       name: cfg.name,
@@ -114,11 +231,20 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       max_value: cfg.maxValue,
       minValue: cfg.minValue,
       min_value: cfg.minValue,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
 
-  integerChoices(cfg: TDBIBaseOption & TDBIMinMaxValue & { choices: TDBIValueName<number>[] }) {
+  integerChoices(
+    cfg: TDBIBaseOption &
+      TDBIMinMaxValue & { choices: TDBIValueName<number>[] } & TDBIValidator<
+        TDBIValidateCtx<TNamespace, number>,
+        number,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.Integer,
       name: cfg.name,
@@ -128,11 +254,21 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       max_value: cfg.maxValue,
       minValue: cfg.minValue,
       min_value: cfg.minValue,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
 
-  integer(cfg: TDBIBaseOption & TDBIMinMaxValue) {
+  integer(
+    cfg: TDBIBaseOption &
+      TDBIMinMaxValue &
+      TDBIValidator<
+        TDBIValidateCtx<TNamespace, number>,
+        number,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.Integer,
       name: cfg.name,
@@ -141,7 +277,8 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       max_value: cfg.maxValue,
       minValue: cfg.minValue,
       min_value: cfg.minValue,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
 
@@ -150,7 +287,7 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       type: Discord.ApplicationCommandOptionType.Boolean,
       name: cfg.name,
       description: cfg.description,
-      required: cfg.required
+      required: cfg.required,
     };
   }
 
@@ -159,45 +296,85 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
       type: Discord.ApplicationCommandOptionType.Attachment,
       name: cfg.name,
       description: cfg.description,
-      required: cfg.required
+      required: cfg.required,
     };
   }
 
-  channel(cfg: TDBIBaseOption & { channelTypes: Discord.ChannelType[] }) {
+  channel(
+    cfg: TDBIBaseOption & {
+      channelTypes: Discord.ChannelType[];
+    } & TDBIValidator<
+        TDBIValidateCtx<TNamespace, Discord.Channel>,
+        Discord.Channel,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.Channel,
       name: cfg.name,
       description: cfg.description,
       channelTypes: cfg.channelTypes,
       channel_types: cfg.channelTypes,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
 
-  role(cfg: TDBIBaseOption) {
+  role(
+    cfg: TDBIBaseOption &
+      TDBIValidator<
+        TDBIValidateCtx<TNamespace, Discord.Role>,
+        Discord.Role,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.Role,
       name: cfg.name,
       description: cfg.description,
-      required: cfg.required
-    }
+      required: cfg.required,
+      validate: cfg.validate,
+    };
   }
 
-  mentionable(cfg: TDBIBaseOption) {
+  mentionable(
+    cfg: TDBIBaseOption &
+      TDBIValidator<
+        TDBIValidateCtx<
+          TNamespace,
+          Discord.Role | Discord.Channel | Discord.User
+        >,
+        Discord.Role | Discord.Channel | Discord.User,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.Mentionable,
       name: cfg.name,
       description: cfg.description,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
 
-  user(cfg: TDBIBaseOption) {
+  user(
+    cfg: TDBIBaseOption &
+      TDBIValidator<
+        TDBIValidateCtx<TNamespace, Discord.User>,
+        Discord.User,
+        "Result",
+        boolean
+      >
+  ) {
     return {
       type: Discord.ApplicationCommandOptionType.User,
       name: cfg.name,
       description: cfg.description,
-      required: cfg.required
+      required: cfg.required,
+      validate: cfg.validate,
     };
   }
-}
+}