strapi-plugin-magic-mark 3.0.0 → 3.0.2

package/dist/server/index.js

@@ -228,6 +228,17 @@ const bookmarkController = ({ strapi }) => ({
         return ctx.throw(400, "Path is required");
       }
       const userId = user.documentId || String(user.id);
+      const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+      const limitCheck = await licenseGuard.canCreateBookmark(userId);
+      if (!limitCheck.canCreate) {
+        return ctx.throw(403, {
+          error: "BOOKMARK_LIMIT_REACHED",
+          message: limitCheck.message || `Bookmark limit reached (${limitCheck.current}/${limitCheck.max}). Upgrade to Premium or Advanced to create more bookmarks.`,
+          current: limitCheck.current,
+          max: limitCheck.max,
+          upgradeUrl: "/admin/settings/magic-mark/upgrade"
+        });
+      }
       const service = strapi.plugin("magic-mark").service("bookmarks");
       const bookmark = await service.create(name, path2, query, emoji, description, userId, sharedWithRoles, sharedWithUsers, isPublic);
       ctx.body = {
@@ -620,6 +631,27 @@ const license = ({ strapi }) => ({
       strapi.log.error("Error storing license key:", error);
       return ctx.badRequest("Error validating license key");
     }
+  },
+  /**
+   * Get license limits and feature flags for current user
+   */
+  async getLimits(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized("User not authenticated");
+      }
+      const userId = user.documentId || String(user.id);
+      const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+      const limits = await licenseGuard.getLicenseLimits(userId);
+      return ctx.send({
+        success: true,
+        data: limits
+      });
+    } catch (error) {
+      strapi.log.error("Error getting license limits:", error);
+      return ctx.badRequest("Error getting license limits");
+    }
   }
 });
 const controllers = {
@@ -741,6 +773,14 @@ const admin = {
       config: {
         policies: []
       }
+    },
+    {
+      method: "GET",
+      path: "/license/limits",
+      handler: "license.getLimits",
+      config: {
+        policies: []
+      }
     }
   ]
 };
@@ -1239,19 +1279,23 @@ const licenseGuardService = ({ strapi }) => ({
     }
   },
   /**
-   * Get online statistics
+   * Get current license data from store (fetches fresh from server)
+   * This is the correct way to get license data with all feature flags
    */
