@insforge/sdk 0.0.58-dev.3 → 0.0.58-dev.5

package/dist/index.mjs

@@ -255,6 +255,28 @@ var Database = class {
 };
 
 // src/modules/auth.ts
+function convertDbProfileToCamelCase(dbProfile) {
+  const result = {
+    id: dbProfile.id
+  };
+  if (dbProfile.created_at !== void 0) result.createdAt = dbProfile.created_at;
+  if (dbProfile.updated_at !== void 0) result.updatedAt = dbProfile.updated_at;
+  Object.keys(dbProfile).forEach((key) => {
+    if (key === "id" || key === "created_at" || key === "updated_at") return;
+    const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    result[camelKey] = dbProfile[key];
+  });
+  return result;
+}
+function convertCamelCaseToDbProfile(profile) {
+  const dbProfile = {};
+  Object.keys(profile).forEach((key) => {
+    if (profile[key] === void 0) return;
+    const snakeKey = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    dbProfile[snakeKey] = profile[key];
+  });
+  return dbProfile;
+}
 var Auth = class {
   constructor(http, tokenManager) {
     this.http = http;
@@ -427,62 +449,24 @@ var Auth = class {
     }
   }
   /**
-   * Get list of available OAuth providers
-   * Returns the list of OAuth providers configured on the backend
+   * Get all public authentication configuration (OAuth + Email)
+   * Returns both OAuth providers and email authentication settings in one request
    * This is a public endpoint that doesn't require authentication
    * 
-   * @returns Array of configured OAuth providers with their configuration status
+   * @returns Complete public authentication configuration including OAuth providers and email auth settings
    * 
    * @example
    * ```ts
-   * const { data, error } = await insforge.auth.getOAuthProviders();
+   * const { data, error } = await insforge.auth.getPublicAuthConfig();
    * if (data) {
-   *   // data is an array of PublicOAuthProvider: [{ provider: 'google', isConfigured: true }, ...]
-   *   data.forEach(p => console.log(`${p.provider}: ${p.isConfigured ? 'configured' : 'not configured'}`));
+   *   console.log(`OAuth providers: ${data.oauth.data.length}`);
+   *   console.log(`Password min length: ${data.email.passwordMinLength}`);
    * }
    * ```
    */
-  async getOAuthProviders() {
+  async getPublicAuthConfig() {
     try {
-      const response = await this.http.get("/api/auth/oauth/providers");
-      return {
-        data: response.data,
-        error: null
-      };
-    } catch (error) {
-      if (error instanceof InsForgeError) {
-        return { data: null, error };
-      }
-      return {
-        data: null,
-        error: new InsForgeError(
-          "An unexpected error occurred while fetching OAuth providers",
-          500,
-          "UNEXPECTED_ERROR"
-        )
-      };
-    }
-  }
-  /**
-   * Get public email authentication configuration
-   * Returns email authentication settings configured on the backend
-   * This is a public endpoint that doesn't require authentication
-   * 
-   * @returns Email authentication configuration including password requirements and email verification settings
-   * 
-   * @example
-   * ```ts
-   * const { data, error } = await insforge.auth.getEmailAuthConfig();
-   * if (data) {
-   *   console.log(`Password min length: ${data.passwordMinLength}`);
-   *   console.log(`Requires email verification: ${data.requireEmailVerification}`);
-   *   console.log(`Requires uppercase: ${data.requireUppercase}`);
-   * }
-   * ```
-   */
-  async getEmailAuthConfig() {
-    try {
-      const response = await this.http.get("/api/auth/email/public-config");
+      const response = await this.http.get("/api/auth/public-config");
       return {
         data: response,
         error: null
@@ -494,7 +478,7 @@ var Auth = class {
       return {
         data: null,
         error: new InsForgeError(
-          "An unexpected error occurred while fetching email authentication configuration",
+          "An unexpected error occurred while fetching public authentication configuration",
           500,
           "UNEXPECTED_ERROR"
         )
@@ -503,7 +487,7 @@ var Auth = class {
   }
   /**
    * Get the current user with full profile information
-   * Returns both auth info (id, email, role) and profile data (nickname, avatar_url, bio, etc.)
+   * Returns both auth info (id, email, role) and profile data (dynamic fields from users table)
    */
   async getCurrentUser() {
     try {
@@ -520,7 +504,7 @@ var Auth = class {
       return {
         data: {
           user: authResponse.user,
-          profile
+          profile: profile ? convertDbProfileToCamelCase(profile) : null
         },
         error: null
       };
@@ -544,14 +528,17 @@ var Auth = class {
   }
   /**
    * Get any user's profile by ID
-   * Returns profile information from the users table (nickname, avatar_url, bio, etc.)
+   * Returns profile information from the users table (dynamic fields)
    */
   async getProfile(userId) {
     const { data, error } = await this.database.from("users").select("*").eq("id", userId).single();
     if (error && error.code === "PGRST116") {
       return { data: null, error: null };
     }
-    return { data, error };
+    if (data) {
+      return { data: convertDbProfileToCamelCase(data), error: null };
+    }
+    return { data: null, error };
   }
   /**
    * Get the current session (only session data, no API call)
@@ -581,7 +568,7 @@ var Auth = class {
   }
   /**
    * Set/Update the current user's profile
-   * Updates profile information in the users table (nickname, avatar_url, bio, etc.)
+   * Updates profile information in the users table (supports any dynamic fields)
    */
   async setProfile(profile) {
     const session = this.tokenManager.getSession();
@@ -605,7 +592,7 @@ var Auth = class {
           id: data2.user.id,
           email: data2.user.email,
           name: data2.profile?.nickname || "",
-          // Not available from API, but required by UserSchema
+          // Fallback - profile structure is dynamic
           emailVerified: false,
           // Not available from API, but required by UserSchema
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -616,8 +603,105 @@ var Auth = class {
         this.tokenManager.saveSession(session);
       }
     }
-    const { data, error } = await this.database.from("users").update(profile).eq("id", session.user.id).select().single();
-    return { data, error };
+    const dbProfile = convertCamelCaseToDbProfile(profile);
+    const { data, error } = await this.database.from("users").update(dbProfile).eq("id", session.user.id).select().single();
+    if (data) {
+      return { data: convertDbProfileToCamelCase(data), error: null };
+    }
+    return { data: null, error };
+  }
+  /**
+   * Send password reset code to user's email
+   * Always returns success to prevent user enumeration
+   */
+  async sendPasswordResetCode(request) {
+    try {
+      const response = await this.http.post(
+        "/api/auth/email/send-reset-password-code",
+        request
+      );
+      return {
+        data: response,
+        error: null
+      };
+    } catch (error) {
+      if (error instanceof InsForgeError) {
+        return { data: null, error };
+      }
+      return {
+        data: null,
+        error: new InsForgeError(
+          "An unexpected error occurred while sending password reset code",
+          500,
+          "UNEXPECTED_ERROR"
+        )
+      };
+    }
+  }
+  /**
+   * Reset password with OTP token
+   * Token can be from magic link or from code verification
+   */
+  async resetPassword(request) {
+    try {
+      const response = await this.http.post(
+        "/api/auth/reset-password",
+        request
+      );
+      return {
+        data: response,
+        error: null
+      };
+    } catch (error) {
+      if (error instanceof InsForgeError) {
+        return { data: null, error };
+      }
+      return {
+        data: null,
+        error: new InsForgeError(
+          "An unexpected error occurred while resetting password",
+          500,
+          "UNEXPECTED_ERROR"
+        )
+      };
+    }
+  }
+  /**
+   * Verify email with OTP token
+   * If email is provided: uses numeric OTP verification (6-digit code)
+   * If email is NOT provided: uses link OTP verification (64-char token)
+   */
+  async verifyEmail(request) {
+    try {
+      const response = await this.http.post(
+        "/api/auth/verify-email",
+        request
+      );
+      if (response.accessToken) {
+        const session = {
+          accessToken: response.accessToken,
+          user: response.user || {}
+        };
+        this.tokenManager.saveSession(session);
+        this.http.setAuthToken(response.accessToken);
+      }
+      return {
+        data: response,
+        error: null
+      };
+    } catch (error) {
+      if (error instanceof InsForgeError) {
+        return { data: null, error };
+      }
+      return {
+        data: null,
+        error: new InsForgeError(
+          "An unexpected error occurred while verifying email",
+          500,
+          "UNEXPECTED_ERROR"
+        )
+      };
+    }
   }
 };