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

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, PublicOAuthProvider, GetPublicEmailAuthConfigResponse, UserIdSchema, EmailSchema, RoleSchema, ProfileSchema, UpdateProfileSchema, 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';
 
@@ -151,14 +151,59 @@ declare class Auth {
     signOut(): Promise<{
         error: InsForgeError | null;
     }>;
+    /**
+     * Get list of available OAuth providers
+     * Returns the list of OAuth providers configured on the backend
+     * This is a public endpoint that doesn't require authentication
+     *
+     * @returns Array of configured OAuth providers with their configuration status
+     *
+     * @example
+     * ```ts
+     * const { data, error } = await insforge.auth.getOAuthProviders();
+     * if (data) {
+     *   // data is an array of PublicOAuthProvider: [{ provider: 'google', isConfigured: true }, ...]
+     *   data.forEach(p => console.log(`${p.provider}: ${p.isConfigured ? 'configured' : 'not configured'}`));
+     * }
+     * ```
+     */
+    getOAuthProviders(): Promise<{
+        data: PublicOAuthProvider[] | null;
+        error: InsForgeError | null;
+    }>;
+    /**
+     * 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}`);
+     * }
+     * ```
+     */
+    getEmailAuthConfig(): Promise<{
+        data: GetPublicEmailAuthConfigResponse | 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.)
      */
     getCurrentUser(): Promise<{
         data: {
-            user: any;
-            profile: any;
+            user: {
+                id: UserIdSchema;
+                email: EmailSchema;
+                role: RoleSchema;
+            };
+            profile: ProfileSchema | null;
         } | null;
         error: any | null;
     }>;
@@ -167,7 +212,7 @@ declare class Auth {
      * Returns profile information from the users table (nickname, avatar_url, bio, etc.)
      */
     getProfile(userId: string): Promise<{
-        data: any | null;
+        data: ProfileSchema | null;
         error: any | null;
     }>;
     /**
@@ -184,61 +229,10 @@ 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;
+    setProfile(profile: UpdateProfileSchema): Promise<{
+        data: ProfileSchema | 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
-     */
-    sendEmailVerification(type: 'code' | 'link', email: string): Promise<{
-        data: {
-            success: boolean;
-            message: string;
-        } | null;
-        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
-     */
-    sendResetPasswordEmail(type: 'code' | 'link', email: string): Promise<{
-        data: {
-            success: boolean;
-            message: 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)
-     */
-    resetPassword(otp: string, newPassword: string, email?: string): Promise<{
-        data: {
-            message: string;
-        } | null;
-        error: InsForgeError | null;
-    }>;
 }
 
 /**

package/dist/index.js

@@ -381,11 +381,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,6 +463,81 @@ var Auth = class {
       };
     }
   }
+  /**
+   * Get list of available OAuth providers
+   * Returns the list of OAuth providers configured on the backend
+   * This is a public endpoint that doesn't require authentication
+   * 
+   * @returns Array of configured OAuth providers with their configuration status
+   * 
+   * @example
+   * ```ts
+   * const { data, error } = await insforge.auth.getOAuthProviders();
+   * if (data) {
+   *   // data is an array of PublicOAuthProvider: [{ provider: 'google', isConfigured: true }, ...]
+   *   data.forEach(p => console.log(`${p.provider}: ${p.isConfigured ? 'configured' : 'not configured'}`));
+   * }
+   * ```
+   */
+  async getOAuthProviders() {
+    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");
+      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 email 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.)
@@ -556,130 +638,24 @@ 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 || "",
+          // Not available from API, but required by UserSchema
+          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 };
   }
-  /**
-   * 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
-   */
-  async sendEmailVerification(type, email) {
-    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);
-      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 verification email",
-          500,
-          "UNEXPECTED_ERROR"
-        )
-      };
-    }
-  }
-  /**
-   * 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)
-   */
-  async verifyEmail(otp, email) {
-    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);
-      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"
-        )
-      };
-    }
-  }
-  /**
-   * 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
-   */
-  async sendResetPasswordEmail(type, email) {
-    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);
-      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 reset password email",
-          500,
-          "UNEXPECTED_ERROR"
-        )
-      };
-    }
-  }
-  /**
-   * 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)
-   */
-  async resetPassword(otp, newPassword, email) {
-    try {
-      const request = { otp, newPassword, email };
-      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"
-        )
-      };
-    }
-  }
 };
 
 // src/modules/storage.ts