@mostfeatured/dbi 0.0.64 → 0.0.65

package/src/methods/publishInteractions.ts

@@ -4,7 +4,7 @@ import { REST } from "@discordjs/rest";
 import { Routes, RESTGetAPIUserResult, RESTPutAPIApplicationCommandsJSONBody, ApplicationCommandType, ApplicationCommandOptionType } from "discord-api-types/v9";
 import { reducePermissions } from "../utils/permissions";
 import snakecaseKeys from "snakecase-keys";
-import { DBI } from "../DBI";
+import { DBI, DBIClientData } from "../DBI";
 import { DBIInteractionLocale } from "../types/InteractionLocale";
 import { NamespaceEnums } from "../../generated/namespaceData";
 
@@ -12,29 +12,25 @@ const PUBLISHABLE_TYPES = ["ChatInput", "UserContextMenu", "MessageContextMenu"]
 const ORIGINAL_LOCALES = ["da", "de", "en-GB", "en-US", "es-ES", "fr", "hr", "it", "lt", "hu", "nl", "no", "pl", "pt-BR", "ro", "fi", "sv-SE", "vi", "tr", "cs", "el", "bg", "ru", "uk", "hi", "th", "zh-CN", "ja", "zh-TW", "ko"];
 
 export async function publishInteractions(
-  clientToken: string,
+  clients: DBIClientData<NamespaceEnums>[],
   interactions: Discord.Collection<string, DBIChatInput<NamespaceEnums>>,
   interactionsLocales: Discord.Collection<string, DBIInteractionLocale>,
   publishType: "Guild" | "Global",
   guildId?: string
 ) {
   interactions = interactions.filter(i => PUBLISHABLE_TYPES.includes(i.type));
-
-  const rest = new REST({ version: "10" });
-  rest.setToken(clientToken);
-
-  const me: RESTGetAPIUserResult = await rest.get(Routes.user()) as any;
   interactions = interactions.sort((a, b) => b.name.split(" ").length - a.name.split(" ").length);
 
-  let body: RESTPutAPIApplicationCommandsJSONBody =
+  let body: {[k: string]: RESTPutAPIApplicationCommandsJSONBody} =
     interactions.reduce((all, current) => {
+      if (current.publish && !all[current.publish]) all[current.publish] = [];
       switch (current.type) {
         case "ChatInput": {
           let nameSplitted = current.name.split(" ");
           let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
           switch (nameSplitted.length) {
             case 1: {
-              all.push({
+              all[current.publish].push({
                 type: ApplicationCommandType.ChatInput,
                 description: current.description,
                 name: nameSplitted[0],
@@ -47,7 +43,7 @@ export async function publishInteractions(
               break;
             }
             case 2: {
-              let baseItem = all.find(i => i.name == current.name.split(" ")[0] && i.type == ApplicationCommandType.ChatInput);
+              let baseItem = all[current.publish].find(i => i.name == current.name.split(" ")[0] && i.type == ApplicationCommandType.ChatInput);
               let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
               let option = {
                 type: ApplicationCommandOptionType.Subcommand,
@@ -59,7 +55,7 @@ export async function publishInteractions(
                 description_localizations: localeData.descriptionLocales,
               };
               if (!baseItem) {
-                all.push({
+                all[current.publish].push({
                   type: ApplicationCommandType.ChatInput,
                   name: nameSplitted[0],
                   default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
@@ -75,10 +71,10 @@ export async function publishInteractions(
               break;
             }
             case 3: {
-              let level1Item = all.find(i => i.name == current.name.split(" ")[0] && i.type == ApplicationCommandType.ChatInput);
+              let level1Item = all[current.publish].find(i => i.name == current.name.split(" ")[0] && i.type == ApplicationCommandType.ChatInput);
               let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
               if (!level1Item) {
-                all.push({
+                all[current.publish].push({
                   type: ApplicationCommandType.ChatInput,
                   name: nameSplitted[0],
                   name_localizations: localeData.nameLocales(0),
@@ -143,7 +139,7 @@ export async function publishInteractions(
         }
         case "MessageContextMenu": {
           let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
-          all.push({
+          all[current.publish].push({
             type: ApplicationCommandType.Message,
             name: current.name,
             default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
@@ -155,29 +151,38 @@ export async function publishInteractions(
         }
         case "UserContextMenu": {
           let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
-          all.push({
+          all[current.publish].push({
             type: ApplicationCommandType.User,
             name: current.name,
             default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
             dm_permission: current.directMessages,
             name_localizations: localeData.allNameLocales,
-            description_localizations: localeData.descriptionLocales
+            description_localizations: localeData.descriptionLocales,
           });
           break;
         }
       }
 
       return all;
-    }, []);
+    }, {} as {[k: string]: any});
+    
+
+  for (let i = 0; i < clients.length; i++) {
+    const client = clients[i];
+    const rest = new REST({ version: "10" });
+    rest.setToken(client.token);
   
-  switch (publishType) {
-    case "Guild": {
-      await rest.put(Routes.applicationGuildCommands(me.id, guildId), { body });
-      break;
-    }
-    case "Global": {
-      await rest.put(Routes.applicationCommands(me.id), { body });
-      break;
+    const me: RESTGetAPIUserResult = await rest.get(Routes.user()) as any;
+  
+    switch (publishType) {
+      case "Guild": {
+        await rest.put(Routes.applicationGuildCommands(me.id, guildId), { body: body[client.namespace] });
+        break;
+      }
+      case "Global": {
+        await rest.put(Routes.applicationCommands(me.id), { body: body[client.namespace] });
+        break;
+      }
     }
   }
   

package/src/types/CustomEvent.ts

@@ -8,7 +8,7 @@ export class DBICustomEvent<TNamespace extends NamespaceEnums, CEventName extend
   map: {[key: string]: string};
   type: string;
   trigger(args: NamespaceData[TNamespace]["customEvents"][CEventName]) {
-    return this.dbi.client.emit(this.name as string, { ...args, _DIRECT_: true});
+    return this.dbi.data.clients.first().client.emit(this.name as string, { ...args, _DIRECT_: true});
   }
   constructor(dbi: DBI<TNamespace>, cfg: TDBICustomEventOmitted<TNamespace, CEventName>) {
     this.dbi = dbi;

package/src/types/Event.ts

@@ -1,6 +1,6 @@
 import Discord from "discord.js";
 import { NamespaceEnums, NamespaceData } from "../../generated/namespaceData";
-import { DBI } from "../DBI";
+import { DBI, DBIClientData } from "../DBI";
 import { DBILocale } from "./Locale";
 
 export interface ClientEvents {
@@ -93,7 +93,7 @@ export interface ClientEvents {
 export type DBIEventCombinations<TNamespace extends NamespaceEnums> = {
   [K in keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]: {
     name: K,
-    onExecute: (ctx: (ClientEvents & NamespaceData[TNamespace]["customEvents"])[K] & { other: Record<string, any>, locale?: { guild: DBILocale<TNamespace> }, eventName: string }) => Promise<any> | any
+    onExecute: (ctx: (ClientEvents & NamespaceData[TNamespace]["customEvents"])[K] & { other: Record<string, any>, locale?: { guild: DBILocale<TNamespace> }, eventName: string, nextClient: DBIClientData<TNamespace> }) => Promise<any> | any
   }
 }[keyof (ClientEvents) | keyof NamespaceData[TNamespace]["customEvents"]];
 
@@ -102,6 +102,7 @@ export type TDBIEventOmitted<TNamespace extends NamespaceEnums> = Omit<DBIEvent<
 export class DBIEvent<TNamespace extends NamespaceEnums> {
   readonly type: "Event";
   other?: Record<string, any>;
+  triggerType?: "OneByOne" | "OneByOneGlobal" | "Random" | "First";
   id?: string;
   name: string;
   onExecute: (...args: any[]) => any;
@@ -115,5 +116,6 @@ export class DBIEvent<TNamespace extends NamespaceEnums> {
     this.name = cfg.name as any;
     this.onExecute = cfg.onExecute;
     this.ordered = cfg.ordered ?? false;
+    this.triggerType = cfg.triggerType ?? "OneByOneGlobal";
   }
 }

package/src/types/Interaction.ts

@@ -1,5 +1,5 @@
 import Discord from "discord.js";
-import { NamespaceEnums } from "../../generated/namespaceData";
+import { NamespaceEnums, NamespaceData } from "../../generated/namespaceData";
 import { DBI } from "../DBI";
 import { DBIButton } from "./Button";
 import { DBIChatInput } from "./ChatInput/ChatInput";
@@ -28,6 +28,7 @@ export interface IDBIBaseExecuteCtx<TNamespace extends NamespaceEnums> {
   dbiInteraction: TDBIInteractions<TNamespace>;
   setRateLimit(type: TDBIRateLimitTypes, duration: number): Promise<any>;
   other: Record<string, any>;
+  clientNamespace: NamespaceData[TNamespace]["clientNamespaces"];
 }
 
 export type TDBIReferencedData = ({ [key: string]: any, $ref: string, $unRef(): boolean } | string | number);
@@ -66,8 +67,10 @@ export class DBIBaseInteraction<TNamespace extends NamespaceEnums> {
     this.type = cfg.type;
     this.options = cfg.options;
     this.other = cfg.other;
+    this.publish = cfg.publish ?? dbi.data.clients.first()?.namespace;
   }
-
+    
+  publish?: NamespaceData[TNamespace]["clientNamespaces"];
   dbi: DBI<TNamespace>;
   name: string;
   description: string;

package/src/utils/recursiveImport.ts

@@ -2,9 +2,10 @@ import fs from "fs";
 import path from "path";
 
 /**
- * Usage: `await recursiveImport("./src", [".js", ".ts"])`
+ * @example
+ * await recursiveImport("./src", [".js"], [".d.ts"])
  */
-export async function recursiveImport(folderPath: string, exts: string[] = [".js", ".ts"]): Promise<any> {
+export async function recursiveImport(folderPath: string, exts: string[] = [".js"], ignore: string[] = [".d.ts",".js.map",".d.ts.map"]): Promise<any> {
   let files = await fs.promises.readdir(folderPath, { withFileTypes: true });
   let dirName = __dirname;
   
@@ -14,7 +15,7 @@ export async function recursiveImport(folderPath: string, exts: string[] = [".js
     if (!relative.includes(`${path.sep}-`)) {
       if (file.isDirectory()) {
         await recursiveImport(filePath, exts)
-      } else if (exts.some(i => file.name.endsWith(i))) {
+      } else if (exts.some(i => file.name.endsWith(i)) && !ignore.some(i => file.name.endsWith(i))) {
         await import(filePath)
       }
     }