@scalemule/nextjs 0.0.1 → 0.0.3

package/dist/server/index.js

@@ -4,6 +4,16 @@ var headers = require('next/headers');
 var server = require('next/server');
 var crypto$1 = require('crypto');
 
+// src/types/index.ts
+var ScaleMuleApiError = class extends Error {
+  constructor(error) {
+    super(error.message);
+    this.name = "ScaleMuleApiError";
+    this.code = error.code;
+    this.field = error.field;
+  }
+};
+
 // src/server/context.ts
 function validateIP(ip) {
   if (!ip) return void 0;
@@ -544,22 +554,27 @@ var ScaleMuleServer = class {
             headers,
             body: formData
           });
-          const data = await response.json();
+          const text = await response.text();
+          let responseData = null;
+          try {
+            responseData = text ? JSON.parse(text) : null;
+          } catch {
+          }
           if (!response.ok) {
-            return {
-              success: false,
-              error: data.error || { code: "UPLOAD_FAILED", message: "Upload failed" }
-            };
+            throw new ScaleMuleApiError(
+              responseData?.error || { code: "UPLOAD_FAILED", message: text || "Upload failed" }
+            );
           }
+          const data = responseData?.data !== void 0 ? responseData.data : responseData;
           return data;
         } catch (err) {
-          return {
-            success: false,
-            error: {
-              code: "UPLOAD_ERROR",
-              message: err instanceof Error ? err.message : "Upload failed"
-            }
-          };
+          if (err instanceof ScaleMuleApiError) {
+            throw err;
+          }
+          throw new ScaleMuleApiError({
+            code: "UPLOAD_ERROR",
+            message: err instanceof Error ? err.message : "Upload failed"
+          });
         }
       }
     };
@@ -582,7 +597,7 @@ var ScaleMuleServer = class {
        * })
        *
        * // Store the secret for signature verification
