@stelliajs/framework 1.2.3 → 1.3.0-dev-2

package/README.md

@@ -85,7 +85,7 @@ const client = new StelliaClient({
         }
     },
     environment: {
-        areEnvironmentsEnabled: true
+        areGuildsConfigurationEnabled: true
     }
 });
 
@@ -98,14 +98,14 @@ await client.connect(process.env.TOKEN);
 ```js
 import { type StelliaClient, type EventStructure } from "@stelliajs/framework";
 import { Events } from "discord.js";
-import { type CustomEnvironment } from "@environments/environment.model.ts";
+import { type CustomGuildsConfiguration } from "@environments/environment.model.ts";
 
 export default {
     data: {
         name: Events.ClientReady,
         once: true
     },
-    async execute(client: StelliaClient<true>, environment: CustomEnvironment) { // <true> ensures that the client is Ready
+    async execute(client: StelliaClient<true>, environment: CustomGuildsConfiguration) { // <true> ensures that the client is Ready
         console.log(`Logged in as ${client.user.tag}`);
         await client.initializeCommands(); // Used to initialise registered commands
     }
@@ -116,14 +116,14 @@ export default {
 ```js
 import { type StelliaClient, type EventStructure } from "@stelliajs/framework";
 import { Events, type Interaction } from "discord.js";