-  async getOnlineStats() {
+  async getCurrentLicense() {
     try {
-      const licenseServerUrl = this.getLicenseServerUrl();
-      const response = await fetch(`${licenseServerUrl}/api/licenses/stats/online`);
-      const data = await response.json();
-      if (data.success) {
-        return data.data;
+      const pluginStore = strapi.store({
+        type: "plugin",
+        name: "magic-mark"
+      });
+      const licenseKey = await pluginStore.get({ key: "licenseKey" });
+      if (!licenseKey) {
+        return null;
       }
-      return null;
+      const license2 = await this.getLicenseByKey(licenseKey);
+      return license2;
     } catch (error) {
-      strapi.log.error("[ERROR] Error fetching online stats:", error);
+      strapi.log.error("[LICENSE] Error loading current license:", error);
       return null;
     }
   },
@@ -1360,6 +1404,165 @@ const licenseGuardService = ({ strapi }) => ({
       return false;
     }
   },
+  /**
+   * Get bookmark limit based on license tier
+   * @returns Bookmark limit: 10 (free), 50 (premium), -1 (advanced/unlimited)
+   */
+  async getBookmarkLimit() {
+    try {
+      const licenseGuard = strapi.licenseGuard;
+      const licenseData = licenseGuard?.data;
+      if (licenseData?.featureAdvanced) {
+        return -1;
+      }
+      if (licenseData?.featurePremium) {
+        return 50;
+      }
+      return 10;
+    } catch (error) {
+      strapi.log.debug("[LICENSE] Error getting bookmark limit, using free tier");
+      return 10;
+    }
+  },
+  /**
+   * Check if user can create more bookmarks
+   * @param userId - User's documentId
+   * @returns Object with canCreate boolean and current/max counts
+   */
+  async canCreateBookmark(userId) {
+    try {
+      const limit = await this.getBookmarkLimit();
+      if (limit === -1) {
+        return { canCreate: true, current: 0, max: -1 };
+      }
+      const BOOKMARK_UID2 = "plugin::magic-mark.bookmark";
+      const bookmarks = await strapi.documents(BOOKMARK_UID2).findMany({
+        filters: { creatorId: userId }
+      });
+      const currentCount = bookmarks?.length || 0;
+      if (currentCount >= limit) {
+        return {
+          canCreate: false,
+          current: currentCount,
+          max: limit,
+          message: `Bookmark limit reached (${currentCount}/${limit}). Upgrade to create more bookmarks.`
+        };
+      }
+      return { canCreate: true, current: currentCount, max: limit };
+    } catch (error) {
+      strapi.log.error("[LICENSE] Error checking bookmark limit:", error);
+      return { canCreate: true, current: 0, max: 10 };
+    }
+  },
+  /**
+   * Get current license limits and feature flags
+   * @param userId - User's documentId for bookmark count
+   * @returns License limits object
+   */
+  async getLicenseLimits(userId) {
+    try {
+      const license2 = await this.getCurrentLicense();
+      strapi.log.info("[LICENSE] getLicenseLimits - license exists:", !!license2);
+      if (license2) {
+        strapi.log.info("[LICENSE] getLicenseLimits - featurePremium:", license2.featurePremium);
+        strapi.log.info("[LICENSE] getLicenseLimits - featureAdvanced:", license2.featureAdvanced);
+      }
+      let tier = "free";
+      if (license2?.featureEnterprise === true) tier = "enterprise";
+      else if (license2?.featureAdvanced === true) tier = "advanced";
+      else if (license2?.featurePremium === true) tier = "premium";
+      const isPremium = tier === "premium" || tier === "advanced" || tier === "enterprise";
+      const isAdvanced = tier === "advanced" || tier === "enterprise";
+      strapi.log.info("[LICENSE] getLicenseLimits - detected tier:", tier);
+      const bookmarkCheck = await this.canCreateBookmark(userId);
+      return {
+        maxBookmarks: bookmarkCheck.max,
+        currentBookmarks: bookmarkCheck.current,
+        canCreate: bookmarkCheck.canCreate,
+        tier,
+        features: {
+          queryHistory: isPremium || isAdvanced,
+          export: isPremium || isAdvanced,
+          analytics: isAdvanced,
+          bulkOperations: isAdvanced,
+          customIntegrations: isAdvanced
+        }
+      };
+    } catch (error) {
+      strapi.log.error("[LICENSE] Error getting license limits:", error);
+      return {
+        maxBookmarks: 10,
+        currentBookmarks: 0,
+        canCreate: true,
+        tier: "free",
+        features: {
+          queryHistory: false,
+          export: false,
+          analytics: false,
+          bulkOperations: false,
+          customIntegrations: false
+        }
+      };
+    }
+  },
+  /**
+   * Check if a specific feature is available based on license
+   * @param feature - Feature key to check
+   * @returns Boolean indicating if feature is available
+   */
+  hasFeature(feature) {
+    try {
+      const licenseGuard = strapi.licenseGuard;
+      const licenseData = licenseGuard?.data;
+      const isPremium = licenseData?.featurePremium || false;
+      const isAdvanced = licenseData?.featureAdvanced || false;
+      const featureRequirements = {
+        // Free tier
+        basicBookmarks: "free",
+        basicFilters: "free",
+        // Premium tier
+        extendedBookmarks: "premium",
+        queryHistory: "premium",
+        exportBookmarks: "premium",
+        sharedBookmarks: "premium",
+        // Advanced tier
+        unlimitedBookmarks: "advanced",
+        advancedFilters: "advanced",
+        subGroups: "advanced",
+        bulkOperations: "advanced",
+        analytics: "advanced",
+        customIntegrations: "advanced"
+      };
+      const requiredTier = featureRequirements[feature] || "free";
+      let currentTierLevel = 0;
+      if (isAdvanced) currentTierLevel = 2;
+      else if (isPremium) currentTierLevel = 1;
+      const tierLevels = {
+        free: 0,
+        premium: 1,
+        advanced: 2
+      };
+      return currentTierLevel >= tierLevels[requiredTier];
+    } catch (error) {
+      strapi.log.debug("[LICENSE] Error checking feature:", feature);
+      return false;
+    }
+  },
+  /**
+   * Get current tier name
+   * @returns 'free' | 'premium' | 'advanced'
+   */
+  getCurrentTier() {
+    try {
+      const licenseGuard = strapi.licenseGuard;
+      const licenseData = licenseGuard?.data;
+      if (licenseData?.featureAdvanced) return "advanced";
+      if (licenseData?.featurePremium) return "premium";
+      return "free";
+    } catch (error) {
+      return "free";
+    }
+  },
   /**
    * Cleanup on plugin destroy
    */

package/dist/server/index.mjs

@@ -224,6 +224,17 @@ const bookmarkController = ({ strapi }) => ({
         return ctx.throw(400, "Path is required");
       }
       const userId = user.documentId || String(user.id);
+      const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+      const limitCheck = await licenseGuard.canCreateBookmark(userId);
+      if (!limitCheck.canCreate) {
+        return ctx.throw(403, {
+          error: "BOOKMARK_LIMIT_REACHED",
+          message: limitCheck.message || `Bookmark limit reached (${limitCheck.current}/${limitCheck.max}). Upgrade to Premium or Advanced to create more bookmarks.`,
+          current: limitCheck.current,
+          max: limitCheck.max,
+          upgradeUrl: "/admin/settings/magic-mark/upgrade"
+        });
+      }
       const service = strapi.plugin("magic-mark").service("bookmarks");
       const bookmark = await service.create(name, path, query, emoji, description, userId, sharedWithRoles, sharedWithUsers, isPublic);
       ctx.body = {
@@ -616,6 +627,27 @@ const license = ({ strapi }) => ({
       strapi.log.error("Error storing license key:", error);
       return ctx.badRequest("Error validating license key");
     }
+  },
+  /**
+   * Get license limits and feature flags for current user
+   */
+  async getLimits(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized("User not authenticated");
+      }
+      const userId = user.documentId || String(user.id);
+      const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+      const limits = await licenseGuard.getLicenseLimits(userId);
+      return ctx.send({
+        success: true,
+        data: limits
+      });
+    } catch (error) {
+      strapi.log.error("Error getting license limits:", error);
+      return ctx.badRequest("Error getting license limits");
+    }
   }
 });
 const controllers = {
@@ -737,6 +769,14 @@ const admin = {
       config: {
         policies: []
       }
+    },
+    {
+      method: "GET",
+      path: "/license/limits",
+      handler: "license.getLimits",
+      config: {
+        policies: []
+      }
     }
   ]
 };
