@mostfeatured/dbi 0.0.63 → 0.0.65

package/src/index.ts

@@ -1,11 +1,27 @@
 import { NamespaceEnums } from "../generated/namespaceData";
 import { DBI, DBIConfigConstructor } from "./DBI";
-export { recursiveImport } from "./utils/recursiveImport";
+import { recursiveImport as _recursiveImport } from "./utils/recursiveImport";
 export { MemoryStore } from "./utils/MemoryStore";
 
 import path from "path";
+import { parseCustomId, buildCustomId } from "./utils/customId";
+
 export const generatedPath = path.resolve(__dirname, "../generated");
 
 export function createDBI<TNamespace extends NamespaceEnums, TOtherType = Record<string, any>>(namespace: TNamespace, cfg: DBIConfigConstructor): DBI<TNamespace, TOtherType> {
   return new DBI<TNamespace, TOtherType>(namespace, cfg);
-};
+};
+
+export const Utils = {
+  parseCustomId,
+  buildCustomId,
+  recursiveImport: _recursiveImport
+}
+
+/**
+ * @deprecated
+ */
+export async function recursiveImport(...args: any[]) {
+  console.log("[DEPRECTED] recursiveImport is a deprected api. Please use Utils.recursiveImport instead.", Error().stack);
+  return await _recursiveImport.call(this, ...args);
+}

package/src/methods/hookEventListeners.ts

