@stelliajs/framework 1.3.0-dev-1 → 1.3.0

package/README.md

@@ -3,7 +3,7 @@
 ## About
 
 StelliaJS is built using Discord JS V14 and TypeScript. It allows you to quickly set up a new bot with a simple and complete architecture.
-A CLI is currently being developed and will soon be available for even greater convenience.
+A CLI is available to help you set up a project with StelliaJS : [link to the CLI](https://github.com/StelliaJS/cli)
 
 ## Architecture
 Recommended architecture for StelliaJS project.
@@ -19,6 +19,10 @@ Recommended architecture for StelliaJS project.
 │   │       │   ├── ban.ts
 │   │       │   └── mute.ts
 │   │       └── ping.ts
+│   ├── environments/
+│   │   ├── environment.development.ts
+│   │   ├── environment.model.ts
+│   │   └── environment.ts
 │   ├── events/
 │   │   ├── ready.ts
 │   │   └── interactionCreate.ts
@@ -36,16 +40,17 @@ Recommended architecture for StelliaJS project.
 ├── .env
 ├── package.json
 ├── package-lock.json
+├── stellia.json
 └── tsconfig.json
 ```
+
 ## Examples
 
-### Simple client
+### Simple client with environment
 
 ```js
 import { StelliaClient } from "@stelliajs/framework";
-import { GatewayIntentBits } from "discord-api-types/v10";
-import { Partials } from "discord.js";
+import { GatewayIntentBits, Partials } from "discord.js";
 
 const client = new StelliaClient({
     intents: [
@@ -56,26 +61,31 @@ const client = new StelliaClient({
     ],
     partials: [Partials.Message, Partials.GuildMember]
 }, {
-    autoCompletes: {
-        directoryPath: "./interactions/autoCompletes"
-    },
-    buttons: {
-        directoryPath: "./interactions/buttons"
-    },
-    commands: {
-        directoryPath: "./commands/slash"
-    },
-    contextMenus: {
-        directoryPath: "./commands/contextMenus"
-    },
-    events: {
-        directoryPath: "./events"
-    },
-    modals: {
-        directoryPath: "./interactions/modals"
+    managers: {
+        autoCompletes: {
+            directoryPath: "./interactions/autoCompletes"
+        },
+        buttons: {
+            directoryPath: "./interactions/buttons"
+        },
+        commands: {
+            directoryPath: "./commands/slash"
+        },
+        contextMenus: {
+            directoryPath: "./commands/contextMenus"
+        },
+        events: {
+            directoryPath: "./events"
+        },
+        modals: {
+            directoryPath: "./interactions/modals"
+        },
+        selectMenus: {
+            directoryPath: "./interactions/selectMenus"
+        }
     },
-    selectMenus: {
-        directoryPath: "./interactions/selectMenus"
+    environment: {
+        areGuildsConfigurationEnabled: true
     }
 });
 
@@ -84,34 +94,36 @@ await client.connect(process.env.TOKEN);
 
 ### Simple event
 
-#### Ready event
+#### Ready event with environment
 ```js
 import { type StelliaClient, type EventStructure } from "@stelliajs/framework";
 import { Events } from "discord.js";
+import { type CustomGuildsConfiguration } from "@environments/environment.model.ts";
 
 export default {
     data: {
         name: Events.ClientReady,
         once: true
     },
-    async execute(client: StelliaClient<true>) { // <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
     }
 } as EventStructure;
 ```
 
-#### InteractionCreate event
+#### InteractionCreate event with environment
 ```js
 import { type StelliaClient, type EventStructure } from "@stelliajs/framework";
 import { Events, type Interaction } from "discord.js";
+import { type CustomGuildsConfiguration } from "@environments/environment.model.ts";
 
 export default {
     data: {
         name: Events.InteractionCreate,
         once: false
     },
-    async execute(client: StelliaClient<true>, interaction: Interaction) {
+    async execute(client: StelliaClient<true>, environment: CustomGuildsConfiguration, interaction: Interaction) {
         if (interaction.inCachedGuild()) {
             await client.handleInteraction(interaction); // Automatic interaction handling
         }
@@ -124,11 +136,12 @@ export default {
 ```js
 import { type CommandStructure, ephemeralFollowUpResponse, type StelliaClient } from "@stelliajs/framework";
 import { type ChatInputCommandInteraction, SlashCommandBuilder } from "discord.js";
+import { type CustomGuildsConfiguration } from "@environments/environment.model.ts";
 
 export default {
     data: new SlashCommandBuilder()
         .setName("ping"),
-    async execute(client: StelliaClient, 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,12 +4,16 @@ 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 = {};
     environment;
     constructor(clientOptions, stelliaOptions) {
         super(clientOptions);
+        if (stelliaOptions?.environment) {
+            this.environment = stelliaOptions.environment;
+        }
         if (stelliaOptions?.managers.autoCompletes?.directoryPath) {
             this.managers.autoCompletes = new AutoCompleteManager(this, stelliaOptions.managers.autoCompletes.directoryPath);
         }
@@ -31,29 +35,26 @@ export class StelliaClient extends Client {
         if (stelliaOptions?.managers.modals?.directoryPath) {
             this.managers.modals = new ModalManager(this, stelliaOptions.managers.modals.directoryPath);
         }
-        if (stelliaOptions?.environment) {
-            this.environment = stelliaOptions.environment;
-        }
         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,24 @@ 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: general,
+            guild: guildConfiguration
+        };
+    };
     handleInteraction = async (interaction) => {
         if (interaction.inCachedGuild()) {
             const interactionType = this.getInteractionType(interaction);
@@ -59,17 +72,18 @@ export class StelliaUtils {
             const autoComplete = autoCompleteManager.getByCustomId(autoCompleteInteraction.commandName);
             if (!autoComplete)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                const autoCompleteWithEnv = autoComplete;
-                await autoCompleteWithEnv.execute(this.client, this.environment, autoCompleteInteraction);
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const autoCompleteWithGuildConfiguration = autoComplete;
+                const guildConfiguration = this.getGuildConfiguration(autoCompleteInteraction.guildId);
+                await autoCompleteWithGuildConfiguration.execute(this.client, guildConfiguration, autoCompleteInteraction);
             }
             else {
-                const autoCompleteWithoutEnv = autoComplete;
-                await autoCompleteWithoutEnv.execute(this.client, autoCompleteInteraction);
+                const autoCompleteWithoutGuildConfiguration = autoComplete;
+                await autoCompleteWithoutGuildConfiguration.execute(this.client, autoCompleteInteraction);
             }
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling autocomplete interaction: ${error}`);
         }
     };
     handleButtonInteraction = async (interaction) => {
@@ -81,17 +95,18 @@ export class StelliaUtils {
             const button = buttonManager.getByCustomId(buttonInteraction.customId) || buttonManager.getByRegex(buttonInteraction.customId);
             if (!button)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                const buttonWithEnv = button;
-                await buttonWithEnv.execute(this.client, this.environment, buttonInteraction);
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const buttonWithGuildConfiguration = button;
+                const guildConfiguration = this.getGuildConfiguration(buttonInteraction.guildId);
+                await buttonWithGuildConfiguration.execute(this.client, guildConfiguration, buttonInteraction);
             }
             else {
-                const buttonWithoutEnv = button;
-                await buttonWithoutEnv.execute(this.client, buttonInteraction);
+                const buttonWithoutGuildConfiguration = button;
+                await buttonWithoutGuildConfiguration.execute(this.client, buttonInteraction);
             }
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling button interaction: ${error}`);
         }
     };
     handleCommandInteraction = async (interaction) => {
@@ -103,17 +118,18 @@ export class StelliaUtils {
             let command = commandManager.getByCustomId(commandInteraction.commandName);
             if (!command)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                const commandWithEnv = command;
-                await commandWithEnv.execute(this.client, this.environment, commandInteraction);
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const commandWithGuildConfiguration = command;
+                const guildConfiguration = this.getGuildConfiguration(commandInteraction.guildId);
+                await commandWithGuildConfiguration.execute(this.client, guildConfiguration, commandInteraction);
             }
             else {
-                const commandWithoutEnv = command;
-                await commandWithoutEnv.execute(this.client, commandInteraction);
+                const commandWithoutGuildConfiguration = command;
+                await commandWithoutGuildConfiguration.execute(this.client, commandInteraction);
             }
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling command interaction: ${error}`);
         }
     };
     handleContextMenuInteraction = async (interaction) => {
@@ -129,7 +145,7 @@ export class StelliaUtils {
             }
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling context menu interaction: ${error}`);
         }
     };
     handleModalInteraction = async (interaction) => {
@@ -141,17 +157,18 @@ export class StelliaUtils {
             const modal = modalManager.getByCustomId(modalInteraction.customId) || modalManager.getByRegex(modalInteraction.customId);
             if (!modal)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                const modalWithEnv = modal;
-                await modalWithEnv.execute(this.client, this.environment, modalInteraction);
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const modalWithGuildConfiguration = modal;
+                const guildConfiguration = this.getGuildConfiguration(modalInteraction.guildId);
+                await modalWithGuildConfiguration.execute(this.client, guildConfiguration, modalInteraction);
             }
             else {
-                const modalWithoutEnv = modal;
-                await modalWithoutEnv.execute(this.client, modalInteraction);
+                const modalWithoutGuildConfiguration = modal;
+                await modalWithoutGuildConfiguration.execute(this.client, modalInteraction);
             }
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling modal interaction: ${error}`);
         }
     };
     handleSelectMenuInteraction = async (interaction) => {
@@ -163,17 +180,18 @@ export class StelliaUtils {
             const selectMenu = selectMenuManager.getByCustomId(selectMenuInteraction.customId) || selectMenuManager.getByRegex(selectMenuInteraction.customId);
             if (!selectMenu)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                const selectMenuWithEnv = selectMenu;
-                await selectMenuWithEnv.execute(this.client, this.environment, selectMenuInteraction);
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const selectMenuWithGuildConfiguration = selectMenu;
+                const guildConfiguration = this.getGuildConfiguration(selectMenuInteraction.guildId);
+                await selectMenuWithGuildConfiguration.execute(this.client, guildConfiguration, selectMenuInteraction);
             }
             else {
-                const modalWithoutEnv = selectMenu;
-                await modalWithoutEnv.execute(this.client, selectMenuInteraction);
+                const modalWithoutGuildConfiguration = selectMenu;
+                await modalWithoutGuildConfiguration.execute(this.client, selectMenuInteraction);
             }
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling select menu interaction: ${error}`);
         }
     };
     handleMessageContextMenuInteraction = async (interaction) => {
@@ -184,17 +202,18 @@ export class StelliaUtils {
             const messageContextMenu = contextMenuManager.getByCustomId(interaction.commandName);
             if (!messageContextMenu)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                const messageContextMenuWithEnv = messageContextMenu;
-                await messageContextMenuWithEnv.execute(this.client, this.environment, interaction);
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const messageContextMenuWithGuildConfiguration = messageContextMenu;
+                const guildConfiguration = this.getGuildConfiguration(interaction.guildId);
+                await messageContextMenuWithGuildConfiguration.execute(this.client, guildConfiguration, interaction);
             }
             else {
-                const messageContextMenuWithoutEnv = messageContextMenu;
-                await messageContextMenuWithoutEnv.execute(this.client, interaction);
+                const messageContextMenuWithoutGuildConfiguration = messageContextMenu;
+                await messageContextMenuWithoutGuildConfiguration.execute(this.client, interaction);
             }
         }
         catch (error) {
-            console.error(error);
+            logger.error(`Error while handling message context menu interaction: ${error}`);
         }
     };
     handleUserContextMenuInteraction = async (interaction) => {
@@ -205,17 +224,18 @@ export class StelliaUtils {
             const userContextMenu = contextMenuManager.getByCustomId(interaction.commandName);
             if (!userContextMenu)
                 return;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                const userContextMenuWithEnv = userContextMenu;
-                await userContextMenuWithEnv.execute(this.client, this.environment, interaction);
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                const userContextMenuWithGuildConfiguration = userContextMenu;
+                const guildConfiguration = this.getGuildConfiguration(interaction.guildId);
+                await userContextMenuWithGuildConfiguration.execute(this.client, guildConfiguration, interaction);
             }
             else {
-                const userContextMenuWithoutEnv = userContextMenu;
-                await userContextMenuWithoutEnv.execute(this.client, interaction);
+                const userContextMenuWithoutGuildConfiguration = userContextMenu;
+                await userContextMenuWithoutGuildConfiguration.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,45 +1,32 @@
-import { Collection, Events } from "discord.js";
+import { Collection } 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 eventStructure of this.interactions.values()) {
-            const { name, once } = eventStructure.data;
-            if (this.client.environment.areEnvironmentsEnabled) {
-                const environment = await this.client.getEnvironment();
-                const event = eventStructure;
-                if (name == Events.ClientReady) {
-                    this.client.once(Events.ClientReady, () => 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));
-                }
+            if (this.client.environment.areGuildsConfigurationEnabled) {
+                await this.loadEventWithGuildConfiguration(eventStructure);
             }
             else {
-                const event = eventStructure;
-                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.setManagerLoaded();
     }
     getByCustomId(id) {
@@ -53,4 +40,45 @@ 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];
+        const guildConfiguration = this.getGuildConfiguration(mainArgument);
+        if (guildConfiguration) {
+            const eventStructure = event;
+            return eventStructure.execute(this.client, guildConfiguration, ...args);
+        }
+        const eventStructure = event;
+        return eventStructure.execute(this.client, this.guildsConfiguration);
+    };
+    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,19 +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 EventStructureWithEnvironment extends EventInteractionStructure {
-    execute(client: StelliaClient, environment: EnvironmentConfiguration, ...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 EventStructureWithoutEnvironment extends EventInteractionStructure {
-    execute(client: StelliaClient, ...args: ClientEvents[Event]): Awaitable<unknown>;
+export interface EventStructureWithAllGuildsConfiguration extends EventInteractionStructure {
+    execute(client: StelliaClient, guildsConfiguration: GuildsConfiguration, ...args: ClientEventsArgs): Awaitable<unknown>;
 }
-export type EventStructure = EventStructureWithEnvironment | EventStructureWithoutEnvironment;
+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: Event;
+    name: EventKeys;
     once: boolean;
 }
-type Event = keyof ClientEvents;
+export type ClientEventsArgs = ClientEvents[keyof ClientEvents];
+export type EventKeys = keyof ClientEvents;
 export {};

package/dist/structures/Interaction.d.ts

@@ -1,49 +1,49 @@
 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 AutoCompleteStructureWithEnvironment extends MessageInteractionStructure {
-    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
+export interface AutoCompleteStructureWithGuildConfiguration extends MessageInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
 }
-export interface AutoCompleteStructureWithoutEnvironment extends MessageInteractionStructure {
+export interface AutoCompleteStructureWithoutGuildConfiguration extends MessageInteractionStructure {
     execute(client: StelliaClient, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
 }
-export type AutoCompleteStructure = AutoCompleteStructureWithEnvironment | AutoCompleteStructureWithoutEnvironment;
-export interface ButtonStructureWithEnvironment extends MessageInteractionStructure {
-    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
+export type AutoCompleteStructure = AutoCompleteStructureWithGuildConfiguration | AutoCompleteStructureWithoutGuildConfiguration;
+export interface ButtonStructureWithGuildConfiguration extends MessageInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
 }
-export interface ButtonStructureWithoutEnvironment extends MessageInteractionStructure {
+export interface ButtonStructureWithoutGuildConfiguration extends MessageInteractionStructure {
     execute(client: StelliaClient, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
 }
-export type ButtonStructure = ButtonStructureWithEnvironment | ButtonStructureWithoutEnvironment;
-export interface CommandStructureWithEnvironment extends CommandInteractionStructure {
-    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
+export type ButtonStructure = ButtonStructureWithGuildConfiguration | ButtonStructureWithoutGuildConfiguration;
+export interface CommandStructureWithGuildConfiguration extends CommandInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
 }
-export interface CommandStructureWithoutEnvironment extends CommandInteractionStructure {
+export interface CommandStructureWithoutGuildConfiguration extends CommandInteractionStructure {
     execute(client: StelliaClient, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
 }
-export type CommandStructure = CommandStructureWithEnvironment | CommandStructureWithoutEnvironment;
-export interface ContextMenuStructureWithEnvironment extends ContextMenuInteractionStructure {
-    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
+export type CommandStructure = CommandStructureWithGuildConfiguration | CommandStructureWithoutGuildConfiguration;
+export interface ContextMenuStructureWithGuildConfiguration extends ContextMenuInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
 }
-export interface ContextMenuStructureWithoutEnvironment extends ContextMenuInteractionStructure {
+export interface ContextMenuStructureWithoutGuildConfiguration extends ContextMenuInteractionStructure {
     execute(client: StelliaClient, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
 }
-export type ContextMenuStructure = ContextMenuStructureWithEnvironment | ContextMenuStructureWithoutEnvironment;
-export interface ModalStructureWithEnvironment extends MessageInteractionStructure {
-    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
+export type ContextMenuStructure = ContextMenuStructureWithGuildConfiguration | ContextMenuStructureWithoutGuildConfiguration;
+export interface ModalStructureWithGuildConfiguration extends MessageInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
 }
-export interface ModalStructureWithoutEnvironment extends MessageInteractionStructure {
+export interface ModalStructureWithoutGuildConfiguration extends MessageInteractionStructure {
     execute(client: StelliaClient, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
 }
-export type ModalStructure = ModalStructureWithEnvironment | ModalStructureWithoutEnvironment;
-export interface SelectMenuStructureWithEnvironment extends MessageInteractionStructure {
-    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
+export type ModalStructure = ModalStructureWithGuildConfiguration | ModalStructureWithoutGuildConfiguration;
+export interface SelectMenuStructureWithGuildConfiguration extends MessageInteractionStructure {
+    execute(client: StelliaClient, guildConfiguration: GuildConfigurationType, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
 }
-export interface SelectMenuStructureWithoutEnvironment extends MessageInteractionStructure {
+export interface SelectMenuStructureWithoutGuildConfiguration extends MessageInteractionStructure {
     execute(client: StelliaClient, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
 }
-export type SelectMenuStructure = SelectMenuStructureWithEnvironment | SelectMenuStructureWithoutEnvironment;
+export type SelectMenuStructure = SelectMenuStructureWithGuildConfiguration | SelectMenuStructureWithoutGuildConfiguration;
 export type AnyInteractionStructure = AutoCompleteStructure | ButtonStructure | CommandStructure | ContextMenuStructure | EventStructure | ModalStructure | SelectMenuStructure;
 interface CommandInteractionStructure {
     data: SlashCommandOptionsOnlyBuilder;

package/dist/typescript/types.d.ts

@@ -1,4 +1,5 @@
 import { type AutoCompleteManager, type ButtonManager, type CommandManager, type ContextMenuManager, type EventManager, type ModalManager, type SelectMenuManager } from "../managers/index.js";
+import { type Snowflake } from "discord.js";
 export type StructureCustomId = string | RegExp;
 export type InteractionCustomId = string;
 export declare enum InteractionType {
@@ -20,9 +21,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 in Snowflake]: BaseGuildConfiguration;
+    };
+}
+export interface GuildConfiguration {
+    general: BaseGeneralConfiguration;
+    guild: BaseGuildConfiguration;
+}
+export type GuildConfigurationType = GuildConfiguration | undefined;

package/dist/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./ephemeralReponse.js";
 export * from "./files.js";
+export * from "./logger.js";

package/dist/utils/index.js

@@ -1,2 +1,3 @@
 export * from "./ephemeralReponse.js";
 export * from "./files.js";
+export * from "./logger.js";

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.3.0-dev-1",
+  "version": "1.3.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
@@ -15,13 +15,14 @@
   "description": "A framework for simplify the creation of discord bots",
   "keywords": ["discord", "bot", "discordjs", "typescript", "framework"],
   "dependencies": {
-    "discord-api-types": "^0.38.2",
-    "discord.js": "^14.19.3"
+    "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.15"
+    "tsc-alias": "^1.8.16"
   },
   "type": "module",
-  "packageManager": "pnpm@10.10.0"
+  "packageManager": "pnpm@10.11.1"
 }