@@ -1235,19 +1275,23 @@ const licenseGuardService = ({ strapi }) => ({
     }
   },
   /**
-   * Get online statistics
+   * Get current license data from store (fetches fresh from server)
+   * This is the correct way to get license data with all feature flags
    */
-  async getOnlineStats() {
+  async getCurrentLicense() {
     try {
-      const licenseServerUrl = this.getLicenseServerUrl();
-      const response = await fetch(`${licenseServerUrl}/api/licenses/stats/online`);
-      const data = await response.json();
-      if (data.success) {
-        return data.data;
+      const pluginStore = strapi.store({
+        type: "plugin",
+        name: "magic-mark"
+      });
+      const licenseKey = await pluginStore.get({ key: "licenseKey" });
+      if (!licenseKey) {
+        return null;
       }
-      return null;
+      const license2 = await this.getLicenseByKey(licenseKey);
+      return license2;
     } catch (error) {
-      strapi.log.error("[ERROR] Error fetching online stats:", error);
+      strapi.log.error("[LICENSE] Error loading current license:", error);
       return null;
     }
   },
@@ -1356,6 +1400,165 @@ const licenseGuardService = ({ strapi }) => ({
       return false;
     }
   },
+  /**
+   * Get bookmark limit based on license tier
+   * @returns Bookmark limit: 10 (free), 50 (premium), -1 (advanced/unlimited)
+   */
+  async getBookmarkLimit() {
+    try {
+      const licenseGuard = strapi.licenseGuard;
+      const licenseData = licenseGuard?.data;
+      if (licenseData?.featureAdvanced) {
+        return -1;
+      }
+      if (licenseData?.featurePremium) {
+        return 50;
+      }
+      return 10;
+    } catch (error) {
+      strapi.log.debug("[LICENSE] Error getting bookmark limit, using free tier");
+      return 10;
+    }
+  },
+  /**
+   * Check if user can create more bookmarks
+   * @param userId - User's documentId
+   * @returns Object with canCreate boolean and current/max counts
+   */
+  async canCreateBookmark(userId) {
+    try {
+      const limit = await this.getBookmarkLimit();
+      if (limit === -1) {
+        return { canCreate: true, current: 0, max: -1 };
+      }
+      const BOOKMARK_UID2 = "plugin::magic-mark.bookmark";
+      const bookmarks = await strapi.documents(BOOKMARK_UID2).findMany({
+        filters: { creatorId: userId }
+      });
+      const currentCount = bookmarks?.length || 0;
+      if (currentCount >= limit) {
+        return {
+          canCreate: false,
+          current: currentCount,
+          max: limit,
+          message: `Bookmark limit reached (${currentCount}/${limit}). Upgrade to create more bookmarks.`
+        };
+      }
+      return { canCreate: true, current: currentCount, max: limit };
+    } catch (error) {
+      strapi.log.error("[LICENSE] Error checking bookmark limit:", error);
+      return { canCreate: true, current: 0, max: 10 };
+    }
+  },
+  /**
+   * Get current license limits and feature flags
+   * @param userId - User's documentId for bookmark count
+   * @returns License limits object
+   */
+  async getLicenseLimits(userId) {
+    try {
+      const license2 = await this.getCurrentLicense();
+      strapi.log.info("[LICENSE] getLicenseLimits - license exists:", !!license2);
+      if (license2) {
+        strapi.log.info("[LICENSE] getLicenseLimits - featurePremium:", license2.featurePremium);
+        strapi.log.info("[LICENSE] getLicenseLimits - featureAdvanced:", license2.featureAdvanced);
+      }
+      let tier = "free";
+      if (license2?.featureEnterprise === true) tier = "enterprise";
+      else if (license2?.featureAdvanced === true) tier = "advanced";
+      else if (license2?.featurePremium === true) tier = "premium";
+      const isPremium = tier === "premium" || tier === "advanced" || tier === "enterprise";
+      const isAdvanced = tier === "advanced" || tier === "enterprise";
+      strapi.log.info("[LICENSE] getLicenseLimits - detected tier:", tier);
+      const bookmarkCheck = await this.canCreateBookmark(userId);
+      return {
+        maxBookmarks: bookmarkCheck.max,
+        currentBookmarks: bookmarkCheck.current,
+        canCreate: bookmarkCheck.canCreate,
+        tier,
+        features: {
+          queryHistory: isPremium || isAdvanced,
+          export: isPremium || isAdvanced,
+          analytics: isAdvanced,
+          bulkOperations: isAdvanced,
+          customIntegrations: isAdvanced
+        }
+      };
+    } catch (error) {
+      strapi.log.error("[LICENSE] Error getting license limits:", error);
+      return {
+        maxBookmarks: 10,
+        currentBookmarks: 0,
+        canCreate: true,
+        tier: "free",
+        features: {
+          queryHistory: false,
+          export: false,
+          analytics: false,
+          bulkOperations: false,
+          customIntegrations: false
+        }
+      };
+    }
+  },
+  /**
+   * Check if a specific feature is available based on license
+   * @param feature - Feature key to check
+   * @returns Boolean indicating if feature is available
+   */
+  hasFeature(feature) {
+    try {
+      const licenseGuard = strapi.licenseGuard;
+      const licenseData = licenseGuard?.data;
+      const isPremium = licenseData?.featurePremium || false;
+      const isAdvanced = licenseData?.featureAdvanced || false;
+      const featureRequirements = {
+        // Free tier
+        basicBookmarks: "free",
+        basicFilters: "free",
+        // Premium tier
+        extendedBookmarks: "premium",
+        queryHistory: "premium",
+        exportBookmarks: "premium",
+        sharedBookmarks: "premium",
+        // Advanced tier
+        unlimitedBookmarks: "advanced",
+        advancedFilters: "advanced",
+        subGroups: "advanced",
+        bulkOperations: "advanced",
+        analytics: "advanced",
+        customIntegrations: "advanced"
+      };
+      const requiredTier = featureRequirements[feature] || "free";
+      let currentTierLevel = 0;
+      if (isAdvanced) currentTierLevel = 2;
+      else if (isPremium) currentTierLevel = 1;
+      const tierLevels = {
+        free: 0,
+        premium: 1,
+        advanced: 2
+      };
+      return currentTierLevel >= tierLevels[requiredTier];
+    } catch (error) {
+      strapi.log.debug("[LICENSE] Error checking feature:", feature);
+      return false;
+    }
+  },
+  /**
+   * Get current tier name
+   * @returns 'free' | 'premium' | 'advanced'
+   */
+  getCurrentTier() {
+    try {
+      const licenseGuard = strapi.licenseGuard;
+      const licenseData = licenseGuard?.data;
+      if (licenseData?.featureAdvanced) return "advanced";
+      if (licenseData?.featurePremium) return "premium";
+      return "free";
+    } catch (error) {
+      return "free";
+    }
+  },
   /**
    * Cleanup on plugin destroy
    */

package/dist/server/src/controllers/index.d.ts

@@ -15,6 +15,7 @@ declare const _default: {
         createAndActivate(ctx: any): Promise<any>;
         ping(ctx: any): Promise<any>;
         storeKey(ctx: any): Promise<any>;
+        getLimits(ctx: any): Promise<any>;
     };
 };
 export default _default;

package/dist/server/src/controllers/license.d.ts

@@ -23,5 +23,9 @@ declare const _default: ({ strapi }: any) => {
      * Store and validate an existing license key
      */
     storeKey(ctx: any): Promise<any>;
+    /**
+     * Get license limits and feature flags for current user
+     */
+    getLimits(ctx: any): Promise<any>;
 };
 export default _default;

package/dist/server/src/index.d.ts

@@ -30,6 +30,7 @@ declare const _default: {
             createAndActivate(ctx: any): Promise<any>;
             ping(ctx: any): Promise<any>;
             storeKey(ctx: any): Promise<any>;
+            getLimits(ctx: any): Promise<any>;
         };
     };
     routes: {
@@ -85,10 +86,32 @@ declare const _default: {
             verifyLicense(licenseKey: string, allowGracePeriod?: boolean): Promise<import("./services/license-guard").VerificationResult>;
             pingLicense(licenseKey: string): Promise<any>;
             getLicenseByKey(licenseKey: string): Promise<import("./services/license-guard").LicenseData>;
-            getOnlineStats(): Promise<any>;
+            getCurrentLicense(): Promise<import("./services/license-guard").LicenseData>;
             startPinging(licenseKey: string, intervalMinutes?: number): NodeJS.Timeout;
             initialize(): Promise<import("./services/license-guard").LicenseStatus>;
             storeLicenseKey(licenseKey: string): Promise<boolean>;
+            getBookmarkLimit(): Promise<number>;
+            canCreateBookmark(userId: string): Promise<{
+                canCreate: boolean;
+                current: number;
+                max: number;
+                message?: string;
+            }>;
+            getLicenseLimits(userId: string): Promise<{
+                maxBookmarks: number;
+                currentBookmarks: number;
+                canCreate: boolean;
+                tier: string;
+                features: {
+                    queryHistory: boolean;
+                    export: boolean;
+                    analytics: boolean;
+                    bulkOperations: boolean;
+                    customIntegrations: boolean;
+                };
+            }>;
+            hasFeature(feature: string): boolean;
+            getCurrentTier(): "free" | "premium" | "advanced";
             cleanup(): void;
         };
     };