@@ -3,6 +3,17 @@ import { NamespaceEnums } from "../../generated/namespaceData";
 import { DBI } from "../DBI";
 
 export function hookEventListeners(dbi: DBI<NamespaceEnums>): () => any {
+
+  function getClientByEvent(value) {
+    return value.triggerType == "OneByOne"
+    ? dbi.data.clients.next(`Event:${value.id}`)
+    : value.triggerType == "OneByOneGlobal"
+      ? dbi.data.clients.next("Event")
+      : value.triggerType == "Random"
+        ? dbi.data.clients.random()
+        : dbi.data.clients.first();
+  }
+
   async function handle(eventName: string, ...args: any[]) {
     if (!dbi.data.eventMap[eventName]) return;
 
@@ -47,11 +58,12 @@ export function hookEventListeners(dbi: DBI<NamespaceEnums>): () => any {
 
     for (let i = 0; i < unOrdered.length; i++) {
       const value = unOrdered[i];
+      
       if (dbi.config.strict) {
-        value.onExecute(arg);
+        value.onExecute({ ...arg, nextClient: getClientByEvent(value) });
       } else {
         try {
-          value.onExecute(arg)?.catch(error => {
+          value.onExecute({ ...arg, nextClient: getClientByEvent(value) })?.catch(error => {
             dbi.events.trigger("eventError", Object.assign(arg, { error }));
           });
         } catch (error) {
@@ -62,11 +74,12 @@ export function hookEventListeners(dbi: DBI<NamespaceEnums>): () => any {
 
     for (let i = 0; i < ordered.length; i++) {
       const value = ordered[i];
+
       if (dbi.config.strict) {
-        await value.onExecute(arg);
+        await value.onExecute({ ...arg, nextClient: getClientByEvent(value) });
       } else {
         try {
-          await value.onExecute(arg)?.catch(error => {
+          await value.onExecute({ ...arg, nextClient: getClientByEvent(value) })?.catch(error => {
             dbi.events.trigger("eventError", Object.assign(arg, { error }));
           });
         } catch (error) {
@@ -78,14 +91,15 @@ export function hookEventListeners(dbi: DBI<NamespaceEnums>): () => any {
     dbi.events.trigger("afterEvent", arg)
   }
 
-  let originalEmit = dbi.client.emit;
+  let firstClient = dbi.data.clients.first().client;
+  let originalEmit = firstClient.emit;
 
-  dbi.client.emit = function(eventName, ...args) {
+  firstClient.emit = function(eventName, ...args) {
     handle(eventName, ...args);
     return originalEmit.call(this, eventName, ...args);
   }
 
   return () => {
-    dbi.client.emit = originalEmit;
+    firstClient.emit = originalEmit;
   }
 }

package/src/methods/hookInteractionListeners.ts

@@ -139,9 +139,13 @@ export function hookInteractionListeners(dbi: DBI<NamespaceEnums>): () => any {
     dbi.events.trigger("afterInteraction", { dbi, interaction: inter, dbiInteraction: dbiInter, locale, setRateLimit, data, other });
   }
 
-  dbi.client.on("interactionCreate", handle);
+  dbi.data.clients.forEach(d=>{
+    d.client.on("interactionCreate", handle);
+  });
 
   return () => { 
-    dbi.client.off("interactionCreate", handle);
+    dbi.data.clients.forEach(d=>{
+      d.client.off("interactionCreate", handle);
+    });
   };
 }

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/Button.ts

@@ -1,7 +1,7 @@
 import Discord from "discord.js";
 import { DBI } from "../DBI";
 import { DBIBaseInteraction, IDBIBaseExecuteCtx, TDBIReferencedData } from "./Interaction";
-import { customIdBuilder } from "../utils/customId";
+import { buildCustomId } from "../utils/customId";
 import { IDBIToJSONArgs } from "../utils/UtilTypes";
 import { NamespaceEnums } from "../../generated/namespaceData";
 import stuffs from "stuffs";
@@ -28,7 +28,7 @@ export class DBIButton<TNamespace extends NamespaceEnums> extends DBIBaseInterac
   toJSON(arg: IDBIToJSONArgs<DBIButtonOverrides> = {}): Discord.ButtonComponentData {
     return {
       ...stuffs.defaultify((arg?.overrides || {}), this.options || {}, true),
-      customId: customIdBuilder(this.dbi as any, this.name, arg?.reference?.data || [], arg?.reference?.ttl),
+      customId: buildCustomId(this.dbi as any, this.name, arg?.reference?.data || [], arg?.reference?.ttl),
       type: Discord.ComponentType.Button,
     } as any;
   };

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/types/Modal.ts

@@ -1,7 +1,7 @@
 import { DBI } from "../DBI";
 import { DBIBaseInteraction, IDBIBaseExecuteCtx, TDBIReferencedData } from "./Interaction";
 import Discord from "discord.js";
-import { customIdBuilder } from "../utils/customId";
+import { buildCustomId } from "../utils/customId";
 import { IDBIToJSONArgs } from "../utils/UtilTypes";
 import { NamespaceEnums } from "../../generated/namespaceData";
 import stuffs from "stuffs";
@@ -36,7 +36,7 @@ export class DBIModal<TNamespace extends NamespaceEnums> extends DBIBaseInteract
   toJSON(arg: IDBIToJSONArgs<DBIModalOverrides> = {}): Discord.ModalComponentData {
     return {
       ...stuffs.defaultify((arg?.overrides || {}), this.options || {}, true),
-      customId: customIdBuilder(this.dbi as any, this.name, arg?.reference?.data || [], arg?.reference?.ttl)
+      customId: buildCustomId(this.dbi as any, this.name, arg?.reference?.data || [], arg?.reference?.ttl)
     } as any;
   };
 

package/src/types/SelectMenu.ts

@@ -1,7 +1,7 @@
 import Discord from "discord.js";
 import { DBI } from "../DBI";
 import { DBIBaseInteraction, IDBIBaseExecuteCtx, TDBIReferencedData } from "./Interaction";
-import { customIdBuilder } from "../utils/customId";
+import { buildCustomId } from "../utils/customId";
 import { IDBIToJSONArgs } from "../utils/UtilTypes";
 import { NamespaceEnums } from "../../generated/namespaceData";
 import stuffs from "stuffs";
@@ -30,7 +30,7 @@ export class DBISelectMenu<TNamespace extends NamespaceEnums> extends DBIBaseInt
   toJSON(arg: IDBIToJSONArgs<DBISelectMenuOverrides> = {}): Discord.BaseSelectMenuComponentData {
     return {
       ...stuffs.defaultify((arg?.overrides || {}), this.options || {}, true),
-      customId: customIdBuilder(this.dbi as any, this.name, arg?.reference?.data || [], arg?.reference?.ttl),
+      customId: buildCustomId(this.dbi as any, this.name, arg?.reference?.data || [], arg?.reference?.ttl),
       type: Discord.ComponentType.SelectMenu,
     } as any;
   };

package/src/utils/customId.ts

@@ -2,12 +2,13 @@ import { DBI } from "../DBI";
 import * as stuffs from "stuffs";
 import { NamespaceEnums } from "../../generated/namespaceData";
 
-export function customIdBuilder(dbi: DBI<NamespaceEnums>, name: string, customData: any[], ttl?:number): string {
+export function buildCustomId(dbi: DBI<NamespaceEnums>, name: string, data: any[], ttl?:number): string {
   let customId = [
     name,
-    ...customData.map(value => {
+    ...data.map(value => {
       if (typeof value == "string") return value;
       if (typeof value == "number") return `π${value}`;
+      if (typeof value == "boolean") return `𝞫${value ? 1 : 0}`;
       let id = stuffs.randomString(8);
       Object.assign(value, {
         $ref: id,
@@ -27,6 +28,7 @@ export function parseCustomId(dbi: DBI<NamespaceEnums>, customId: string): {name
   let name = splitted.shift();
   let data = splitted.map(value => {
     if (value.startsWith("π")) return Number(value.slice(1));
+    if (value.startsWith("𝞫")) return !!Number(value.slice(1));
     if (value.startsWith("¤")) return dbi.data.refs.get(value.slice(1))?.value;
     return value;
   });

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)
       }
     }