-       * console.log('Webhook secret:', result.data.secret)
+       * console.log('Webhook secret:', result.secret)
        * ```
        */
       create: async (data) => {
@@ -737,23 +752,29 @@ var ScaleMuleServer = class {
         headers,
         body: options.body ? JSON.stringify(options.body) : void 0
       });
-      const data = await response.json();
+      const text = await response.text();
+      let responseData = null;
+      try {
+        responseData = text ? JSON.parse(text) : null;
+      } catch {
+      }
       if (!response.ok) {
-        const error = data.error || {
+        const error = responseData?.error || {
           code: `HTTP_${response.status}`,
-          message: data.message || response.statusText
+          message: responseData?.message || text || response.statusText
         };
-        return { success: false, error };
+        throw new ScaleMuleApiError(error);
       }
+      const data = responseData?.data !== void 0 ? responseData.data : responseData;
       return data;
     } catch (err) {
-      return {
-        success: false,
-        error: {
-          code: "SERVER_ERROR",
-          message: err instanceof Error ? err.message : "Request failed"
-        }
-      };
+      if (err instanceof ScaleMuleApiError) {
+        throw err;
+      }
+      throw new ScaleMuleApiError({
+        code: "SERVER_ERROR",
+        message: err instanceof Error ? err.message : "Request failed"
+      });
     }
   }
 };
@@ -1012,18 +1033,21 @@ function createAuthRoutes(config = {}) {
           if (!email || !password) {
             return errorResponse("VALIDATION_ERROR", "Email and password required", 400);
           }
-          const result = await sm.auth.register({ email, password, full_name, username, phone });
-          if (!result.success) {
+          let registeredUser;
+          try {
+            registeredUser = await sm.auth.register({ email, password, full_name, username, phone });
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
             return errorResponse(
-              result.error?.code || "REGISTER_FAILED",
-              result.error?.message || "Registration failed",
+              apiErr?.code || "REGISTER_FAILED",
+              apiErr?.message || "Registration failed",
               400
             );
           }
-          if (config.onRegister && result.data) {
-            await config.onRegister({ id: result.data.id, email: result.data.email });
+          if (config.onRegister) {
+            await config.onRegister({ id: registeredUser.id, email: registeredUser.email });
           }
-          return successResponse({ user: result.data, message: "Registration successful" }, 201);
+          return successResponse({ user: registeredUser, message: "Registration successful" }, 201);
         }
         // ==================== Login ====================
         case "login": {
@@ -1031,9 +1055,12 @@ function createAuthRoutes(config = {}) {
           if (!email || !password) {
             return errorResponse("VALIDATION_ERROR", "Email and password required", 400);
           }
-          const result = await sm.auth.login({ email, password, remember_me });
-          if (!result.success || !result.data) {
-            const errorCode = result.error?.code || "LOGIN_FAILED";
+          let loginData;
+          try {
+            loginData = await sm.auth.login({ email, password, remember_me });
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
+            const errorCode = apiErr?.code || "LOGIN_FAILED";
             let status = 400;
             if (errorCode === "INVALID_CREDENTIALS" || errorCode === "UNAUTHORIZED") status = 401;
             if (["EMAIL_NOT_VERIFIED", "PHONE_NOT_VERIFIED", "ACCOUNT_LOCKED", "ACCOUNT_DISABLED", "MFA_REQUIRED"].includes(errorCode)) {
@@ -1041,17 +1068,17 @@ function createAuthRoutes(config = {}) {
             }
             return errorResponse(
               errorCode,
-              result.error?.message || "Login failed",
+              apiErr?.message || "Login failed",
               status
             );
           }
           if (config.onLogin) {
             await config.onLogin({
-              id: result.data.user.id,
-              email: result.data.user.email
+              id: loginData.user.id,
+              email: loginData.user.email
             });
           }
-          return withSession(result.data, { user: result.data.user }, cookieOptions);
+          return withSession(loginData, { user: loginData.user }, cookieOptions);
         }
         // ==================== Logout ====================
         case "logout": {
@@ -1079,11 +1106,13 @@ function createAuthRoutes(config = {}) {
           if (!token || !new_password) {
             return errorResponse("VALIDATION_ERROR", "Token and new password required", 400);
           }
-          const result = await sm.auth.resetPassword(token, new_password);
-          if (!result.success) {
+          try {
+            await sm.auth.resetPassword(token, new_password);
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
             return errorResponse(
-              result.error?.code || "RESET_FAILED",
-              result.error?.message || "Password reset failed",
+              apiErr?.code || "RESET_FAILED",
+              apiErr?.message || "Password reset failed",
               400
             );
           }
@@ -1095,11 +1124,13 @@ function createAuthRoutes(config = {}) {
           if (!token) {
             return errorResponse("VALIDATION_ERROR", "Token required", 400);
           }
-          const result = await sm.auth.verifyEmail(token);
-          if (!result.success) {
+          try {
+            await sm.auth.verifyEmail(token);
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
             return errorResponse(
-              result.error?.code || "VERIFY_FAILED",
-              result.error?.message || "Email verification failed",
+              apiErr?.code || "VERIFY_FAILED",
+              apiErr?.message || "Email verification failed",
               400
             );
           }
@@ -1111,12 +1142,14 @@ function createAuthRoutes(config = {}) {
           const { email } = body;
           const session = await getSession();
           if (email) {
-            const result2 = await sm.auth.resendVerification(email);
-            if (!result2.success) {
+            try {
+              await sm.auth.resendVerification(email);
+            } catch (err) {
+              const apiErr = err instanceof ScaleMuleApiError ? err : null;
               return errorResponse(
-                result2.error?.code || "RESEND_FAILED",
-                result2.error?.message || "Failed to resend verification",
-                result2.error?.code === "RATE_LIMITED" ? 429 : 400
+                apiErr?.code || "RESEND_FAILED",
+                apiErr?.message || "Failed to resend verification",
+                apiErr?.code === "RATE_LIMITED" ? 429 : 400
               );
             }
             return successResponse({ message: "Verification email sent" });
@@ -1124,11 +1157,13 @@ function createAuthRoutes(config = {}) {
           if (!session) {
             return errorResponse("UNAUTHORIZED", "Email or session required", 401);
           }
-          const result = await sm.auth.resendVerification(session.sessionToken);
-          if (!result.success) {
+          try {
+            await sm.auth.resendVerification(session.sessionToken);
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
             return errorResponse(
-              result.error?.code || "RESEND_FAILED",
-              result.error?.message || "Failed to resend verification",
+              apiErr?.code || "RESEND_FAILED",
+              apiErr?.message || "Failed to resend verification",
               400
             );
           }
@@ -1140,15 +1175,17 @@ function createAuthRoutes(config = {}) {
           if (!session) {
             return errorResponse("UNAUTHORIZED", "Authentication required", 401);
           }
-          const result = await sm.auth.refresh(session.sessionToken);
-          if (!result.success || !result.data) {
+          let refreshData;
+          try {
+            refreshData = await sm.auth.refresh(session.sessionToken);
+          } catch {
             return clearSession(
               { message: "Session expired" },
               cookieOptions
             );
           }
           return withRefreshedSession(
-            result.data.session_token,
+            refreshData.session_token,
             session.userId,
             { message: "Session refreshed" },
             cookieOptions
@@ -1164,15 +1201,17 @@ function createAuthRoutes(config = {}) {
           if (!current_password || !new_password) {
             return errorResponse("VALIDATION_ERROR", "Current and new password required", 400);
           }
-          const result = await sm.user.changePassword(
-            session.sessionToken,
-            current_password,
-            new_password
-          );
-          if (!result.success) {
+          try {
+            await sm.user.changePassword(
+              session.sessionToken,
+              current_password,
+              new_password
+            );
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
             return errorResponse(
-              result.error?.code || "CHANGE_FAILED",
-              result.error?.message || "Failed to change password",
+              apiErr?.code || "CHANGE_FAILED",
+              apiErr?.message || "Failed to change password",
               400
             );
           }
@@ -1197,14 +1236,16 @@ function createAuthRoutes(config = {}) {
           if (!session) {
             return errorResponse("UNAUTHORIZED", "Authentication required", 401);
           }
-          const result = await sm.auth.me(session.sessionToken);
-          if (!result.success || !result.data) {
+          let userData;
+          try {
+            userData = await sm.auth.me(session.sessionToken);
+          } catch {
             return clearSession(
               { error: { code: "SESSION_EXPIRED", message: "Session expired" } },
               cookieOptions
             );
           }
-          return successResponse({ user: result.data });
+          return successResponse({ user: userData });
         }
         // ==================== Get Session Status ====================
         case "session": {
@@ -1239,11 +1280,13 @@ function createAuthRoutes(config = {}) {
           if (!password) {
             return errorResponse("VALIDATION_ERROR", "Password required", 400);
           }
-          const result = await sm.user.deleteAccount(session.sessionToken, password);
-          if (!result.success) {
+          try {
+            await sm.user.deleteAccount(session.sessionToken, password);
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
             return errorResponse(
-              result.error?.code || "DELETE_FAILED",
-              result.error?.message || "Failed to delete account",
+              apiErr?.code || "DELETE_FAILED",
+              apiErr?.message || "Failed to delete account",
               400
             );
           }
@@ -1271,15 +1314,18 @@ function createAuthRoutes(config = {}) {
           }
           const body = await request.json().catch(() => ({}));
           const { full_name, avatar_url } = body;
-          const result = await sm.user.update(session.sessionToken, { full_name, avatar_url });
-          if (!result.success || !result.data) {
+          let updatedUser;
+          try {
+            updatedUser = await sm.user.update(session.sessionToken, { full_name, avatar_url });
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
             return errorResponse(
-              result.error?.code || "UPDATE_FAILED",
-              result.error?.message || "Failed to update profile",
+              apiErr?.code || "UPDATE_FAILED",
+              apiErr?.message || "Failed to update profile",
               400
             );
           }
-          return successResponse({ user: result.data });
+          return successResponse({ user: updatedUser });
         }
         default:
           return errorResponse("NOT_FOUND", `Unknown endpoint: ${path}`, 404);
@@ -1327,48 +1373,51 @@ function createAnalyticsRoutes(config = {}) {
     if (!event_name) {
       return errorResponse("VALIDATION_ERROR", "event_name is required", 400);
     }
-    const result = await sm.analytics.trackEvent(
-      {
-        event_name,
-        event_category,
-        properties,
-        user_id,
-        session_id,
-        anonymous_id,
-        session_duration_seconds,
-        page_url,
-        page_title,
-        referrer,
-        landing_page,
-        device_type,
-        device_brand,
-        device_model,
-        browser,
-        browser_version,
-        os,
-        os_version,
-        screen_resolution,
-        viewport_size,
-        utm_source,
-        utm_medium,
-        utm_campaign,
-        utm_term,
-        utm_content,
-        client_timestamp: client_timestamp || timestamp
-      },
-      { clientContext }
-    );
-    if (!result.success) {
+    let trackResult;
+    try {
+      trackResult = await sm.analytics.trackEvent(
+        {
+          event_name,
+          event_category,
+          properties,
+          user_id,
+          session_id,
+          anonymous_id,
+          session_duration_seconds,
+          page_url,
+          page_title,
+          referrer,
+          landing_page,
+          device_type,
+          device_brand,
+          device_model,
+          browser,
+          browser_version,
+          os,
+          os_version,
+          screen_resolution,
+          viewport_size,
+          utm_source,
+          utm_medium,
+          utm_campaign,
+          utm_term,
+          utm_content,
+          client_timestamp: client_timestamp || timestamp
+        },
+        { clientContext }
+      );
+    } catch (err) {
+      const apiErr = err instanceof ScaleMuleApiError ? err : null;
       return errorResponse(
-        result.error?.code || "TRACK_FAILED",
-        result.error?.message || "Failed to track event",
+        apiErr?.code || "TRACK_FAILED",
+        apiErr?.message || "Failed to track event",
         400
       );
     }
     if (config.onEvent) {
-      await config.onEvent({ event_name, session_id: result.data?.session_id });
+      await config.onEvent({ event_name, session_id: trackResult?.session_id });
     }
-    return successResponse({ tracked: result.data?.tracked || 1, session_id: result.data?.session_id });
+    return successResponse({ tracked: trackResult?.tracked || 1, session_id: trackResult?.session_id });
   };
   const POST = async (request, context) => {
     try {
@@ -1395,15 +1444,18 @@ function createAnalyticsRoutes(config = {}) {
           if (events.length > 100) {
             return errorResponse("VALIDATION_ERROR", "Maximum 100 events per batch", 400);
           }
-          const result = await sm.analytics.trackBatch(events, { clientContext });
-          if (!result.success) {
+          let batchResult;
+          try {
+            batchResult = await sm.analytics.trackBatch(events, { clientContext });
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
             return errorResponse(
-              result.error?.code || "BATCH_FAILED",
-              result.error?.message || "Failed to track events",
+              apiErr?.code || "BATCH_FAILED",
+              apiErr?.message || "Failed to track events",
               400
             );
           }
-          return successResponse({ tracked: result.data?.tracked || events.length });
+          return successResponse({ tracked: batchResult?.tracked || events.length });
         }
         // ==================== Track Page View ====================
         case "page-view":
@@ -1412,21 +1464,24 @@ function createAnalyticsRoutes(config = {}) {
           if (!page_url) {
             return errorResponse("VALIDATION_ERROR", "page_url is required", 400);
           }
-          const result = await sm.analytics.trackPageView(
-            { page_url, page_title, referrer, session_id, user_id },
-            { clientContext }
-          );
-          if (!result.success) {
+          let pageViewResult;
+          try {
+            pageViewResult = await sm.analytics.trackPageView(
+              { page_url, page_title, referrer, session_id, user_id },
+              { clientContext }
+            );
+          } catch (err) {
+            const apiErr = err instanceof ScaleMuleApiError ? err : null;
             return errorResponse(
-              result.error?.code || "TRACK_FAILED",
-              result.error?.message || "Failed to track page view",
+              apiErr?.code || "TRACK_FAILED",
+              apiErr?.message || "Failed to track page view",
               400
             );
           }
           if (config.onEvent) {
-            await config.onEvent({ event_name: "page_viewed", session_id: result.data?.session_id });
+            await config.onEvent({ event_name: "page_viewed", session_id: pageViewResult?.session_id });
           }
-          return successResponse({ tracked: result.data?.tracked || 1, session_id: result.data?.session_id });
+          return successResponse({ tracked: pageViewResult?.tracked || 1, session_id: pageViewResult?.session_id });
         }
         default:
           return errorResponse("NOT_FOUND", `Unknown endpoint: ${path}`, 404);
@@ -1489,18 +1544,22 @@ function errorCodeToStatus(code) {
   return CODE_TO_STATUS[code.toLowerCase()] || 400;
 }
 function unwrap(result) {
-  if (result.error || result.success === false) {
-    const err = result.error;
-    const code = err?.code || "UNKNOWN_ERROR";
-    const status = err?.status || errorCodeToStatus(code);
-    throw new ScaleMuleError(
-      code,
-      err?.message || "An error occurred",
-      status,
-      err?.details
-    );
+  if (result !== null && result !== void 0 && typeof result === "object" && ("success" in result || "error" in result) && "data" in result) {
+    const envelope = result;
+    if (envelope.error || envelope.success === false) {
+      const err = envelope.error;
+      const code = err?.code || "UNKNOWN_ERROR";
+      const status = err?.status || errorCodeToStatus(code);
+      throw new ScaleMuleError(
+        code,
+        err?.message || "An error occurred",
+        status,
+        err?.details
+      );
+    }
+    return envelope.data;
   }
-  return result.data;
+  return result;
 }
 
 // src/server/handler.ts
@@ -1578,12 +1637,9 @@ async function registerVideoWebhook(url, options) {
     url,
     events: options?.events || ["video.ready", "video.failed"]
   });
-  if (!result.success || !result.data) {
-    throw new Error(result.error?.message || "Failed to register webhook");
-  }
   return {
-    id: result.data.id,
-    secret: result.data.secret
+    id: result.id,
+    secret: result.secret
   };
 }
 function createWebhookRoutes(config = {}) {
@@ -1724,13 +1780,7 @@ function createAuthMiddleware(config = {}) {
     if (!skipValidation) {
       try {
         const sm = createServerClient();
-        const result = await sm.auth.me(session.sessionToken);
-        if (!result.success) {
-          const response = server.NextResponse.redirect(new URL(redirectTo, request.url));
-          response.cookies.delete(SESSION_COOKIE_NAME);
-          response.cookies.delete(USER_ID_COOKIE_NAME);
-          return response;
-        }
+        await sm.auth.me(session.sessionToken);
       } catch (error) {
         console.error("[ScaleMule Middleware] Session validation failed, blocking request:", error);
         const response = server.NextResponse.redirect(new URL(redirectTo, request.url));
@@ -1821,22 +1871,18 @@ async function getAppSecret(key) {
   try {
     const client = createServerClient();
     const result = await client.secrets.get(key);
-    if (!result.success) {
-      if (result.error?.code === "SECRET_NOT_FOUND") {
-        return void 0;
-      }
-      console.error(`[ScaleMule Secrets] Failed to fetch ${key}:`, result.error);
-      return void 0;
-    }
-    if (!noCache && result.data) {
+    if (!noCache && result) {
       secretsCache[key] = {
-        value: result.data.value,
-        version: result.data.version,
+        value: result.value,
+        version: result.version,
         cachedAt: Date.now()
       };
     }
-    return result.data?.value;
+    return result?.value;
   } catch (error) {
+    if (error instanceof ScaleMuleApiError && error.code === "SECRET_NOT_FOUND") {
+      return void 0;
+    }
     console.error(`[ScaleMule Secrets] Error fetching ${key}:`, error);
     return void 0;
   }
@@ -1884,24 +1930,20 @@ async function getBundle(key, resolve = true) {
   try {
     const client = createServerClient();
     const result = await client.bundles.get(key, resolve);
-    if (!result.success) {
-      if (result.error?.code === "BUNDLE_NOT_FOUND") {
-        return void 0;
-      }
-      console.error(`[ScaleMule Bundles] Failed to fetch ${key}:`, result.error);
-      return void 0;
-    }
-    if (!noCache && result.data) {
+    if (!noCache && result) {
       bundlesCache[key] = {
-        type: result.data.type,
-        data: result.data.data,
-        version: result.data.version,
-        inheritsFrom: result.data.inherits_from,
+        type: result.type,
+        data: result.data,
+        version: result.version,
+        inheritsFrom: result.inherits_from,
         cachedAt: Date.now()
       };
     }
-    return result.data?.data;
+    return result?.data;
   } catch (error) {
+    if (error instanceof ScaleMuleApiError && error.code === "BUNDLE_NOT_FOUND") {
+      return void 0;
+    }
     console.error(`[ScaleMule Bundles] Error fetching ${key}:`, error);
     return void 0;
   }