kythia-core 0.9.4-beta.2 → 0.9.5-beta

package/changelog.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.9.5-beta](https://github.com/kenndeclouv/kythia-core/compare/v0.9.4-beta.3...v0.9.5-beta) (2025-11-11)
+
+
+### ✨ Added
+
+* Add select menu handler registration and interaction handling in Kythia and InteractionManager, enhancing user interaction capabilities. ([a27e84d](https://github.com/kenndeclouv/kythia-core/commit/a27e84d60f6f6077b073582f7c705eb28bc4d329))
+
+### [0.9.4-beta.3](https://github.com/kenndeclouv/kythia-core/compare/v0.9.4-beta.2...v0.9.4-beta.3) (2025-11-10)
+
+
+### 🔧 Changed
+
+* Enhance KythiaORM with dialect-specific UPSERT queries for improved database compatibility. Adjusted InteractionManager button handler logic for better flexibility in handling interactions. ([2bfafc4](https://github.com/kenndeclouv/kythia-core/commit/2bfafc47e83b06f5f72a57da162d0c6b244bfe6d))
+
 ### [0.9.4-beta.2](https://github.com/kenndeclouv/kythia-core/compare/v0.9.4-beta.1...v0.9.4-beta.2) (2025-11-10)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "kythia-core",
-    "version": "0.9.4-beta.2",
+    "version": "0.9.5-beta",
     "description": "Core library for the Kythia main Discord bot: extensible, modular, and scalable foundation for commands, components, and event management.",
     "main": "index.js",
     "scripts": {

package/src/Kythia.js

@@ -4,7 +4,7 @@
  * @file src/Kythia.js
  * @copyright © 2025 kenndeclouv
  * @assistant chaa & graa
- * @version 0.9.4-beta
+ * @version 0.9.5-beta
  *
  * @description
  * This file contains the main Bot class - acting as an orchestrator (CEO) that
@@ -187,6 +187,17 @@ class Kythia {
             this.addonManager.registerModalHandler(customIdPrefix, handler);
         }
     }
+    /**
+     * 🟦 Register Select Menu Handler
+     * Delegates to AddonManager
+     * @param {string} customIdPrefix - The prefix of the select menu customId
+     * @param {Function} handler - The handler function to execute
+     */
+    registerSelectMenuHandler(customIdPrefix, handler) {
+        if (this.addonManager) {
+            this.addonManager.registerSelectMenuHandler(customIdPrefix, handler);
+        }
+    }
 
     /**
      * 🛡️ Validate License (Stub)

package/src/database/KythiaModel.js

@@ -4,7 +4,7 @@
  * @file src/database/KythiaModel.js
  * @copyright © 2025 kenndeclouv
  * @assistant chaa & graa
- * @version 0.9.4-beta
+ * @version 0.9.5-beta
  *
  * @description
  * Caching layer for Sequelize Models, now sharding-aware. When config.db.redis.shard === true,
@@ -800,43 +800,89 @@ class KythiaModel extends Model {
         return queryPromise;
     }
 
+    
     /**
-     * 📦 Attempts to find a record based on `options.where`. If found, it returns the cached or DB record.
+     * 📦 Finds a record by the specified where condition, using cache if available; if not found, creates it and caches the result.
+     * Will update an existing cached instance with defaults (if necessary) and save any new/changed data to both DB and cache.
      */
     static async findOrCreateWithCache(options) {
         if (!options || !options.where) {
             throw new Error("findOrCreateWithCache requires a 'where' option.");
         }
 
-        const { cacheTags, noCache, ...findOrCreateOptions } = options;
+        const { where, defaults, cacheTags, noCache, ...otherOptions } = options;
+
+        if (noCache) {
+            return this.findOrCreate(options);
+        }
+
+        const normalizedWhere = this._normalizeFindOptions(where).where;
+        const cacheKey = this.getCacheKey(normalizedWhere);
+
+        const cacheResult = await this.getCachedEntry(cacheKey, otherOptions.include);
 
-        const cacheKey = this.getCacheKey(options.where);
-        const cacheResult = await this.getCachedEntry(cacheKey);
         if (cacheResult.hit && cacheResult.data) {
-            return [cacheResult.data, false];
+            const instance = cacheResult.data;
+            let needsUpdate = false;
+
+            if (defaults && typeof defaults === 'object') {
+                for (const key in defaults) {
+                    if (instance[key] === undefined || String(instance[key]) !== String(defaults[key])) {
+                        instance[key] = defaults[key];
+                        needsUpdate = true;
+                    }
+                }
+            }
+
+            if (needsUpdate) {
+                await instance.saveAndUpdateCache();
+            }
+
+            return [instance, false];
         }
+
         this.cacheStats.misses++;
         if (this.pendingQueries.has(cacheKey)) {
             return this.pendingQueries.get(cacheKey);
         }
-        const findOrCreatePromise = this.findOrCreate(findOrCreateOptions)
-            .then(([instance, created]) => {
-                if (this.isRedisConnected || !this.isShardMode) {
-                    const tags = [`${this.name}`];
-                    if (instance) {
-                        const pk = this.primaryKeyAttribute;
-                        tags.push(`${this.name}:${pk}:${instance[pk]}`);
+
+        const findPromise = this.findOne({ where, ...otherOptions })
+            .then(async (instance) => {
+                if (instance) {
+                    let needsUpdate = false;
+                    if (defaults && typeof defaults === 'object') {
+                        for (const key in defaults) {
+                            if (instance[key] === undefined || String(instance[key]) !== String(defaults[key])) {
+                                instance[key] = defaults[key];
+                                needsUpdate = true;
+                            }
+                        }
                     }
-                    this.setCacheEntry(cacheKey, instance, undefined, tags);
+
+                    if (needsUpdate) {
+                        await instance.saveAndUpdateCache();
+                    } else {
+                        const tags = [`${this.name}`, `${this.name}:${this.primaryKeyAttribute}:${instance[this.primaryKeyAttribute]}`];
+                        await this.setCacheEntry(cacheKey, instance, undefined, tags);
+                    }
+
+                    return [instance, false];
+                } else {
+                    const createData = { ...where, ...defaults };
+                    const newInstance = await this.create(createData);
+
+                    const tags = [`${this.name}`, `${this.name}:${this.primaryKeyAttribute}:${newInstance[this.primaryKeyAttribute]}`];
+                    await this.setCacheEntry(cacheKey, newInstance, undefined, tags);
+
+                    return [newInstance, true];
                 }
-                return [instance, created];
             })
             .finally(() => {
                 this.pendingQueries.delete(cacheKey);
             });
 
-        this.pendingQueries.set(cacheKey, findOrCreatePromise);
-        return findOrCreatePromise;
+        this.pendingQueries.set(cacheKey, findPromise);
+        return findPromise;
     }
 
     /**

package/src/database/KythiaORM.js

@@ -4,7 +4,7 @@
  * @file src/database/KythiaORM.js
  * @copyright © 2025 kenndeclouv
  * @assistant chaa & graa
- * @version 0.9.4-beta
+ * @version 0.9.5-beta
  *
  * @description
  * A utility for intelligent, hash-based syncing of Sequelize models.
@@ -448,7 +448,7 @@ async function KythiaORM({ kythiaInstance, sequelize, KythiaModel, logger, confi
                 }
             }
 
-            const modelNamesToSync = modelsToSync.map(m => m.model.name);
+            const modelNamesToSync = modelsToSync.map((m) => m.model.name);
 
             logger.info(`🔄 Syncing models via sequelize.sync(): ${modelNamesToSync.join(', ')}...`);
             await sequelize.sync({
@@ -459,16 +459,50 @@ async function KythiaORM({ kythiaInstance, sequelize, KythiaModel, logger, confi
 
             logger.info('💾 Updating version hashes in model_versions table...');
             for (const { model, newHash } of modelsToSync) {
-                await sequelize.query(
-                    `INSERT INTO ${versionTableName} (model_name, version_hash, updated_at) 
-                        VALUES (?, ?, CURRENT_TIMESTAMP) 
-                        ON DUPLICATE KEY UPDATE 
-                        version_hash = VALUES(version_hash), updated_at = CURRENT_TIMESTAMP`,
-                    {
-                        replacements: [model.name, newHash],
-                        type: sequelize.QueryTypes.INSERT,
-                    }
-                );
+                const dialect = sequelize.getDialect();
+                let upsertQuery;
+
+                switch (dialect) {
+                    case 'mysql':
+                    case 'mariadb':
+                        upsertQuery = `INSERT INTO ${versionTableName} (model_name, version_hash, updated_at) 
+                                     VALUES (?, ?, CURRENT_TIMESTAMP) 
+                                     ON DUPLICATE KEY UPDATE 
+                                     version_hash = VALUES(version_hash), updated_at = CURRENT_TIMESTAMP`;
+                        break;
+
+                    case 'sqlite':
+                    case 'postgres':
+                        upsertQuery = `INSERT INTO ${versionTableName} (model_name, version_hash, updated_at) 
+                                     VALUES (?, ?, CURRENT_TIMESTAMP) 
+                                     ON CONFLICT(model_name) 
+                                     DO UPDATE SET version_hash = excluded.version_hash, updated_at = CURRENT_TIMESTAMP`;
+                        break;
+
+                    case 'mssql':
+                        upsertQuery = `MERGE INTO ${versionTableName} AS T
+                                     USING (VALUES (?, ?, CURRENT_TIMESTAMP)) AS S (model_name, version_hash, updated_at)
+                                     ON (T.model_name = S.model_name)
+                                     WHEN MATCHED THEN
+                                         UPDATE SET T.version_hash = S.version_hash, T.updated_at = S.updated_at
+                                     WHEN NOT MATCHED THEN
+                                         INSERT (model_name, version_hash, updated_at) 
+                                         VALUES (S.model_name, S.version_hash, S.updated_at);`;
+                        break;
+
+                    default:
+                        logger.warn(`Dialect "${dialect}" does not have a custom UPSERT, attempting fallback to ON CONFLICT...`);
+                        upsertQuery = `INSERT INTO ${versionTableName} (model_name, version_hash, updated_at) 
+                                     VALUES (?, ?, CURRENT_TIMESTAMP) 
+                                     ON CONFLICT(model_name) 
+                                     DO UPDATE SET version_hash = excluded.version_hash, updated_at = CURRENT_TIMESTAMP`;
+                }
+
+                await sequelize.query(upsertQuery, {
+                    replacements: [model.name, newHash],
+
+                    type: sequelize.QueryTypes.INSERT,
+                });
             }
 
             logger.info('✨ Database sync completed successfully!');

package/src/database/KythiaSequelize.js

@@ -4,10 +4,10 @@
  * @file src/database/KythiaSequelize.js
  * @copyright © 2025 kenndeclouv
  * @assistant chaa & graa
- * @version 0.9.4-beta
+ * @version 0.9.5-beta
  *
  * @description
- * Main Sequelize connection factory for the application
+ * Main Sequelize connection factory for the application.
  */
 const { Sequelize } = require('sequelize');
 
@@ -21,14 +21,35 @@ const { Sequelize } = require('sequelize');
  */
 function createSequelizeInstance(config, logger) {
     const dbConfig = config.db || {};
+    if (!config.db) config.db = dbConfig;
 
-    const dialect = dbConfig.driver || process.env.DB_DRIVER;
-    const dbName = dbConfig.name || process.env.DB_NAME;
+    let driver = dbConfig.driver || process.env.DB_DRIVER;
+    let name = dbConfig.name || process.env.DB_NAME;
+
+    if (!driver || driver === '') {
+        driver = 'sqlite';
+        if (logger) logger.info('💡 DB driver not specified. Defaulting to: sqlite');
+    } else {
+        driver = driver.toLowerCase();
+    }
+
+    if (driver === 'sqlite') {
+        if (!name || name === '') {
+            name = 'kythiadata.sqlite';
+            if (logger) logger.info('💡 DB name for sqlite not specified. Defaulting to: kythiadata.sqlite');
+        }
+    }
+
+    dbConfig.driver = driver;
+    dbConfig.name = name;
+
+    const dialect = dbConfig.driver;
+    const dbName = dbConfig.name;
     const dbUser = dbConfig.user || process.env.DB_USER;
     const dbPassword = dbConfig.password || process.env.DB_PASSWORD;
     const dbHost = dbConfig.host || process.env.DB_HOST;
     const dbPort = dbConfig.port || process.env.DB_PORT;
-    const dbStorage = dbConfig.storagePath || process.env.DB_STORAGE_PATH;
+
     const dbSocket = dbConfig.socketPath || process.env.DB_SOCKET_PATH;
     const dbSsl = dbConfig.ssl || process.env.DB_SSL;
     const dbDialectOptions = dbConfig.dialectOptions || process.env.DB_DIALECT_OPTIONS;
@@ -45,12 +66,16 @@ function createSequelizeInstance(config, logger) {
             charset: 'utf8mb4',
             collate: 'utf8mb4_unicode_ci',
         },
-        timezone: dbConfig.timezone || '+00:00',
     };
 
+    if (dialect !== 'sqlite') {
+        seqConfig.timezone = dbConfig.timezone || '+00:00';
+    }
+
     switch (dialect) {
         case 'sqlite':
-            seqConfig.storage = dbStorage;
+            seqConfig.storage = dbConfig.name;
+            delete seqConfig.database;
             break;
 
         case 'mysql':

package/src/managers/AddonManager.js

@@ -4,7 +4,7 @@
  * @file src/managers/AddonManager.js
  * @copyright © 2025 kenndeclouv
  * @assistant chaa & graa
- * @version 0.9.4-beta
+ * @version 0.9.5-beta
  *
  * @description
  * Handles all addon loading, command registration, and component management.
@@ -57,6 +57,18 @@ class AddonManager {
         }
         this.buttonHandlers.set(customId, handler);
     }
+    /**
+     * 🔽 Register Select Menu Handler
+     * Registers a handler function for a specific select menu customId prefix.
+     * @param {string} customIdPrefix - The prefix of the select menu customId
+     * @param {Function} handler - The handler function to execute
+     */
+    registerSelectMenuHandler(customIdPrefix, handler) {
+        if (this.selectMenuHandlers.has(customIdPrefix)) {
+            this.logger.warn(`[REGISTRATION] Warning: Select menu handler for [${customIdPrefix}] already exists and will be overwritten.`);
+        }
+        this.selectMenuHandlers.set(customIdPrefix, handler);
+    }
 
     /**
      * 📝 Register Modal Handler

package/src/managers/EventManager.js

@@ -4,7 +4,7 @@
  * @file src/managers/EventManager.js
  * @copyright © 2025 kenndeclouv
  * @assistant chaa & graa
- * @version 0.9.4-beta
+ * @version 0.9.5-beta
  *
  * @description
  * Handles all Discord event listeners except InteractionCreate.

package/src/managers/InteractionManager.js

@@ -4,7 +4,7 @@
  * @file src/managers/InteractionManager.js
  * @copyright © 2025 kenndeclouv
  * @assistant chaa & graa
- * @version 0.9.4-beta
+ * @version 0.9.5-beta
  *
  * @description
  * Handles all Discord interaction events including slash commands, buttons, modals,
@@ -77,6 +77,8 @@ class InteractionManager {
                     await this._handleButton(interaction);
                 } else if (interaction.isModalSubmit()) {
                     await this._handleModalSubmit(interaction);
+                } else if (interaction.isAnySelectMenu()) {
+                    await this._handleSelectMenu(interaction);
                 } else if (interaction.isUserContextMenuCommand() || interaction.isMessageContextMenuCommand()) {
                     await this._handleContextMenuCommand(interaction, formatPerms);
                 }
@@ -222,11 +224,10 @@ class InteractionManager {
         }
 
         if (typeof command.execute === 'function') {
-            // Ensure logger is defined for the command execution context
             if (!interaction.logger) {
                 interaction.logger = this.logger;
             }
-            // Also inject logger into the container for legacy/compatibility
+
             if (this.container && !this.container.logger) {
                 this.container.logger = this.logger;
             }
@@ -280,8 +281,23 @@ class InteractionManager {
      * @private
      */
     async _handleButton(interaction) {
-        const handler = this.buttonHandlers.get(interaction.customId.split('_')[0]);
-        if (handler) await handler(interaction, this.container);
+        const customIdPrefix = interaction.customId.includes('|') ? interaction.customId.split('|')[0] : interaction.customId.split(':')[0];
+
+        const handler = this.buttonHandlers.get(customIdPrefix);
+
+        if (handler) {
+            if (typeof handler === 'object' && typeof handler.execute === 'function') {
+                await handler.execute(interaction, this.container);
+            } else if (typeof handler === 'function') {
+                if (handler.length === 2) {
+                    await handler(interaction, this.container);
+                } else {
+                    await handler(interaction);
+                }
+            } else {
+                this.logger.error(`Handler for button ${customIdPrefix} has an invalid format`);
+            }
+        }
     }
 
     /**
@@ -290,10 +306,52 @@ class InteractionManager {
      */
     async _handleModalSubmit(interaction) {
         const customIdPrefix = interaction.customId.includes('|') ? interaction.customId.split('|')[0] : interaction.customId.split(':')[0];
-        this.logger.info('Modal submit - customId:', interaction.customId, 'prefix:', customIdPrefix);
+
+        this.logger.info(`Modal submit - customId: ${interaction.customId}, prefix: ${customIdPrefix}`);
+
         const handler = this.modalHandlers.get(customIdPrefix);
-        this.logger.info('Modal handler found:', !!handler);
-        if (handler) await handler(interaction, this.container);
+        this.logger.info(`Modal handler found: ${!!handler}`);
+
+        if (handler) {
+            if (typeof handler === 'object' && typeof handler.execute === 'function') {
+                await handler.execute(interaction, this.container);
+            } else if (typeof handler === 'function') {
+                if (handler.length === 2) {
+                    await handler(interaction, this.container);
+                } else {
+                    await handler(interaction);
+                }
+            } else {
+                this.logger.error(`Handler untuk modal ${customIdPrefix} formatnya salah (bukan fungsi atau { execute: ... })`);
+            }
+        }
+    }
+
+    /**
+     * Handle select menu interactions
+     * @private
+     */
+    async _handleSelectMenu(interaction) {
+        const customIdPrefix = interaction.customId.includes('|') ? interaction.customId.split('|')[0] : interaction.customId.split(':')[0];
+
+        this.logger.info(`Select menu submit - customId: ${interaction.customId}, prefix: ${customIdPrefix}`);
+
+        const handler = this.selectMenuHandlers.get(customIdPrefix);
+        this.logger.info(`Select menu handler found: ${!!handler}`);
+
+        if (handler) {
+            if (typeof handler === 'object' && typeof handler.execute === 'function') {
+                await handler.execute(interaction, this.container);
+            } else if (typeof handler === 'function') {
+                if (handler.length === 2) {
+                    await handler(interaction, this.container);
+                } else {
+                    await handler(interaction);
+                }
+            } else {
+                this.logger.error(`Handler untuk select menu ${customIdPrefix} formatnya salah`);
+            }
+        }
     }
 
     /**
@@ -406,7 +464,6 @@ class InteractionManager {
             }
         }
 
-        // Ensure logger is available in the execution context
         if (!interaction.logger) {
             interaction.logger = this.logger;
         }

package/src/managers/ShutdownManager.js

@@ -4,7 +4,7 @@
  * @file src/managers/ShutdownManager.js
  * @copyright © 2025 kenndeclouv
  * @assistant chaa & graa
- * @version 0.9.4-beta
+ * @version 0.9.5-beta
  *
  * @description
  * Handles graceful shutdown procedures including interval tracking,