package/dist/server/src/services/index.d.ts

@@ -35,10 +35,32 @@ declare const _default: {
         verifyLicense(licenseKey: string, allowGracePeriod?: boolean): Promise<import("./license-guard").VerificationResult>;
         pingLicense(licenseKey: string): Promise<any>;
         getLicenseByKey(licenseKey: string): Promise<import("./license-guard").LicenseData>;
-        getOnlineStats(): Promise<any>;
+        getCurrentLicense(): Promise<import("./license-guard").LicenseData>;
         startPinging(licenseKey: string, intervalMinutes?: number): NodeJS.Timeout;
         initialize(): Promise<import("./license-guard").LicenseStatus>;
         storeLicenseKey(licenseKey: string): Promise<boolean>;
+        getBookmarkLimit(): Promise<number>;
+        canCreateBookmark(userId: string): Promise<{
+            canCreate: boolean;
+            current: number;
+            max: number;
+            message?: string;
+        }>;
+        getLicenseLimits(userId: string): Promise<{
+            maxBookmarks: number;
+            currentBookmarks: number;
+            canCreate: boolean;
+            tier: string;
+            features: {
+                queryHistory: boolean;
+                export: boolean;
+                analytics: boolean;
+                bulkOperations: boolean;
+                customIntegrations: boolean;
+            };
+        }>;
+        hasFeature(feature: string): boolean;
+        getCurrentTier(): "free" | "premium" | "advanced";
         cleanup(): void;
     };
 };