-import { type CustomEnvironment } from "@environments/environment.model.ts";
+import { type CustomGuildsConfiguration } from "@environments/environment.model.ts";
 
 export default {
     data: {
         name: Events.InteractionCreate,
         once: false
     },
-    async execute(client: StelliaClient<true>, environment: CustomEnvironment, interaction: Interaction) {
+    async execute(client: StelliaClient<true>, environment: CustomGuildsConfiguration, interaction: Interaction) {
         if (interaction.inCachedGuild()) {
             await client.handleInteraction(interaction); // Automatic interaction handling
         }
@@ -136,12 +136,12 @@ export default {
 ```js
 import { type CommandStructure, ephemeralFollowUpResponse, type StelliaClient } from "@stelliajs/framework";
 import { type ChatInputCommandInteraction, SlashCommandBuilder } from "discord.js";
-import { type CustomEnvironment } from "@environments/environment.model.ts";
+import { type CustomGuildsConfiguration } from "@environments/environment.model.ts";
 
 export default {
     data: new SlashCommandBuilder()
         .setName("ping"),
-    async execute(client: StelliaClient, environment: CustomEnvironment, interaction: ChatInputCommandInteraction<"cached">) { // All interactions are cached
+    async execute(client: StelliaClient, environment: CustomGuildsConfiguration, interaction: ChatInputCommandInteraction<"cached">) { // All interactions are cached
         await ephemeralFollowUpResponse(interaction, "Pong!", true); // Response is ephemeral and deleted after 60 seconds
     }
 } as CommandStructure;

package/dist/client/StelliaClient.d.ts

@@ -1,14 +1,15 @@
 import { Client, type ClientOptions, type Interaction } from "discord.js";
 import { type ManagerOptions } from "../managers/index.js";
-import { type Environment, type EnvironmentConfiguration, type Managers } from "../typescript/index.js";
+import { type ClientEnvironment, type GuildConfigurationType, type GuildsConfiguration, type Managers } from "../typescript/index.js";
 export declare class StelliaClient<Ready extends boolean = boolean> extends Client<Ready> {
     private readonly utils;
     readonly managers: Managers;
-    readonly environment: Environment;
+    readonly environment: ClientEnvironment;
     constructor(clientOptions: ClientOptions, stelliaOptions?: StelliaOptions);
     connect: (token: string) => Promise<void>;
     initializeCommands: () => Promise<void>;
-    getEnvironment: <CustomEnvironment extends EnvironmentConfiguration>() => Promise<CustomEnvironment>;
+    getGuildsConfiguration: <CustomGuildsConfiguration extends GuildsConfiguration>() => Promise<CustomGuildsConfiguration>;
+    getGuildConfiguration: (guildId: string) => GuildConfigurationType;
     handleInteraction: (interaction: Interaction<"cached">) => Promise<void>;
     private areManagersLoaded;
     private static convertFilePathToProduction;
@@ -23,6 +24,6 @@ interface StelliaOptions {
         selectMenus?: ManagerOptions;
         modals?: ManagerOptions;
     };
-    environment?: Environment;
+    environment?: ClientEnvironment;
 }
 export {};

package/dist/client/StelliaClient.js

@@ -4,6 +4,7 @@ import { StelliaUtils } from "./index.js";
 import path from "path";
 import * as fs from "node:fs";
 import { pathToFileURL } from "url";
+import { logger } from "../utils/logger.js";
 export class StelliaClient extends Client {
     utils;
     managers = {};
@@ -36,24 +37,24 @@ export class StelliaClient extends Client {
         }
         this.utils = new StelliaUtils(this);
         process.on("unhandledRejection", (error) => {
-            console.error(`Unhandled promise rejection: ${error}`);
+            logger.error(`Unhandled promise rejection: ${error}`);
         });
     }
     connect = async (token) => {
         if (!this.areManagersLoaded()) {
             setTimeout(() => {
-                console.log("Managers are not loaded yet, retrying in 500ms...");
+                logger.warn("Managers are not loaded yet, retrying in 500ms...");
                 this.connect(token);
             }, 500);
             return;
         }
-        console.log("Managers are loaded, connecting to Discord...");
+        logger.success("Managers are loaded, connecting to Discord...");
         await this.login(token);
     };
     initializeCommands = async () => {
         await this.utils.initializeCommands();
     };
-    getEnvironment = async () => {
+    getGuildsConfiguration = async () => {
         const chosenEnvironment = process.argv.find(arg => arg.startsWith("--config"))?.split("=")[1];
         if (!chosenEnvironment) {
             throw new Error("Environment not provided");
@@ -82,6 +83,9 @@ export class StelliaClient extends Client {
             });
         });
     };
+    getGuildConfiguration = (guildId) => {
+        return this.utils.getGuildConfiguration(guildId);
+    };
     handleInteraction = async (interaction) => {
         await this.utils.handleInteraction(interaction);
     };

package/dist/client/StelliaUtils.d.ts

@@ -1,11 +1,13 @@
 import { type StelliaClient } from "./index.js";
 import { type Interaction } from "discord.js";
+import { type GuildConfiguration } from "../typescript/index.js";
 export declare class StelliaUtils {
     readonly client: StelliaClient;
     private readonly interactionHandlers;
-    private environment;
+    private guildsConfiguration;
     constructor(client: StelliaClient);
     initializeCommands: () => Promise<void>;
+    getGuildConfiguration: (guildId: string) => GuildConfiguration | undefined;
     handleInteraction: (interaction: Interaction<"cached">) => Promise<void>;
     private handleAutoCompleteInteraction;
     private handleButtonInteraction;

package/dist/client/StelliaUtils.js

@@ -1,10 +1,11 @@
 import { ApplicationCommandType, REST, Routes } from "discord.js";
 import { DISCORD_API_VERSION } from "../constants/index.js";
 import { InteractionType } from "../typescript/index.js";
+import { logger } from "../utils/logger.js";
 export class StelliaUtils {
     client;
     interactionHandlers;
-    environment;
+    guildsConfiguration;
     constructor(client) {
         this.client = client;
         this.interactionHandlers = new Map([
@@ -15,13 +16,13 @@ export class StelliaUtils {
             [InteractionType.ModalSubmit, this.handleModalInteraction],
             [InteractionType.SelectMenu, this.handleSelectMenuInteraction]
         ]);
-        if (this.client.environment.areEnvironmentsEnabled) {
-            this.client.getEnvironment()
-                .then((environment) => {
-                this.environment = environment;
-                console.log("Environment loaded");
+        if (this.client.environment.areGuildsConfigurationEnabled) {
+            this.client.getGuildsConfiguration()
+                .then((guildsConfiguration) => {
+                this.guildsConfiguration = guildsConfiguration;
+                logger.success("Guilds configuration loaded successfully for interactions");
             })
-                .catch((error) => console.error(error));
+                .catch((error) => logger.error(`Error while loading guilds configuration: ${error}`));
         }
     }
     initializeCommands = async () => {
@@ -32,12 +33,21 @@ export class StelliaUtils {
             const rest = new REST({ version: DISCORD_API_VERSION }).setToken(this.client.token);
             try {
                 await rest.put(Routes.applicationCommands(this.client.user.id), { body: applicationCommands });
+                logger.success("Application commands registered successfully");
             }
             catch (error) {
-                console.error(error);
+                logger.error(`Error while registering application commands: ${error}`);
             }
         }
     };
+    getGuildConfiguration = (guildId) => {
+        if (!this.client.environment.areGuildsConfigurationEnabled || !this.guildsConfiguration) {
+            return undefined;
+        }
+        const { guilds, ...general } = this.guildsConfiguration;
+        const guildConfiguration = guilds[guildId];
+        return { general, guild: guildConfiguration };
+    };
     handleInteraction = async (interaction) => {
         if (interaction.inCachedGuild()) {
             const interactionType = this.getInteractionType(interaction);
@@ -52,21 +62,25 @@ export class StelliaUtils {
     };
     handleAutoCompleteInteraction = async (interaction) => {
         try {
-            const interactionAutoComplete = interaction;
+            const autoCompleteInteraction = interaction;
             const autoCompleteManager = this.client.managers.autoCompletes;
             if (!autoCompleteManager)
                 return;
-            const autoComplete = autoCompleteManager.getByCustomId(interactionAutoComplete.commandName);
+            const autoComplete = autoCompleteManager.getByCustomId(autoCompleteInteraction.commandName);
             if (!autoComplete)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                await autoComplete.execute(this.client, this.environment, interactionAutoComplete);
-                return;
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const autoCompleteWithGuildConfiguration = autoComplete;
+                const guildConfiguration = this.getGuildConfiguration(autoCompleteInteraction.guildId);
+                await autoCompleteWithGuildConfiguration.execute(this.client, guildConfiguration, autoCompleteInteraction);
+            }
+            else {
+                const autoCompleteWithoutGuildConfiguration = autoComplete;
+                await autoCompleteWithoutGuildConfiguration.execute(this.client, autoCompleteInteraction);
             }
-            await autoComplete.execute(this.client, interactionAutoComplete);
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling autocomplete interaction: ${error}`);
         }
     };
     handleButtonInteraction = async (interaction) => {
@@ -78,33 +92,41 @@ export class StelliaUtils {
             const button = buttonManager.getByCustomId(buttonInteraction.customId) || buttonManager.getByRegex(buttonInteraction.customId);
             if (!button)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                await button.execute(this.client, this.environment, buttonInteraction);
-                return;
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const buttonWithGuildConfiguration = button;
+                const guildConfiguration = this.getGuildConfiguration(buttonInteraction.guildId);
+                await buttonWithGuildConfiguration.execute(this.client, guildConfiguration, buttonInteraction);
+            }
+            else {
+                const buttonWithoutGuildConfiguration = button;
+                await buttonWithoutGuildConfiguration.execute(this.client, buttonInteraction);
             }
-            await button.execute(this.client, buttonInteraction);
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling button interaction: ${error}`);
         }
     };
     handleCommandInteraction = async (interaction) => {
         try {
-            const interactionCommand = interaction;
+            const commandInteraction = interaction;
             const commandManager = this.client.managers.commands;
             if (!commandManager)
                 return;
-            const command = commandManager.getByCustomId(interactionCommand.commandName);
+            let command = commandManager.getByCustomId(commandInteraction.commandName);
             if (!command)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                await command.execute(this.client, this.environment, interactionCommand);
-                return;
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const commandWithGuildConfiguration = command;
+                const guildConfiguration = this.getGuildConfiguration(commandInteraction.guildId);
+                await commandWithGuildConfiguration.execute(this.client, guildConfiguration, commandInteraction);
+            }
+            else {
+                const commandWithoutGuildConfiguration = command;
+                await commandWithoutGuildConfiguration.execute(this.client, commandInteraction);
             }
-            await command.execute(this.client, interactionCommand);
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling command interaction: ${error}`);
         }
     };
     handleContextMenuInteraction = async (interaction) => {
@@ -120,45 +142,53 @@ export class StelliaUtils {
             }
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling context menu interaction: ${error}`);
         }
     };
     handleModalInteraction = async (interaction) => {
         try {
-            const interactionModal = interaction;
+            const modalInteraction = interaction;
             const modalManager = this.client.managers.modals;
             if (!modalManager)
                 return;
-            const modal = modalManager.getByCustomId(interactionModal.customId) || modalManager.getByRegex(interactionModal.customId);
+            const modal = modalManager.getByCustomId(modalInteraction.customId) || modalManager.getByRegex(modalInteraction.customId);
             if (!modal)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                await modal.execute(this.client, this.environment, interactionModal);
-                return;
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const modalWithGuildConfiguration = modal;
+                const guildConfiguration = this.getGuildConfiguration(modalInteraction.guildId);
+                await modalWithGuildConfiguration.execute(this.client, guildConfiguration, modalInteraction);
+            }
+            else {
+                const modalWithoutGuildConfiguration = modal;
+                await modalWithoutGuildConfiguration.execute(this.client, modalInteraction);
             }
-            await modal.execute(this.client, interactionModal);
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling modal interaction: ${error}`);
         }
     };
     handleSelectMenuInteraction = async (interaction) => {
         try {
-            const interactionSelectMenu = interaction;
+            const selectMenuInteraction = interaction;
             const selectMenuManager = this.client.managers.selectMenus;
             if (!selectMenuManager)
                 return;
-            const selectMenu = selectMenuManager.getByCustomId(interactionSelectMenu.customId) || selectMenuManager.getByRegex(interactionSelectMenu.customId);
+            const selectMenu = selectMenuManager.getByCustomId(selectMenuInteraction.customId) || selectMenuManager.getByRegex(selectMenuInteraction.customId);
             if (!selectMenu)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                await selectMenu.execute(this.client, this.environment, interactionSelectMenu);
-                return;
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const selectMenuWithGuildConfiguration = selectMenu;
+                const guildConfiguration = this.getGuildConfiguration(selectMenuInteraction.guildId);
+                await selectMenuWithGuildConfiguration.execute(this.client, guildConfiguration, selectMenuInteraction);
+            }
+            else {
+                const modalWithoutGuildConfiguration = selectMenu;
+                await modalWithoutGuildConfiguration.execute(this.client, selectMenuInteraction);
             }
-            await selectMenu.execute(this.client, interactionSelectMenu);
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling select menu interaction: ${error}`);
         }
     };
     handleMessageContextMenuInteraction = async (interaction) => {
@@ -169,14 +199,18 @@ export class StelliaUtils {
             const messageContextMenu = contextMenuManager.getByCustomId(interaction.commandName);
             if (!messageContextMenu)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                await messageContextMenu.execute(this.client, this.environment, interaction);
-                return;
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const messageContextMenuWithGuildConfiguration = messageContextMenu;
+                const guildConfiguration = this.getGuildConfiguration(interaction.guildId);
+                await messageContextMenuWithGuildConfiguration.execute(this.client, guildConfiguration, interaction);
+            }
+            else {
+                const messageContextMenuWithoutGuildConfiguration = messageContextMenu;
+                await messageContextMenuWithoutGuildConfiguration.execute(this.client, interaction);
             }
-            await messageContextMenu.execute(this.client, interaction);
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling message context menu interaction: ${error}`);
         }
     };
     handleUserContextMenuInteraction = async (interaction) => {
@@ -187,14 +221,18 @@ export class StelliaUtils {
             const userContextMenu = contextMenuManager.getByCustomId(interaction.commandName);
             if (!userContextMenu)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                await userContextMenu.execute(this.client, this.environment, interaction);
-                return;
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const userContextMenuWithGuildConfiguration = userContextMenu;
+                const guildConfiguration = this.getGuildConfiguration(interaction.guildId);
+                await userContextMenuWithGuildConfiguration.execute(this.client, guildConfiguration, interaction);
+            }
+            else {
+                const userContextMenuWithoutGuildConfiguration = userContextMenu;
+                await userContextMenuWithoutGuildConfiguration.execute(this.client, interaction);
             }
-            await userContextMenu.execute(this.client, interaction);
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling user context menu interaction: ${error}`);
         }
     };
     getInteractionType(interaction) {

package/dist/managers/EventManager.d.ts

@@ -4,9 +4,14 @@ import { BaseManager } from "./index.js";
 import { type StructureCustomId, type InteractionCustomId } from "../typescript/index.js";
 export declare class EventManager extends BaseManager {
     private interactions;
+    private guildsConfiguration;
     constructor(client: StelliaClient, directoryPath: string);
     loadData(): Promise<void>;
     getByCustomId<EventStructure>(id: InteractionCustomId): EventStructure | undefined;
     getByRegex<EventStructure>(id: InteractionCustomId): EventStructure | undefined;
     getAll<EventStructure>(): Collection<StructureCustomId, EventStructure>;
+    private loadEventWithGuildConfiguration;
+    private eventHandler;
+    private loadEventWithoutGuildConfiguration;
+    private getGuildConfiguration;
 }

package/dist/managers/EventManager.js

@@ -1,43 +1,33 @@
 import { Collection, Events } from "discord.js";
 import { BaseManager } from "./index.js";
 import { requiredFiles } from "../utils/index.js";
+import { logger } from "../utils/logger.js";
 export class EventManager extends BaseManager {
     interactions = new Collection();
+    guildsConfiguration;
     constructor(client, directoryPath) {
         super(client, directoryPath);
+        if (this.client.environment.areGuildsConfigurationEnabled) {
+            this.client.getGuildsConfiguration()
+                .then((guildsConfiguration) => {
+                this.guildsConfiguration = guildsConfiguration;
+                logger.success("Guilds configuration loaded successfully for event manager");
+            })
+                .catch((error) => logger.error(`Error while loading guilds configuration: ${error}`));
+        }
     }
     async loadData() {
         const events = await requiredFiles(this.directoryPath);
         this.interactions = events;
-        for (const event of this.interactions.values()) {
-            const { name, once } = event.data;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                const environment = await this.client.getEnvironment();
-                if (name == Events.ClientReady) {
-                    this.client.once(name, () => event.execute(this.client, environment));
-                    continue;
-                }
-                if (once) {
-                    this.client.once(name, (...args) => event.execute(this.client, environment, ...args));
-                }
-                else {
-                    this.client.on(name, (...args) => event.execute(this.client, environment, ...args));
-                }
+        for (const eventStructure of this.interactions.values()) {
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                await this.loadEventWithGuildConfiguration(eventStructure);
             }
             else {
-                if (name == Events.ClientReady) {
-                    this.client.once(name, () => event.execute(this.client));
-                    continue;
-                }
-                if (once) {
-                    this.client.once(name, (...args) => event.execute(this.client, ...args));
-                }
-                else {
-                    this.client.on(name, (...args) => event.execute(this.client, ...args));
-                }
+                await this.loadEventWithoutGuildConfiguration(eventStructure);
             }
         }
-        this.client.on(Events.Error, (error) => console.error(error));
+        this.client.on(Events.Error, (error) => logger.error(`Client error: ${error}`));
         this.setManagerLoaded();
     }
     getByCustomId(id) {
@@ -51,4 +41,48 @@ export class EventManager extends BaseManager {
         const events = this.interactions;
         return events;
     }
+    async loadEventWithGuildConfiguration(eventStructure) {
+        const { name, once } = eventStructure.data;
+        const event = eventStructure;
+        if (once) {
+            this.client.once(name, (...args) => this.eventHandler(event, ...args));
+        }
+        else {
+            this.client.on(name, (...args) => this.eventHandler(event, ...args));
+        }
+    }
+    eventHandler = (event, ...args) => {
+        const mainArgument = args[0];
+        if (!mainArgument) {
+            const eventStructure = event;
+            return eventStructure.execute(this.client, this.guildsConfiguration);
+        }
+        const guildConfiguration = this.getGuildConfiguration(mainArgument);
+        if (guildConfiguration) {
+            const eventStructure = event;
+            return eventStructure.execute(this.client, guildConfiguration, ...args);
+        }
+        logger.warn(`No guild configuration found for event ${event.data.name} with main argument ${mainArgument}`);
+    };
+    async loadEventWithoutGuildConfiguration(eventStructure) {
+        const { name, once } = eventStructure.data;
+        const event = eventStructure;
+        if (once) {
+            this.client.once(name, (...args) => event.execute(this.client, ...args));
+        }
+        else {
+            this.client.on(name, (...args) => event.execute(this.client, ...args));
+        }
+    }
+    getGuildConfiguration(mainArgument) {
+        if (mainArgument && typeof mainArgument === "object") {
+            if ("guildId" in mainArgument && mainArgument.guildId) {
+                return this.client.getGuildConfiguration(mainArgument.guildId);
+            }
+            if ("guild" in mainArgument && mainArgument.guild) {
+                return this.client.getGuildConfiguration(mainArgument.guild.id);
+            }
+        }
+        return undefined;
+    }
 }

package/dist/structures/Event.d.ts

@@ -1,14 +1,24 @@
 import { type Awaitable, type ClientEvents } from "discord.js";
 import { type StelliaClient } from "../client/index.js";
-import type { EnvironmentConfiguration } from "../typescript/types.js";
-export interface EventStructure<Event extends keyof ClientEvents = keyof ClientEvents> {
-    data: {
-        name: Event;
-        once: boolean;
-    };
-    execute(client: StelliaClient): Awaitable<unknown>;
-    execute(...args: ClientEvents[Event]): Awaitable<unknown>;
-    execute(client: StelliaClient, ...args: ClientEvents[Event]): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, ...args: ClientEvents[Event]): Awaitable<unknown>;
+import { type GuildConfigurationType, type GuildsConfiguration } from "../typescript/types.js";
+export interface EventStructureWithGuildConfiguration extends EventInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, ...args: ClientEventsArgs): Awaitable<unknown>;
 }
+export interface EventStructureWithAllGuildsConfiguration extends EventInteractionStructure {
+    execute(client: StelliaClient, guildsConfiguration: GuildsConfiguration, ...args: ClientEventsArgs): Awaitable<unknown>;
+}
+export interface EventStructureWithoutGuildConfiguration extends EventInteractionStructure {
+    execute(client: StelliaClient, ...args: ClientEventsArgs): Awaitable<unknown>;
+}
+export type EventStructureWithConfiguration = EventStructureWithGuildConfiguration | EventStructureWithAllGuildsConfiguration;
+export type EventStructure = EventStructureWithGuildConfiguration | EventStructureWithAllGuildsConfiguration | EventStructureWithoutGuildConfiguration;
+interface EventInteractionStructure {
+    data: EventDataStructure;
+}
+interface EventDataStructure {
+    name: EventKeys;
+    once: boolean;
+}
+export type ClientEventsArgs = ClientEvents[keyof ClientEvents];
+export type EventKeys = keyof ClientEvents;
+export {};

package/dist/structures/Interaction.d.ts

@@ -1,39 +1,64 @@
-import { type AnySelectMenuInteraction, type AutocompleteInteraction, type Awaitable, type ButtonInteraction, type ChatInputCommandInteraction, type ContextMenuCommandBuilder, type MessageContextMenuCommandInteraction, type ModalSubmitInteraction, type SlashCommandBuilder, type UserContextMenuCommandInteraction } from "discord.js";
+import { type AnySelectMenuInteraction, type AutocompleteInteraction, type Awaitable, type ButtonInteraction, type ChatInputCommandInteraction, type ContextMenuCommandType, type MessageContextMenuCommandInteraction, type ModalSubmitInteraction, type SlashCommandOptionsOnlyBuilder, type UserContextMenuCommandInteraction } from "discord.js";
 import { type StelliaClient } from "../client/index.js";
-import { type EnvironmentConfiguration } from "../typescript/index.js";
+import { type GuildConfigurationType } from "../typescript/index.js";
 import { type EventStructure } from "./Event.js";
-export interface AutoCompleteStructure {
-    data: DefaultDataStructure;
+export interface AutoCompleteStructureWithGuildConfiguration extends MessageInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
+}
+export interface AutoCompleteStructureWithoutGuildConfiguration extends MessageInteractionStructure {
     execute(client: StelliaClient, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
 }
-export interface ButtonStructure {
-    data: DefaultDataStructure;
+export type AutoCompleteStructure = AutoCompleteStructureWithGuildConfiguration | AutoCompleteStructureWithoutGuildConfiguration;
+export interface ButtonStructureWithGuildConfiguration extends MessageInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
+}
+export interface ButtonStructureWithoutGuildConfiguration extends MessageInteractionStructure {
     execute(client: StelliaClient, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
 }
-export interface CommandStructure {
-    data: SlashCommandBuilder;
+export type ButtonStructure = ButtonStructureWithGuildConfiguration | ButtonStructureWithoutGuildConfiguration;
+export interface CommandStructureWithGuildConfiguration extends CommandInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
+}
+export interface CommandStructureWithoutGuildConfiguration extends CommandInteractionStructure {
     execute(client: StelliaClient, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
 }
-export interface ContextMenuStructure {
-    data: ContextMenuCommandBuilder;
+export type CommandStructure = CommandStructureWithGuildConfiguration | CommandStructureWithoutGuildConfiguration;
+export interface ContextMenuStructureWithGuildConfiguration extends ContextMenuInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
+}
+export interface ContextMenuStructureWithoutGuildConfiguration extends ContextMenuInteractionStructure {
     execute(client: StelliaClient, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
 }
-export interface ModalStructure {
-    data: DefaultDataStructure;
+export type ContextMenuStructure = ContextMenuStructureWithGuildConfiguration | ContextMenuStructureWithoutGuildConfiguration;
+export interface ModalStructureWithGuildConfiguration extends MessageInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
+}
+export interface ModalStructureWithoutGuildConfiguration extends MessageInteractionStructure {
     execute(client: StelliaClient, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
 }
-export interface SelectMenuStructure {
-    data: DefaultDataStructure;
+export type ModalStructure = ModalStructureWithGuildConfiguration | ModalStructureWithoutGuildConfiguration;
+export interface SelectMenuStructureWithGuildConfiguration extends MessageInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
+}
+export interface SelectMenuStructureWithoutGuildConfiguration extends MessageInteractionStructure {
     execute(client: StelliaClient, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
 }
+export type SelectMenuStructure = SelectMenuStructureWithGuildConfiguration | SelectMenuStructureWithoutGuildConfiguration;
 export type AnyInteractionStructure = AutoCompleteStructure | ButtonStructure | CommandStructure | ContextMenuStructure | EventStructure | ModalStructure | SelectMenuStructure;
-interface DefaultDataStructure {
+interface CommandInteractionStructure {
+    data: SlashCommandOptionsOnlyBuilder;
+}
+interface ContextMenuInteractionStructure {
+    data: ContextMenuDataStructure;
+}
+interface ContextMenuDataStructure {
+    name: string;
+    type: ContextMenuCommandType;
+}
+interface MessageInteractionStructure {
+    data: MessageDataStructure;
+}
+interface MessageDataStructure {
     name: string | RegExp;
     once: boolean;
 }

package/dist/typescript/types.d.ts

@@ -20,9 +20,26 @@ export interface Managers {
     selectMenus?: SelectMenuManager;
     modals?: ModalManager;
 }
-export interface Environment {
-    areEnvironmentsEnabled: boolean;
+export interface ClientEnvironment {
+    areGuildsConfigurationEnabled: boolean;
 }
-export interface EnvironmentConfiguration {
+export interface BaseGuildConfiguration {
+    locale: string;
     [key: string]: unknown;
 }
+export interface BaseGeneralConfiguration {
+    [key: string]: unknown;
+}
+export interface GuildsConfiguration {
+    general: {
+        [key: string]: unknown;
+    };
+    guilds: {
+        [guildId: string]: BaseGuildConfiguration;
+    };
+}
+export interface GuildConfiguration {
+    general: BaseGeneralConfiguration;
+    guild: BaseGuildConfiguration;
+}
+export type GuildConfigurationType = GuildConfiguration | undefined;

package/dist/utils/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    info: (message: string) => void;
+    success: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,15 @@
+import logSymbols from "log-symbols";
+export const logger = {
+    info: (message) => {
+        console.log(`${logSymbols.info} ${message}`);
+    },
+    success: (message) => {
+        console.log(`${logSymbols.success} ${message}`);
+    },
+    warn: (message) => {
+        console.warn(`${logSymbols.warning} ${message}`);
+    },
+    error: (message) => {
+        console.error(`${logSymbols.error} ${message}`);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stelliajs/framework",
-  "version": "1.2.3",
+  "version": "1.3.0-dev-2",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
@@ -15,12 +15,14 @@
   "description": "A framework for simplify the creation of discord bots",
   "keywords": ["discord", "bot", "discordjs", "typescript", "framework"],
   "dependencies": {
-    "discord-api-types": "^0.37.119",
-    "discord.js": "^14.18.0"
+    "discord-api-types": "^0.38.10",
+    "discord.js": "^14.19.3",
+    "log-symbols": "^7.0.1"
   },
   "devDependencies": {
     "ts-node": "^10.9.2",
-    "tsc-alias": "^1.8.10"
+    "tsc-alias": "^1.8.16"
   },
-  "type": "module"
+  "type": "module",
+  "packageManager": "pnpm@10.11.1"
 }