@scalemule/nextjs 0.0.1 → 0.0.2

package/dist/server/index.mjs

@@ -2,6 +2,16 @@ import { cookies } from 'next/headers';
 import { NextResponse } from 'next/server';
 import { createHmac, timingSafeEqual } from '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;
@@ -542,22 +552,23 @@ var ScaleMuleServer = class {
             headers,
             body: formData
           });
-          const data = await response.json();
+          const text = await response.text();
+          const responseData = text ? JSON.parse(text) : null;
           if (!response.ok) {
-            return {
-              success: false,
-              error: data.error || { code: "UPLOAD_FAILED", message: "Upload failed" }
-            };
+            throw new ScaleMuleApiError(
+              responseData?.error || { code: "UPLOAD_FAILED", message: "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"
+          });
         }
       }
     };
@@ -580,7 +591,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) => {
@@ -735,23 +746,25 @@ var ScaleMuleServer = class {
         headers,
         body: options.body ? JSON.stringify(options.body) : void 0
       });
-      const data = await response.json();
+      const text = await response.text();
+      const responseData = text ? JSON.parse(text) : null;
       if (!response.ok) {
-        const error = data.error || {
+        const error = responseData?.error || {
           code: `HTTP_${response.status}`,
-          message: data.message || response.statusText
+          message: responseData?.message || 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"
+      });
     }
   }
 };
@@ -1010,18 +1023,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": {
@@ -1029,9 +1045,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)) {
@@ -1039,17 +1058,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": {
@@ -1077,11 +1096,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
             );
           }
@@ -1093,11 +1114,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
             );
           }
@@ -1109,12 +1132,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" });
@@ -1122,11 +1147,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
             );
           }
@@ -1138,15 +1165,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
@@ -1162,15 +1191,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
             );
           }
@@ -1195,14 +1226,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": {
@@ -1237,11 +1270,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
             );
           }
@@ -1269,15 +1304,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);
@@ -1325,48 +1363,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 {
@@ -1393,15 +1434,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":
@@ -1410,21 +1454,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);
@@ -1487,18 +1534,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
@@ -1576,12 +1627,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 = {}) {
@@ -1722,13 +1770,7 @@ function createAuthMiddleware(config = {}) {
     if (!skipValidation) {
       try {
         const sm = createServerClient();
-        const result = await sm.auth.me(session.sessionToken);
-        if (!result.success) {
-          const response = 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 = NextResponse.redirect(new URL(redirectTo, request.url));
@@ -1819,22 +1861,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;
   }
@@ -1882,24 +1920,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;
   }

package/dist/server/webhook-handler.d.mts

@@ -1,2 +1,2 @@
-export { h as createWebhookHandler } from '../webhook-handler-C-5_Ey1T.mjs';
-import '../index-BkacIKdu.mjs';
+export { h as createWebhookHandler } from '../webhook-handler-DCSwldKC.mjs';
+import '../index-9v0SaLgg.mjs';

package/dist/server/webhook-handler.d.ts

@@ -1,2 +1,2 @@
-export { h as createWebhookHandler } from '../webhook-handler-BPNqhuwL.js';
-import '../index-BkacIKdu.js';
+export { h as createWebhookHandler } from '../webhook-handler-Ymeice_x.js';
+import '../index-9v0SaLgg.js';

package/dist/testing.d.mts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { U as User, K as StorageFile, j as ApiResponse, A as ApiError } from './index-BkacIKdu.mjs';
+import { U as User, N as StorageFile, A as ApiError } from './index-9v0SaLgg.mjs';
 
 interface MockUserOptions {
     id?: string;
@@ -27,8 +27,8 @@ interface MockFileOptions {
 }
 declare function createMockFile(options?: MockFileOptions): StorageFile;
 interface MockClientConfig {
-    /** Simulated responses for specific paths */
-    responses?: Record<string, ApiResponse<unknown>>;
+    /** Simulated responses for specific paths (return value, not wrapped) */
+    responses?: Record<string, unknown>;
     /** Default delay in ms (simulates network latency) */
     delay?: number;
     /** Whether to simulate errors */
@@ -46,13 +46,13 @@ declare class MockScaleMuleClient {
     getSessionToken(): string | null;
     getUserId(): string | null;
     isAuthenticated(): boolean;
-    request<T>(path: string): Promise<ApiResponse<T>>;
-    get<T>(path: string): Promise<ApiResponse<T>>;
-    post<T>(path: string): Promise<ApiResponse<T>>;
-    patch<T>(path: string): Promise<ApiResponse<T>>;
-    put<T>(path: string): Promise<ApiResponse<T>>;
-    delete<T>(path: string): Promise<ApiResponse<T>>;
-    upload<T>(): Promise<ApiResponse<T>>;
+    request<T>(path: string): Promise<T>;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string): Promise<T>;
+    patch<T>(path: string): Promise<T>;
+    put<T>(path: string): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+    upload<T>(): Promise<T>;
 }
 interface MockScaleMuleContextValue {
     client: MockScaleMuleClient;