@scalemule/nextjs 0.0.1 → 0.0.2

package/dist/testing.d.ts

@@ -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.js';
+import { U as User, N as StorageFile, A as ApiError } from './index-9v0SaLgg.js';
 
 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;

package/dist/testing.js

@@ -3,6 +3,15 @@
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 
+// 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;
+  }
+};
 function createMockUser(options = {}) {
   return {
     id: options.id ?? "mock-user-id-123",
@@ -62,15 +71,12 @@ var MockScaleMuleClient = class {
   async request(path) {
     await this.simulateDelay();
     if (this.simulateErrors) {
-      return {
-        success: false,
-        error: { code: "MOCK_ERROR", message: "Simulated error" }
-      };
+      throw new ScaleMuleApiError({ code: "MOCK_ERROR", message: "Simulated error" });
     }
-    if (this.responses[path]) {
+    if (this.responses[path] !== void 0) {
       return this.responses[path];
     }
-    return { success: true, data: {} };
+    return {};
   }
   async get(path) {
     return this.request(path);
@@ -89,7 +95,7 @@ var MockScaleMuleClient = class {
   }
   async upload() {
     await this.simulateDelay();
-    return { success: true, data: {} };
+    return {};
   }
 };
 var MockScaleMuleContext = react.createContext(null);

package/dist/testing.mjs

@@ -1,6 +1,15 @@
 import { createContext, useState, useMemo, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
+// 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;
+  }
+};
 function createMockUser(options = {}) {
   return {
     id: options.id ?? "mock-user-id-123",
@@ -60,15 +69,12 @@ var MockScaleMuleClient = class {
   async request(path) {
     await this.simulateDelay();
     if (this.simulateErrors) {
-      return {
-        success: false,
-        error: { code: "MOCK_ERROR", message: "Simulated error" }
-      };
+      throw new ScaleMuleApiError({ code: "MOCK_ERROR", message: "Simulated error" });
     }
-    if (this.responses[path]) {
+    if (this.responses[path] !== void 0) {
       return this.responses[path];
     }
-    return { success: true, data: {} };
+    return {};
   }
   async get(path) {
     return this.request(path);
@@ -87,7 +93,7 @@ var MockScaleMuleClient = class {
   }
   async upload() {
     await this.simulateDelay();
-    return { success: true, data: {} };
+    return {};
   }
 };
 var MockScaleMuleContext = createContext(null);

package/dist/{webhook-handler-BPNqhuwL.d.ts → webhook-handler-DCSwldKC.d.mts}

@@ -1,4 +1,4 @@
-import { R as RegisterRequest, j as ApiResponse, U as User, k as LoginRequest, L as LoginResponse, c as ListFilesParams, Q as ListFilesResponse, K as StorageFile, _ as ClientContext, T as UploadResponse } from './index-BkacIKdu.js';
+import { R as RegisterRequest, U as User, l as LoginRequest, L as LoginResponse, c as ListFilesParams, T as ListFilesResponse, N as StorageFile, $ as ClientContext, W as UploadResponse } from './index-9v0SaLgg.mjs';
 
 /**
  * Server-Side ScaleMule Client
@@ -39,53 +39,53 @@ declare class ScaleMuleServer {
         /**
          * Register a new user
          */
-        register: (data: RegisterRequest) => Promise<ApiResponse<User>>;
+        register: (data: RegisterRequest) => Promise<User>;
         /**
          * Login user - returns session token (store in HTTP-only cookie)
          */
-        login: (data: LoginRequest) => Promise<ApiResponse<LoginResponse>>;
+        login: (data: LoginRequest) => Promise<LoginResponse>;
         /**
          * Logout user
          */
-        logout: (sessionToken: string) => Promise<ApiResponse<void>>;
+        logout: (sessionToken: string) => Promise<void>;
         /**
          * Get current user from session token
          */
-        me: (sessionToken: string) => Promise<ApiResponse<User>>;
+        me: (sessionToken: string) => Promise<User>;
         /**
          * Refresh session token
          */
-        refresh: (sessionToken: string) => Promise<ApiResponse<{
+        refresh: (sessionToken: string) => Promise<{
             session_token: string;
             expires_at: string;
-        }>>;
+        }>;
         /**
          * Request password reset email
          */
-        forgotPassword: (email: string) => Promise<ApiResponse<{
+        forgotPassword: (email: string) => Promise<{
             message: string;
-        }>>;
+        }>;
         /**
          * Reset password with token
          */
-        resetPassword: (token: string, newPassword: string) => Promise<ApiResponse<{
+        resetPassword: (token: string, newPassword: string) => Promise<{
             message: string;
-        }>>;
+        }>;
         /**
          * Verify email with token
          */
-        verifyEmail: (token: string) => Promise<ApiResponse<{
+        verifyEmail: (token: string) => Promise<{
             message: string;
-        }>>;
+        }>;
         /**
          * Resend verification email.
          * Can be called with a session token (authenticated) or email (unauthenticated).
          */
         resendVerification: (sessionTokenOrEmail: string, options?: {
             email?: string;
-        }) => Promise<ApiResponse<{
+        }) => Promise<{
             message: string;
-        }>>;
+        }>;
     };
     user: {
         /**
@@ -94,25 +94,25 @@ declare class ScaleMuleServer {
         update: (sessionToken: string, data: {
             full_name?: string;
             avatar_url?: string;
-        }) => Promise<ApiResponse<User>>;
+        }) => Promise<User>;
         /**
          * Change password
          */
-        changePassword: (sessionToken: string, currentPassword: string, newPassword: string) => Promise<ApiResponse<{
+        changePassword: (sessionToken: string, currentPassword: string, newPassword: string) => Promise<{
             message: string;
-        }>>;
+        }>;
         /**
          * Change email
          */
-        changeEmail: (sessionToken: string, newEmail: string, password: string) => Promise<ApiResponse<{
+        changeEmail: (sessionToken: string, newEmail: string, password: string) => Promise<{
             message: string;
-        }>>;
+        }>;
         /**
          * Delete account
          */
-        deleteAccount: (sessionToken: string, password: string) => Promise<ApiResponse<{
+        deleteAccount: (sessionToken: string, password: string) => Promise<{
             message: string;
-        }>>;
+        }>;
     };
     secrets: {
         /**
@@ -126,10 +126,10 @@ declare class ScaleMuleServer {
          * }
          * ```
          */
-        get: (key: string) => Promise<ApiResponse<{
+        get: (key: string) => Promise<{
             value: string;
             version: number;
-        }>>;
+        }>;
         /**
          * Set a secret in the tenant vault
          *
@@ -138,46 +138,46 @@ declare class ScaleMuleServer {
          * await scalemule.secrets.set('ANONYMOUS_USER_SALT', 'my-secret-salt')
          * ```
          */
-        set: (key: string, value: string) => Promise<ApiResponse<{
+        set: (key: string, value: string) => Promise<{
             value: string;
             version: number;
-        }>>;
+        }>;
         /**
          * Delete a secret from the tenant vault
          */
-        delete: (key: string) => Promise<ApiResponse<void>>;
+        delete: (key: string) => Promise<void>;
         /**
          * List all secrets in the tenant vault
          */
-        list: () => Promise<ApiResponse<{
+        list: () => Promise<{
             secrets: Array<{
                 path: string;
                 version: number;
             }>;
-        }>>;
+        }>;
         /**
          * Get secret version history
          */
-        versions: (key: string) => Promise<ApiResponse<{
+        versions: (key: string) => Promise<{
             versions: Array<{
                 version: number;
                 created_at: string;
             }>;
-        }>>;
+        }>;
         /**
          * Rollback to a specific version
          */
-        rollback: (key: string, version: number) => Promise<ApiResponse<{
+        rollback: (key: string, version: number) => Promise<{
             value: string;
             version: number;
-        }>>;
+        }>;
         /**
          * Rotate a secret (copy current version as new version)
          */
-        rotate: (key: string, newValue: string) => Promise<ApiResponse<{
+        rotate: (key: string, newValue: string) => Promise<{
             value: string;
             version: number;
-        }>>;
+        }>;
     };
     bundles: {
         /**
@@ -194,12 +194,12 @@ declare class ScaleMuleServer {
          * }
          * ```
          */
-        get: <T = Record<string, unknown>>(key: string, resolve?: boolean) => Promise<ApiResponse<{
+        get: <T = Record<string, unknown>>(key: string, resolve?: boolean) => Promise<{
             type: string;
             data: T;
             version: number;
             inherits_from?: string;
-        }>>;
+        }>;
         /**
          * Set a bundle (structured secret)
          *
@@ -225,26 +225,26 @@ declare class ScaleMuleServer {
          * }, 'database/prod')
          * ```
          */
-        set: <T = Record<string, unknown>>(key: string, type: string, data: T, inheritsFrom?: string) => Promise<ApiResponse<{
+        set: <T = Record<string, unknown>>(key: string, type: string, data: T, inheritsFrom?: string) => Promise<{
             type: string;
             data: T;
             version: number;
-        }>>;
+        }>;
         /**
          * Delete a bundle
          */
-        delete: (key: string) => Promise<ApiResponse<void>>;
+        delete: (key: string) => Promise<void>;
         /**
          * List all bundles
          */
-        list: () => Promise<ApiResponse<{
+        list: () => Promise<{
             bundles: Array<{
                 path: string;
                 type: string;
                 version: number;
                 inherits_from?: string;
             }>;
-        }>>;
+        }>;
         /**
          * Get connection URL for a database bundle
          *
@@ -256,9 +256,9 @@ declare class ScaleMuleServer {
          * }
          * ```
          */
-        connectionUrl: (key: string) => Promise<ApiResponse<{
+        connectionUrl: (key: string) => Promise<{
             url: string;
-        }>>;
+        }>;
     };
     vaultAudit: {
         /**
@@ -279,7 +279,7 @@ declare class ScaleMuleServer {
             since?: string;
             until?: string;
             limit?: number;
-        }) => Promise<ApiResponse<{
+        }) => Promise<{
             logs: Array<{
                 timestamp: string;
                 action: string;
@@ -287,21 +287,21 @@ declare class ScaleMuleServer {
                 success: boolean;
                 error_message?: string;
             }>;
-        }>>;
+        }>;
     };
     storage: {
         /**
          * List user's files
          */
-        list: (userId: string, params?: ListFilesParams) => Promise<ApiResponse<ListFilesResponse>>;
+        list: (userId: string, params?: ListFilesParams) => Promise<ListFilesResponse>;
         /**
          * Get file info
          */
-        get: (fileId: string) => Promise<ApiResponse<StorageFile>>;
+        get: (fileId: string) => Promise<StorageFile>;
         /**
          * Delete file
          */
-        delete: (userId: string, fileId: string) => Promise<ApiResponse<void>>;
+        delete: (userId: string, fileId: string) => Promise<void>;
         /**
          * Upload file (from server - use FormData)
          *
@@ -326,7 +326,7 @@ declare class ScaleMuleServer {
             contentType: string;
         }, options?: {
             clientContext?: ClientContext;
-        }) => Promise<ApiResponse<UploadResponse>>;
+        }) => Promise<UploadResponse>;
     };
     webhooks: {
         /**
@@ -341,23 +341,23 @@ declare class ScaleMuleServer {
          * })
          *
          * // Store the secret for signature verification
-         * console.log('Webhook secret:', result.data.secret)
+         * console.log('Webhook secret:', result.secret)
          * ```
          */
         create: (data: {
             webhook_name: string;
             url: string;
             events: string[];
-        }) => Promise<ApiResponse<{
+        }) => Promise<{
             id: string;
             secret: string;
             url: string;
             events: string[];
-        }>>;
+        }>;
         /**
          * List all webhook subscriptions
          */
-        list: () => Promise<ApiResponse<{
+        list: () => Promise<{
             webhooks: Array<{
                 id: string;
                 webhook_name: string;
@@ -365,11 +365,11 @@ declare class ScaleMuleServer {
                 events: string[];
                 is_enabled: boolean;
             }>;
-        }>>;
+        }>;
         /**
          * Delete a webhook subscription
          */
-        delete: (id: string) => Promise<ApiResponse<void>>;
+        delete: (id: string) => Promise<void>;
         /**
          * Update a webhook subscription
          */
@@ -377,21 +377,21 @@ declare class ScaleMuleServer {
             url?: string;
             events?: string[];
             is_enabled?: boolean;
-        }) => Promise<ApiResponse<{
+        }) => Promise<{
             id: string;
             url: string;
             events: string[];
-        }>>;
+        }>;
         /**
          * Get available webhook event types
          */
-        eventTypes: () => Promise<ApiResponse<{
+        eventTypes: () => Promise<{
             events: Array<{
                 event_name: string;
                 event_description: string;
                 payload_schema: Record<string, unknown>;
             }>;
-        }>>;
+        }>;
     };
     analytics: {
         /**
@@ -446,10 +446,10 @@ declare class ScaleMuleServer {
             timestamp?: string;
         }, options?: {
             clientContext?: ClientContext;
-        }) => Promise<ApiResponse<{
+        }) => Promise<{
             tracked: number;
             session_id?: string;
-        }>>;
+        }>;
         /**
          * Track a page view
          *
@@ -470,10 +470,10 @@ declare class ScaleMuleServer {
             user_id?: string;
         }, options?: {
             clientContext?: ClientContext;
-        }) => Promise<ApiResponse<{
+        }) => Promise<{
             tracked: number;
             session_id?: string;
-        }>>;
+        }>;
         /**
          * Track multiple events in a batch (max 100)
          *
@@ -511,9 +511,9 @@ declare class ScaleMuleServer {
             timestamp?: string;
         }>, options?: {
             clientContext?: ClientContext;
-        }) => Promise<ApiResponse<{
+        }) => Promise<{
             tracked: number;
-        }>>;
+        }>;
     };
 }
 /**