package/dist/server/src/services/license-guard.d.ts

@@ -79,9 +79,10 @@ declare const licenseGuardService: ({ strapi }: {
      */
     getLicenseByKey(licenseKey: string): Promise<LicenseData | null>;
     /**
-     * Get online statistics
+     * Get current license data from store (fetches fresh from server)
+     * This is the correct way to get license data with all feature flags
      */
-    getOnlineStats(): Promise<any>;
+    getCurrentLicense(): Promise<LicenseData | null>;
     /**
      * Start periodic pinging for a license
      */
@@ -95,6 +96,51 @@ declare const licenseGuardService: ({ strapi }: {
      * Store license key after creation
      */
     storeLicenseKey(licenseKey: string): Promise<boolean>;
+    /**
+     * Get bookmark limit based on license tier
+     * @returns Bookmark limit: 10 (free), 50 (premium), -1 (advanced/unlimited)
+     */
+    getBookmarkLimit(): Promise<number>;
+    /**
+     * Check if user can create more bookmarks
+     * @param userId - User's documentId
+     * @returns Object with canCreate boolean and current/max counts
+     */
+    canCreateBookmark(userId: string): Promise<{
+        canCreate: boolean;
+        current: number;
+        max: number;
+        message?: string;
+    }>;
+    /**
+     * Get current license limits and feature flags
+     * @param userId - User's documentId for bookmark count
+     * @returns License limits object
+     */
+    getLicenseLimits(userId: string): Promise<{
+        maxBookmarks: number;
+        currentBookmarks: number;
+        canCreate: boolean;
+        tier: string;
+        features: {
+            queryHistory: boolean;
+            export: boolean;
+            analytics: boolean;
+            bulkOperations: boolean;
+            customIntegrations: boolean;
+        };
+    }>;
+    /**
+     * Check if a specific feature is available based on license
+     * @param feature - Feature key to check
+     * @returns Boolean indicating if feature is available
+     */
+    hasFeature(feature: string): boolean;
+    /**
+     * Get current tier name
+     * @returns 'free' | 'premium' | 'advanced'
+     */
+    getCurrentTier(): 'free' | 'premium' | 'advanced';
     /**
      * Cleanup on plugin destroy
      */

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.0",
+  "version": "3.0.2",
   "keywords": [
     "strapi",
     "strapi-plugin",