spacecommands 3.6.0 → 3.6.2

package/dist/CommandHandler.js

@@ -89,13 +89,16 @@ class CommandHandler {
                     }
                 });
                 for (const cmd of commandsToSync.values()) {
-                    await commands_1.default.upsert({
-                        id: cmd.names[0],
+                    const result = await commands_1.default.upsert({
+                        name: cmd.names[0],
                         category: cmd.category,
                         description: cmd.description,
                         aliases: cmd.names.slice(1),
                         is_slash: !!cmd.slash
                     });
+                    if (result && result.id) {
+                        cmd.setDbId(result.id);
+                    }
                 }
             }
             this._commands.forEach(async (command) => {

package/dist/commands/requiredrole.js

@@ -11,6 +11,22 @@ module.exports = {
     minArgs: 2,
     maxArgs: 2,
     expectedArgs: '<command> <none-or-roleid>',
+    options: [
+        {
+            name: 'command',
+            description: 'The command to set required roles for',
+            required: true,
+            type: 'STRING',
+            autocomplete: true,
+        },
+        {
+            name: 'none-or-roleid',
+            description: 'The role ID to require, or "none" to clear',
+            required: true,
+            type: 'STRING',
+            autocomplete: true,
+        }
+    ],
     cooldown: '2s',
     slash: 'both',
     autocomplete: async (interaction, instance) => {
@@ -18,17 +34,37 @@ module.exports = {
         if (focusedOption.name === 'command') {
             const commandsModel = require('../models/commands').default;
             // Fetch all commands (optimisation: maybe cache this?)
-            // For now, let's fetch all (filtered by DB query if possible, but here we just get matches)
-            // Actually Supabase 'like' or 'ilike' would be better.
-            // But our model uses exact match find or all.
-            // Let's assume we fetch all and filter in memory for list size < 100
-            const commands = await commandsModel.find();
+            let commands = [];
+            try {
+                commands = await commandsModel.find();
+            }
+            catch (e) {
+                console.warn('SpaceCommands > Failed to fetch commands for autocomplete:', e);
+                return interaction.respond([]);
+            }
             const filtered = commands.filter((cmd) => cmd.name && cmd.name.toLowerCase().startsWith(focusedOption.value.toLowerCase()));
             return interaction.respond(filtered.slice(0, 25).map((cmd) => ({
                 name: cmd.name,
                 value: cmd.id,
             })));
         }
+        else if (focusedOption.name === 'none-or-roleid') {
+            const guild = interaction.guild;
+            if (!guild)
+                return interaction.respond([]);
+            const filter = focusedOption.value.toLowerCase();
+            const roles = guild.roles.cache
+                .filter((r) => r.name.toLowerCase().includes(filter))
+                .map((r) => ({ name: r.name, value: r.id }));
+            const options = [];
+            if ('none'.includes(filter)) {
+                options.push({ name: 'None (Clear Roles)', value: 'none' });
+            }
+            // Add roles, limit total to 25
+            const remainingSlots = 25 - options.length;
+            options.push(...roles.slice(0, remainingSlots));
+            return interaction.respond(options);
+        }
     },
     callback: async (options) => {
         const { channel, args, instance } = options;

package/dist/models/commands.js

@@ -10,7 +10,10 @@ const commands = {
             return [];
         let query = client.from(exports.TABLE_NAME).select('*');
         if (filter.name) {
-            query = query.eq('id', filter.name);
+            query = query.eq('name', filter.name);
+        }
+        if (filter.id) {
+            query = query.eq('id', filter.id);
         }
         const { data, error } = await query;
         if (error) {
@@ -23,14 +26,16 @@ const commands = {
         const client = (0, supabase_1.getSupabaseClient)();
         if (!client)
             return null;
-        const { error } = await client
+        const { data, error } = await client
             .from(exports.TABLE_NAME)
-            .upsert(commandData, { onConflict: 'id' });
+            .upsert(commandData, { onConflict: 'name' })
+            .select()
+            .single();
         if (error) {
             console.error('SpaceCommands > Error upserting command:', error);
             return null;
         }
-        return true;
+        return data;
     },
     delete: async (id) => {
         const client = (0, supabase_1.getSupabaseClient)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacecommands",
-  "version": "3.6.0",
+  "version": "3.6.2",
   "main": "dist/index.js",
   "types": "./typings.d.ts",
   "typings": "./typings.d.ts",