spacecommands 3.5.7 → 3.5.8

package/README.md

@@ -1,3 +1,5 @@
+Please consult RULES.md before making any changes.
+
 # SpaceCommands
 
 SpaceCommands is a modern, feature-rich Discord.js command handler library. Built on Discord.js v14, it provides an easy-to-use framework for creating Discord bots with slash commands, permissions, cooldowns, and more.

package/dist/command-checks/has-entitlement.js

@@ -20,7 +20,7 @@ module.exports = async (guild, command, instance, member, user, reply) => {
     }
     // Check if user has required entitlements
     if (requiredEntitlements.length > 0) {
-        const { hasEntitlement } = await entitlementHandler.hasAnyEntitlement(user.id, requiredEntitlements);
+        const { hasEntitlement } = await entitlementHandler.hasAnyEntitlement(user.id, requiredEntitlements, guild?.id);
         if (!hasEntitlement) {
             reply(instance.messageHandler.get(guild, 'MISSING_ENTITLEMENT') ||
                 'You need a premium subscription to use this command.').then((message) => {
@@ -40,7 +40,13 @@ module.exports = async (guild, command, instance, member, user, reply) => {
     // If premiumOnly is set, check for any active entitlement
     if (premiumOnly) {
         const allEntitlements = await entitlementHandler.getUserEntitlements(user.id);
-        if (allEntitlements.length === 0) {
+        let hasPremium = allEntitlements.length > 0;
+        // Check guild overrides if no user entitlement found
+        if (!hasPremium && guild) {
+            const overrides = await entitlementHandler.getGuildOverrides(guild.id);
+            hasPremium = overrides.length > 0;
+        }
+        if (!hasPremium) {
             reply(instance.messageHandler.get(guild, 'PREMIUM_ONLY') ||
                 'This command is only available to premium subscribers.').then((message) => {
                 if (!message) {

package/dist/handlers/EntitlementHandler.js

@@ -1,5 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+const premium_overrides_1 = __importDefault(require("../models/premium-overrides"));
 /**
  * Handler for Discord premium features and entitlements
  * Supports Discord's monetization system with SKUs and subscriptions
@@ -8,7 +13,9 @@ class EntitlementHandler {
     _client;
     _instance;
     _skus = new Map();
+    _hierarchy = new Map(); // childSku -> parentSkus
     _entitlementCache = new Map();
+    _overrideCache = new Map(); // guildId -> skuIds
     _cacheTimeout = 5 * 60 * 1000; // 5 minutes
     constructor(instance) {
         this._instance = instance;
@@ -38,6 +45,26 @@ class EntitlementHandler {
             }
         });
     }
+    /**
+     * Register a SKU hierarchy
+     * @param childSku The SKU that is included in the parent SKUs
+     * @param parentSkus The SKUs that include the child SKU
+     */
+    registerHierarchy(childSku, parentSkus) {
+        const existing = this._hierarchy.get(childSku) || [];
+        this._hierarchy.set(childSku, [...new Set([...existing, ...parentSkus])]);
+        if (this._instance.debug) {
+            console.log(`SpaceCommands > Registered hierarchy: ${parentSkus.join(', ')} includes ${childSku}`);
+        }
+        return this;
+    }
+    /**
+     * Get all SKUs that satisfy the required SKU (including itself and its parents)
+     */
+    getSatisfyingSkus(skuId) {
+        const parents = this._hierarchy.get(skuId) || [];
+        return [skuId, ...parents];
+    }
     /**
      * Register a SKU for premium features
      */
@@ -60,9 +87,21 @@ class EntitlementHandler {
     /**
      * Check if a user has a specific entitlement
      */
-    async hasEntitlement(userId, skuId) {
+    async hasEntitlement(userId, skuId, guildId) {
+        const validSkuIds = this.getSatisfyingSkus(skuId);
+        // First, check for guild overrides if guildId is provided
+        if (guildId) {
+            for (const validSku of validSkuIds) {
+                if (await this.hasGuildOverride(guildId, validSku)) {
+                    return {
+                        hasEntitlement: true,
+                        isOverride: true,
+                    };
+                }
+            }
+        }
         const entitlements = await this.getUserEntitlements(userId);
-        const entitlement = entitlements.find((e) => e.skuId === skuId);
+        const entitlement = entitlements.find((e) => validSkuIds.includes(e.skuId));
         return {
             hasEntitlement: !!entitlement,
             entitlement,
@@ -71,9 +110,26 @@ class EntitlementHandler {
     /**
      * Check if a user has any of the specified entitlements
      */
-    async hasAnyEntitlement(userId, skuIds) {
+    async hasAnyEntitlement(userId, skuIds, guildId) {
+        // Expand checks to include hierarchy
+        const allValidSkuIds = new Set();
+        for (const skuId of skuIds) {
+            this.getSatisfyingSkus(skuId).forEach(id => allValidSkuIds.add(id));
+        }
+        const validSkuList = Array.from(allValidSkuIds);
+        // First, check for guild overrides if guildId is provided
+        if (guildId) {
+            for (const skuId of validSkuList) {
+                if (await this.hasGuildOverride(guildId, skuId)) {
+                    return {
+                        hasEntitlement: true,
+                        isOverride: true,
+                    };
+                }
+            }
+        }
         const entitlements = await this.getUserEntitlements(userId);
-        const entitlement = entitlements.find((e) => skuIds.includes(e.skuId));
+        const entitlement = entitlements.find((e) => validSkuList.includes(e.skuId));
         return {
             hasEntitlement: !!entitlement,
             entitlement,
@@ -82,10 +138,54 @@ class EntitlementHandler {
     /**
      * Check if a user has all of the specified entitlements
      */
-    async hasAllEntitlements(userId, skuIds) {
-        const entitlements = await this.getUserEntitlements(userId);
-        const entitlementSkus = entitlements.map((e) => e.skuId);
-        return skuIds.every((skuId) => entitlementSkus.includes(skuId));
+    async hasAllEntitlements(userId, skuIds, guildId) {
+        // Optimisation: Get user entitlements once
+        const userEntitlements = await this.getUserEntitlements(userId);
+        const userSkuIds = userEntitlements.map((e) => e.skuId);
+        for (const skuId of skuIds) {
+            const validSkuIds = this.getSatisfyingSkus(skuId);
+            // Check if user has ANY of the satisfying SKUs for this requirement
+            let hasRequirement = userSkuIds.some(id => validSkuIds.includes(id));
+            if (!hasRequirement && guildId) {
+                // Check overrides for ANY satisfying SKU
+                for (const validSku of validSkuIds) {
+                    if (await this.hasGuildOverride(guildId, validSku)) {
+                        hasRequirement = true;
+                        break;
+                    }
+                }
+            }
+            if (!hasRequirement) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if a guild has an override for a specific SKU
+     */
+    async hasGuildOverride(guildId, skuId, useCache = true) {
+        if (!this._instance.isDBConnected()) {
+            return false;
+        }
+        if (useCache && this._overrideCache.has(guildId)) {
+            const overrides = this._overrideCache.get(guildId);
+            return overrides.includes(skuId);
+        }
+        try {
+            const result = await premium_overrides_1.default.findOne(guildId);
+            const skuIds = result?.skuId ? [result.skuId] : [];
+            this._overrideCache.set(guildId, skuIds);
+            // Clear cache after timeout
+            setTimeout(() => {
+                this._overrideCache.delete(guildId);
+            }, this._cacheTimeout);
+            return skuIds.includes(skuId);
+        }
+        catch (error) {
+            console.error(`SpaceCommands > Error checking guild override for ${guildId}:`, error);
+            return false;
+        }
     }
     /**
      * Get all active entitlements for a user
@@ -128,6 +228,32 @@ class EntitlementHandler {
     getSKU(skuId) {
         return this._skus.get(skuId);
     }
+    /**
+     * Get all active overrides for a guild
+     */
+    async getGuildOverrides(guildId, useCache = true) {
+        if (!this._instance.isDBConnected()) {
+            return [];
+        }
+        if (useCache && this._overrideCache.has(guildId)) {
+            return this._overrideCache.get(guildId);
+        }
+        try {
+            const result = await premium_overrides_1.default.findOne(guildId);
+            const overrideSku = result?.skuId;
+            const overrides = overrideSku ? [overrideSku] : [];
+            this._overrideCache.set(guildId, overrides);
+            // Clear cache after timeout
+            setTimeout(() => {
+                this._overrideCache.delete(guildId);
+            }, this._cacheTimeout);
+            return overrides;
+        }
+        catch (error) {
+            console.error(`SpaceCommands > Error fetching guild overrides for ${guildId}:`, error);
+            return [];
+        }
+    }
     /**
      * Clear the entitlement cache for a specific user
      */
@@ -139,6 +265,17 @@ class EntitlementHandler {
             this._entitlementCache.clear();
         }
     }
+    /**
+     * Clear the override cache for a specific guild
+     */
+    clearOverrideCache(guildId) {
+        if (guildId) {
+            this._overrideCache.delete(guildId);
+        }
+        else {
+            this._overrideCache.clear();
+        }
+    }
     /**
      * Set the cache timeout duration (in milliseconds)
      */
@@ -151,7 +288,8 @@ class EntitlementHandler {
      */
     async checkAccess(userOrMember, skuId) {
         const userId = userOrMember.id;
-        return this.hasEntitlement(userId, skuId);
+        const guildId = userOrMember instanceof discord_js_1.GuildMember ? userOrMember.guild.id : undefined;
+        return this.hasEntitlement(userId, skuId, guildId);
     }
     /**
      * Consume a one-time purchase entitlement

package/dist/models/premium-overrides.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const supabase_1 = require("../supabase");
+const TABLE_NAME = 'spacecommands_premium_overrides';
+exports.default = {
+    /**
+     * Find overrides for a specific guild
+     */
+    async findOne(guildId) {
+        const client = (0, supabase_1.getSupabaseClient)();
+        if (!client)
+            return null;
+        const { data, error } = await client
+            .from(TABLE_NAME)
+            .select('sku_id')
+            .eq('guild_id', guildId)
+            .single();
+        if (error) {
+            if (error.code === 'PGRST116')
+                return null;
+            console.error('SpaceCommands > Error finding premium override:', error);
+            return null;
+        }
+        return {
+            guildId,
+            skuId: data.sku_id,
+        };
+    },
+    /**
+     * Set overrides for a guild
+     */
+    async setOverride(guildId, skuId) {
+        const client = (0, supabase_1.getSupabaseClient)();
+        if (!client)
+            return null;
+        const { data, error } = await client
+            .from(TABLE_NAME)
+            .upsert({ guild_id: guildId, sku_id: skuId }, { onConflict: 'guild_id' })
+            .select()
+            .single();
+        if (error) {
+            console.error('SpaceCommands > Error setting premium override:', error);
+            return null;
+        }
+        return {
+            guildId: data.guild_id,
+            skuId: data.sku_id,
+        };
+    },
+    /**
+     * Remove overrides for a guild
+     */
+    async removeOverrides(guildId) {
+        const client = (0, supabase_1.getSupabaseClient)();
+        if (!client)
+            return false;
+        const { error } = await client
+            .from(TABLE_NAME)
+            .delete()
+            .eq('guild_id', guildId);
+        if (error) {
+            console.error('SpaceCommands > Error removing premium override:', error);
+            return false;
+        }
+        return true;
+    }
+};

package/dist/models/required-roles.js

@@ -56,7 +56,25 @@ exports.default = {
             return null;
         const guildId = filter.guildId;
         const command = filter.command || update.command || update.$set?.command;
-        const requiredRoles = update.requiredRoles || update.$set?.requiredRoles;
+        let requiredRoles = update.requiredRoles || update.$set?.requiredRoles;
+        // Handle $addToSet (used by requiredrole command)
+        if (update.$addToSet && update.$addToSet.requiredRoles) {
+            const roleToAdd = update.$addToSet.requiredRoles;
+            // Fetch existing roles first
+            const { data: existing } = await client
+                .from(TABLE_NAME)
+                .select('required_roles')
+                .eq('guild_id', guildId)
+                .eq('command', command)
+                .single();
+            const currentRoles = existing ? (existing.required_roles || []) : [];
+            // Ensure it's an array
+            const rolesArray = Array.isArray(currentRoles) ? currentRoles : [];
+            if (!rolesArray.includes(roleToAdd)) {
+                rolesArray.push(roleToAdd);
+            }
+            requiredRoles = rolesArray;
+        }
         const { data, error } = await client
             .from(TABLE_NAME)
             .upsert({ guild_id: guildId, command, required_roles: requiredRoles }, { onConflict: 'guild_id,command' })

package/package.json

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