@insforge/sdk 0.0.58-dev.0 → 0.0.58-dev.10

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { UserSchema, CreateUserRequest, CreateUserResponse, CreateSessionRequest, CreateSessionResponse, OAuthProvidersSchema, StorageFileSchema, ListObjectsResponseSchema, ChatCompletionRequest, ImageGenerationRequest } from '@insforge/shared-schemas';
+import { UserSchema, CreateUserRequest, CreateUserResponse, CreateSessionRequest, CreateSessionResponse, OAuthProvidersSchema, GetPublicAuthConfigResponse, UserIdSchema, EmailSchema, RoleSchema, StorageFileSchema, ListObjectsResponseSchema, ChatCompletionRequest, ImageGenerationRequest } from '@insforge/shared-schemas';
 export { AuthErrorResponse, CreateSessionRequest, CreateUserRequest, UserSchema } from '@insforge/shared-schemas';
 import * as _supabase_postgrest_js from '@supabase/postgrest-js';
 
@@ -106,6 +106,21 @@ declare class TokenManager {
  * Uses shared schemas for type safety
  */
 
+/**
+ * Dynamic profile type - represents flexible profile data from database
+ * Fields can vary based on database schema configuration.
+ * All fields are converted from snake_case (database) to camelCase (API)
+ */
+type ProfileData = Record<string, any> & {
+    id: string;
+    createdAt?: string;
+    updatedAt?: string;
+};
+/**
+ * Dynamic profile update type - for updating profile fields
+ * Supports any fields that exist in the profile table
+ */
+type UpdateProfileData = Partial<Record<string, any>>;
 declare class Auth {
     private http;
     private tokenManager;
@@ -151,23 +166,47 @@ declare class Auth {
     signOut(): Promise<{
         error: InsForgeError | null;
     }>;
+    /**
+     * 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 Complete public authentication configuration including OAuth providers and email auth settings
+     *
+     * @example
+     * ```ts
+     * const { data, error } = await insforge.auth.getPublicAuthConfig();
+     * if (data) {
+     *   console.log(`OAuth providers: ${data.oauth.data.length}`);
+     *   console.log(`Password min length: ${data.email.passwordMinLength}`);
+     * }
+     * ```
+     */
+    getPublicAuthConfig(): Promise<{
+        data: GetPublicAuthConfigResponse | null;
+        error: InsForgeError | null;
+    }>;
     /**
      * 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)
      */
     getCurrentUser(): Promise<{
         data: {
-            user: any;
-            profile: any;
+            user: {
+                id: UserIdSchema;
+                email: EmailSchema;
+                role: RoleSchema;
+            };
+            profile: ProfileData | null;
         } | null;
         error: any | null;
     }>;
     /**
      * 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)
      */
     getProfile(userId: string): Promise<{
-        data: any | null;
+        data: ProfileData | null;
         error: any | null;
     }>;
     /**
@@ -182,24 +221,19 @@ declare class Auth {
     };
     /**
      * Set/Update the current user's profile
-     * Updates profile information in the users table (nickname, avatar_url, bio, etc.)
-     */
-    setProfile(profile: {
-        nickname?: string;
-        avatar_url?: string;
-        bio?: string;
-        birthday?: string;
-        [key: string]: any;
-    }): Promise<{
-        data: any | null;
+     * Updates profile information in the users table (supports any dynamic fields)
+     */
+    setProfile(profile: UpdateProfileData): Promise<{
+        data: ProfileData | null;
         error: any | null;
     }>;
     /**
-     * Send email verification code or link
-     * @param type - 'code' for numeric OTP (6 digits) or 'link' for verification link
-     * @param email - Email address to send verification to
+     * Send password reset code to user's email
+     * Always returns success to prevent user enumeration
      */
-    sendEmailVerification(type: 'code' | 'link', email: string): Promise<{
+    sendPasswordResetCode(request: {
+        email: string;
+    }): Promise<{
         data: {
             success: boolean;
             message: string;
@@ -207,38 +241,39 @@ declare class Auth {
         error: InsForgeError | null;
     }>;
     /**
-     * Verify email with OTP
-     * @param otp - 6-digit numeric code (with email) or 64-char hex token (without email)
-     * @param email - Optional email address (required for code verification)
-     */
-    verifyEmail(otp: string, email?: string): Promise<{
-        data: CreateSessionResponse | null;
-        error: InsForgeError | null;
-    }>;
-    /**
-     * Send password reset code or link
-     * @param type - 'code' for numeric OTP (6 digits) or 'link' for reset link
-     * @param email - Email address to send reset instructions to
+     * Reset password with OTP token
+     * Token can be from magic link or from code verification
      */
-    sendResetPasswordEmail(type: 'code' | 'link', email: string): Promise<{
+    resetPassword(request: {
+        newPassword: string;
+        otp: string;
+    }): Promise<{
         data: {
-            success: boolean;
             message: string;
+            redirectTo?: string;
         } | null;
         error: InsForgeError | null;
     }>;
     /**
-     * Reset password with OTP
-     * @param otp - 6-digit numeric code (with email) or 64-char hex token (without email)
-     * @param newPassword - New password to set
-     * @param email - Optional email address (required for code-based reset)
+     * 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)
      */
-    resetPassword(otp: string, newPassword: string, email?: string): Promise<{
+    verifyEmail(request: {
+        email?: string;
+        otp: string;
+    }): Promise<{
         data: {
-            message: string;
+            accessToken: string;
+            user?: any;
         } | null;
         error: InsForgeError | null;
     }>;
+    /**
+     * Set the current session
+     * This is used to set the session from the OAuth callback
+     */
+    setSession(session: AuthSession): Promise<void>;
 }
 
 /**
@@ -572,4 +607,4 @@ declare class InsForgeClient {
 
 declare function createClient(config: InsForgeConfig): InsForgeClient;
 
-export { AI, type ApiError, Auth, type AuthSession, type InsForgeConfig as ClientOptions, Database, type FunctionInvokeOptions, Functions, HttpClient, InsForgeClient, type InsForgeConfig, InsForgeError, Storage, StorageBucket, type StorageResponse, TokenManager, type TokenStorage, createClient, InsForgeClient as default };
+export { AI, type ApiError, Auth, type AuthSession, type InsForgeConfig as ClientOptions, Database, type FunctionInvokeOptions, Functions, HttpClient, InsForgeClient, type InsForgeConfig, InsForgeError, type ProfileData, Storage, StorageBucket, type StorageResponse, TokenManager, type TokenStorage, type UpdateProfileData, createClient, InsForgeClient as default };

package/dist/index.js

@@ -292,6 +292,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;
@@ -381,11 +403,18 @@ var Auth = class {
     try {
       const response = await this.http.post("/api/auth/sessions", request);
       const session = {
-        accessToken: response.accessToken,
-        user: response.user
+        accessToken: response.accessToken || "",
+        user: response.user || {
+          id: "",
+          email: "",
+          name: "",
+          emailVerified: false,
+          createdAt: "",
+          updatedAt: ""
+        }
       };
       this.tokenManager.saveSession(session);
-      this.http.setAuthToken(response.accessToken);
+      this.http.setAuthToken(response.accessToken || "");
       return {
         data: response,
         error: null
@@ -456,9 +485,46 @@ var Auth = class {
       };
     }
   }
+  /**
+   * 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 Complete public authentication configuration including OAuth providers and email auth settings
+   * 
+   * @example
+   * ```ts
+   * const { data, error } = await insforge.auth.getPublicAuthConfig();
+   * if (data) {
+   *   console.log(`OAuth providers: ${data.oauth.data.length}`);
+   *   console.log(`Password min length: ${data.email.passwordMinLength}`);
+   * }
+   * ```
+   */
+  async getPublicAuthConfig() {
+    try {
+      const response = await this.http.get("/api/auth/public-config");
+      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 fetching public authentication configuration",
+          500,
+          "UNEXPECTED_ERROR"
+        )
+      };
+    }
+  }
   /**
    * 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 {
@@ -475,7 +541,7 @@ var Auth = class {
       return {
         data: {
           user: authResponse.user,
-          profile
+          profile: profile ? convertDbProfileToCamelCase(profile) : null
         },
         error: null
       };
@@ -499,14 +565,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)
@@ -536,7 +605,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();
@@ -556,23 +625,38 @@ var Auth = class {
         return { data: null, error: error2 };
       }
       if (data2?.user) {
-        session.user = data2.user;
+        session.user = {
+          id: data2.user.id,
+          email: data2.user.email,
+          name: data2.profile?.nickname || "",
+          // Fallback - profile structure is dynamic
+          emailVerified: false,
+          // Not available from API, but required by UserSchema
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // Fallback
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          // Fallback
+        };
         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 email verification code or link
-   * @param type - 'code' for numeric OTP (6 digits) or 'link' for verification link
-   * @param email - Email address to send verification to
+   * Send password reset code to user's email
+   * Always returns success to prevent user enumeration
    */
-  async sendEmailVerification(type, email) {
+  async sendPasswordResetCode(request) {
     try {
-      const request = { email };
-      const endpoint = type === "code" ? "/api/auth/email/send-verification-code" : "/api/auth/email/send-verification-link";
-      const response = await this.http.post(endpoint, request);
+      const response = await this.http.post(
+        "/api/auth/email/send-reset-password-code",
+        request
+      );
       return {
         data: response,
         error: null
@@ -584,7 +668,7 @@ var Auth = class {
       return {
         data: null,
         error: new InsForgeError(
-          "An unexpected error occurred while sending verification email",
+          "An unexpected error occurred while sending password reset code",
           500,
           "UNEXPECTED_ERROR"
         )
@@ -592,20 +676,15 @@ var Auth = class {
     }
   }
   /**
-   * Verify email with OTP
-   * @param otp - 6-digit numeric code (with email) or 64-char hex token (without email)
-   * @param email - Optional email address (required for code verification)
+   * Reset password with OTP token
+   * Token can be from magic link or from code verification
    */
-  async verifyEmail(otp, email) {
+  async resetPassword(request) {
     try {
-      const request = { otp, email };
-      const response = await this.http.post("/api/auth/verify-email", request);
-      const session = {
-        accessToken: response.accessToken,
-        user: response.user
-      };
-      this.tokenManager.saveSession(session);
-      this.http.setAuthToken(response.accessToken);
+      const response = await this.http.post(
+        "/api/auth/reset-password",
+        request
+      );
       return {
         data: response,
         error: null
@@ -617,7 +696,7 @@ var Auth = class {
       return {
         data: null,
         error: new InsForgeError(
-          "An unexpected error occurred while verifying email",
+          "An unexpected error occurred while resetting password",
           500,
           "UNEXPECTED_ERROR"
         )
@@ -625,15 +704,24 @@ var Auth = class {
     }
   }
   /**
-   * Send password reset code or link
-   * @param type - 'code' for numeric OTP (6 digits) or 'link' for reset link
-   * @param email - Email address to send reset instructions to
+   * 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 sendResetPasswordEmail(type, email) {
+  async verifyEmail(request) {
     try {
-      const request = { email };
-      const endpoint = type === "code" ? "/api/auth/email/send-reset-password-code" : "/api/auth/email/send-reset-password-link";
-      const response = await this.http.post(endpoint, request);
+      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
@@ -645,7 +733,7 @@ var Auth = class {
       return {
         data: null,
         error: new InsForgeError(
-          "An unexpected error occurred while sending reset password email",
+          "An unexpected error occurred while verifying email",
           500,
           "UNEXPECTED_ERROR"
         )
@@ -653,31 +741,19 @@ var Auth = class {
     }
   }
   /**
-   * Reset password with OTP
-   * @param otp - 6-digit numeric code (with email) or 64-char hex token (without email)
-   * @param newPassword - New password to set
-   * @param email - Optional email address (required for code-based reset)
+   * Set the current session
+   * This is used to set the session from the OAuth callback
    */
-  async resetPassword(otp, newPassword, email) {
+  async setSession(session) {
     try {
-      const request = { otp, newPassword, email };
-      const response = await this.http.post("/api/auth/reset-password", request);
-      return {
-        data: response,
-        error: null
-      };
+      this.tokenManager.saveSession(session);
+      this.http.setAuthToken(session.accessToken);
     } 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"
-        )
-      };
+      throw new InsForgeError(
+        "An unexpected error occurred while setting session",
+        500,
+        "UNEXPECTED_ERROR"
+      );
     }
   }
 };