@moontra/moonui-pro 2.37.16 → 2.37.17

package/dist/index.mjs

@@ -2239,62 +2239,47 @@ function MoonUIAuthProvider({
             console.log('[MoonUI Auth] Auth server not available in development. Run "moonui dev" to enable Pro features.');
           }
         }
-        if (isProduction) {
-          if (licenseKey) {
-            console.log("[MoonUI Auth] Production mode - validating license key...");
-            try {
-              const currentDomain = typeof window !== "undefined" ? window.location.hostname : process.env.VERCEL_URL || process.env.NEXT_PUBLIC_VERCEL_URL || "";
-              const apiUrl = "https://moonui.dev/api/v1/license/validate";
-              const validationResponse = await fetch(apiUrl, {
-                method: "POST",
-                headers: {
-                  "Content-Type": "application/json"
-                },
-                body: JSON.stringify({
-                  licenseKey,
-                  domain: currentDomain
-                })
-              });
-              if (validationResponse.ok) {
-                const validationData = await validationResponse.json();
-                if (validationData.valid && validationData.hasProAccess) {
-                  console.log("[MoonUI Auth] License key validated successfully");
-                  const newState = {
-                    isLoading: false,
-                    hasProAccess: validationData.hasProAccess,
-                    isAuthenticated: true,
-                    subscriptionPlan: validationData.plan === "lifetime" ? "lifetime" : "free",
-                    subscription: {
-                      status: validationData.hasProAccess ? "active" : "inactive",
-                      plan: validationData.plan === "lifetime" ? "lifetime" : "free"
-                    },
-                    isAdmin: false
-                  };
-                  if (typeof document !== "undefined" && validationData.cacheDuration) {
-                    const cacheData = {
-                      valid: true,
-                      hasProAccess: validationData.hasProAccess,
-                      timestamp: Date.now()
-                    };
-                    document.cookie = `moonui_pro_status=${encodeURIComponent(
-                      JSON.stringify(cacheData)
-                    )}; max-age=${Math.floor(validationData.cacheDuration / 1e3)}; path=/; SameSite=Strict`;
-                  }
-                  if (isMounted.current) {
-                    setState(newState);
-                  }
-                  authPromise = null;
-                  return newState;
-                } else {
-                  console.warn("[MoonUI Auth] License key validation failed:", validationData.error || "Invalid license");
-                }
-              } else {
-                console.error("[MoonUI Auth] License validation request failed:", validationResponse.status);
-              }
-            } catch (error) {
-              console.error("[MoonUI Auth] License validation error:", error);
+        if (isProduction && licenseKey) {
+          console.log("[MoonUI Auth] Production mode - License key provided");
+          const cachedValidation = readValidationFromCookie();
+          if (cachedValidation && cachedValidation.valid && cachedValidation.hasProAccess) {
+            console.log("[MoonUI Auth] Using cached server validation");
+            const newState2 = {
+              isLoading: false,
+              hasProAccess: cachedValidation.hasProAccess,
+              isAuthenticated: true,
+              subscriptionPlan: "lifetime",
+              subscription: {
+                status: "active",
+                plan: "lifetime"
+              },
+              isAdmin: false
+            };
+            if (isMounted.current) {
+              setState(newState2);
             }
+            authPromise = null;
+            return newState2;
+          }
+          console.log("[MoonUI Auth] License key detected - granting Pro access");
+          console.log("[MoonUI Auth] Note: Actual license validation should be done server-side");
+          const newState = {
+            isLoading: false,
+            hasProAccess: true,
+            // Grant access since license key is provided
+            isAuthenticated: true,
+            subscriptionPlan: "lifetime",
+            subscription: {
+              status: "active",
+              plan: "lifetime"
+            },
+            isAdmin: false
+          };
+          if (isMounted.current) {
+            setState(newState);
           }
+          authPromise = null;
+          return newState;
         }
         const freeState = {
           isLoading: false,

package/dist/server.d.ts

@@ -53,6 +53,66 @@ declare function performServerValidation(): Promise<{
     cached?: boolean;
 }>;
 
+/**
+ * Server-side license validation helper
+ * This should be used in API routes or server components to validate license keys
+ * and set appropriate cookies for client-side caching
+ */
+interface ValidateLicenseOptions {
+    licenseKey: string;
+    domain: string;
+}
+interface ValidationResponse {
+    valid: boolean;
+    hasProAccess: boolean;
+    plan?: 'lifetime' | 'monthly' | 'annual' | 'free';
+    error?: string;
+    cacheDuration?: number;
+}
+/**
+ * Validate a MoonUI license key on the server
+ * This function should be called from your API routes or server components
+ *
+ * @example Next.js API Route
+ * ```typescript
+ * // app/api/validate-license/route.ts
+ * import { validateLicense } from '@moontra/moonui-pro/server';
+ * import { NextResponse } from 'next/server';
+ *
+ * export async function POST(request: Request) {
+ *   const { licenseKey } = await request.json();
+ *   const domain = request.headers.get('host') || '';
+ *
+ *   const result = await validateLicense({ licenseKey, domain });
+ *
+ *   const response = NextResponse.json(result);
+ *
+ *   // Set cookie if validation successful
+ *   if (result.valid && result.hasProAccess) {
+ *     response.cookies.set('moonui_pro_status', JSON.stringify({
+ *       valid: true,
+ *       hasProAccess: result.hasProAccess,
+ *       timestamp: Date.now()
+ *     }), {
+ *       httpOnly: false, // Must be accessible by client
+ *       secure: process.env.NODE_ENV === 'production',
+ *       sameSite: 'strict',
+ *       maxAge: result.cacheDuration || 86400 // 24 hours default
+ *     });
+ *   }
+ *
+ *   return response;
+ * }
+ * ```
+ */
+declare function validateLicense({ licenseKey, domain }: ValidateLicenseOptions): Promise<ValidationResponse>;
+/**
+ * Helper to set MoonUI auth cookies
+ * Use this after successful validation
+ */
+declare function setAuthCookie(response: any, // Response object from your framework
+validationResult: ValidationResponse): void;
+
 /**
  * MoonUI Pro Authentication Configuration
  *
@@ -100,4 +160,4 @@ type AuthConfig = typeof AUTH_CONFIG;
 type CacheConfig = typeof AUTH_CONFIG.cache;
 type SecurityConfig = typeof AUTH_CONFIG.security;
 
-export { AUTH_CONFIG, AuthConfig, CacheConfig, SecurityConfig, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setValidationInCookies, validateWithMoonUIServer };
+export { AUTH_CONFIG, AuthConfig, CacheConfig, SecurityConfig, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setAuthCookie, setValidationInCookies, validateLicense, validateWithMoonUIServer };

package/dist/server.mjs

@@ -3148,6 +3148,67 @@ async function performServerValidation() {
   return { ...result, cached: false };
 }
 
+// src/lib/server-validate.ts
+async function validateLicense({
+  licenseKey,
+  domain
+}) {
+  try {
+    const response = await fetch("https://moonui.dev/api/v1/license/validate", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        // Add server-side headers to bypass CORS
+        "X-Server-Request": "true",
+        "X-Request-Domain": domain
+      },
+      body: JSON.stringify({
+        licenseKey,
+        domain
+      })
+    });
+    if (!response.ok) {
+      return {
+        valid: false,
+        hasProAccess: false,
+        error: `Validation failed: ${response.status}`
+      };
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    console.error("[MoonUI Server Validate] Error:", error);
+    return {
+      valid: false,
+      hasProAccess: false,
+      error: error instanceof Error ? error.message : "Validation error"
+    };
+  }
+}
+function setAuthCookie(response, validationResult) {
+  if (validationResult.valid && validationResult.hasProAccess) {
+    const cookieData = {
+      valid: true,
+      hasProAccess: validationResult.hasProAccess,
+      timestamp: Date.now()
+    };
+    const maxAge = validationResult.cacheDuration || 86400;
+    if (typeof response.setHeader === "function") {
+      response.setHeader(
+        "Set-Cookie",
+        `moonui_pro_status=${encodeURIComponent(JSON.stringify(cookieData))}; Max-Age=${maxAge}; Path=/; SameSite=Strict; ${""}`
+      );
+    } else if (response.cookies && typeof response.cookies.set === "function") {
+      response.cookies.set("moonui_pro_status", JSON.stringify(cookieData), {
+        maxAge,
+        path: "/",
+        sameSite: "strict",
+        secure: false
+      });
+    }
+  }
+}
+
 // src/server.ts
 if (typeof window !== "undefined") {
   console.warn(
@@ -3155,4 +3216,4 @@ if (typeof window !== "undefined") {
   );
 }
 
-export { AUTH_CONFIG, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setValidationInCookies, validateWithMoonUIServer };
+export { AUTH_CONFIG, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setAuthCookie, setValidationInCookies, validateLicense, validateWithMoonUIServer };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moontra/moonui-pro",
-    "version": "2.37.16",
+    "version": "2.37.17",
     "description": "Premium React components for MoonUI - Advanced UI library with 50+ pro components including performance, interactive, and gesture components",
     "type": "module",
     "main": "dist/index.mjs",