@insforge/sdk 1.0.3-refresh.1 → 1.0.5-dev.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { UserSchema, CreateUserRequest, CreateUserResponse, CreateSessionRequest, CreateSessionResponse, OAuthProvidersSchema, GetPublicAuthConfigResponse, UserIdSchema, EmailSchema, RoleSchema, SendVerificationEmailRequest, SendResetPasswordEmailRequest, ExchangeResetPasswordTokenRequest, VerifyEmailRequest, VerifyEmailResponse, StorageFileSchema, ListObjectsResponseSchema, ChatCompletionRequest, ImageGenerationRequest, SubscribeResponse, SocketMessage } from '@insforge/shared-schemas';
-export { AuthErrorResponse, CreateSessionRequest, CreateUserRequest, RealtimeErrorPayload, SocketMessage, SubscribeResponse, UserSchema } from '@insforge/shared-schemas';
+import { UserSchema, CreateUserRequest, CreateUserResponse, CreateSessionRequest, CreateSessionResponse, OAuthProvidersSchema, GetPublicAuthConfigResponse, GetProfileResponse, SendVerificationEmailRequest, SendResetPasswordEmailRequest, ExchangeResetPasswordTokenRequest, VerifyEmailRequest, VerifyEmailResponse, StorageFileSchema, ListObjectsResponseSchema, ChatCompletionRequest, ImageGenerationRequest, SubscribeResponse, SocketMessage, SendRawEmailRequest, SendEmailResponse } from '@insforge/shared-schemas';
+export { AuthErrorResponse, CreateSessionRequest, CreateUserRequest, RealtimeErrorPayload, SendRawEmailRequest as SendEmailOptions, SendEmailResponse, SocketMessage, SubscribeResponse, UserSchema } from '@insforge/shared-schemas';
 import * as _supabase_postgrest_js from '@supabase/postgrest-js';
 
 /**
@@ -162,29 +162,13 @@ 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;
-    private database;
     constructor(http: HttpClient, tokenManager: TokenManager);
     /**
      * Automatically detect and handle OAuth callback parameters in the URL
-     * This runs on initialization to seamlessly complete the OAuth flow
+     * This runs after initialization to seamlessly complete the OAuth flow
      * Matches the backend's OAuth callback response (backend/src/api/routes/auth.ts:540-544)
      */
     private detectAuthCallback;
@@ -248,22 +232,17 @@ declare class Auth {
      */
     getCurrentUser(): Promise<{
         data: {
-            user: {
-                id: UserIdSchema;
-                email: EmailSchema;
-                role: RoleSchema;
-            };
-            profile: ProfileData | null;
+            user: UserSchema;
         } | null;
         error: any | null;
     }>;
     /**
      * Get any user's profile by ID
-     * Returns profile information from the users table (dynamic fields)
+     * Returns profile information from the users table
      */
     getProfile(userId: string): Promise<{
-        data: ProfileData | null;
-        error: any | null;
+        data: GetProfileResponse | null;
+        error: InsForgeError | null;
     }>;
     /**
      * Get the current session (only session data, no API call)
@@ -278,10 +257,11 @@ declare class Auth {
     /**
      * Set/Update the current user's profile
      * Updates profile information in the users table (supports any dynamic fields)
+     * Requires authentication
      */
-    setProfile(profile: UpdateProfileData): Promise<{
-        data: ProfileData | null;
-        error: any | null;
+    setProfile(profile: Record<string, unknown>): Promise<{
+        data: GetProfileResponse | null;
+        error: InsForgeError | null;
     }>;
     /**
      * Send email verification (code or link based on config)
@@ -678,7 +658,8 @@ declare class Realtime {
     private connectPromise;
     private subscribedChannels;
     private eventListeners;
-    constructor(baseUrl: string, tokenManager: TokenManager);
+    private anonKey?;
+    constructor(baseUrl: string, tokenManager: TokenManager, anonKey?: string);
     private notifyListeners;
     /**
      * Connect to the realtime server
@@ -761,6 +742,47 @@ declare class Realtime {
     getSubscribedChannels(): string[];
 }
 
+/**
+ * Emails client for sending custom emails
+ *
+ * @example
+ * ```typescript
+ * // Send a simple email
+ * const { data, error } = await client.emails.send({
+ *   to: 'user@example.com',
+ *   subject: 'Welcome!',
+ *   html: '<h1>Welcome to our platform</h1>'
+ * });
+ *
+ * if (error) {
+ *   console.error('Failed to send:', error.message);
+ *   return;
+ * }
+ * // Email sent successfully - data is {} (empty object)
+ *
+ * // Send to multiple recipients with CC
+ * const { data, error } = await client.emails.send({
+ *   to: ['user1@example.com', 'user2@example.com'],
+ *   cc: 'manager@example.com',
+ *   subject: 'Team Update',
+ *   html: '<p>Here is the latest update...</p>',
+ *   replyTo: 'support@example.com'
+ * });
+ * ```
+ */
+declare class Emails {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Send a custom HTML email
+     * @param options Email options including recipients, subject, and HTML content
+     */
+    send(options: SendRawEmailRequest): Promise<{
+        data: SendEmailResponse | null;
+        error: Error | null;
+    }>;
+}
+
 /**
  * Main InsForge SDK Client
  *
@@ -808,6 +830,7 @@ declare class InsForgeClient {
     readonly ai: AI;
     readonly functions: Functions;
     readonly realtime: Realtime;
+    readonly emails: Emails;
     constructor(config?: InsForgeConfig);
     /**
      * Get the underlying HTTP client for custom requests
@@ -829,4 +852,4 @@ declare class InsForgeClient {
 
 declare function createClient(config: InsForgeConfig): InsForgeClient;
 
-export { AI, type ApiError, Auth, type AuthSession, type InsForgeConfig as ClientOptions, type ConnectionState, Database, type EventCallback, type FunctionInvokeOptions, Functions, HttpClient, InsForgeClient, type InsForgeConfig, InsForgeError, type ProfileData, Realtime, Storage, StorageBucket, type StorageResponse, TokenManager, type TokenStorage, type UpdateProfileData, createClient, InsForgeClient as default };
+export { AI, type ApiError, Auth, type AuthSession, type InsForgeConfig as ClientOptions, type ConnectionState, Database, Emails, type EventCallback, type FunctionInvokeOptions, Functions, HttpClient, InsForgeClient, type InsForgeConfig, InsForgeError, Realtime, Storage, StorageBucket, type StorageResponse, TokenManager, type TokenStorage, createClient, InsForgeClient as default };

package/dist/index.js

@@ -23,6 +23,7 @@ __export(index_exports, {
   AI: () => AI,
   Auth: () => Auth,
   Database: () => Database,
+  Emails: () => Emails,
   Functions: () => Functions,
   HttpClient: () => HttpClient,
   InsForgeClient: () => InsForgeClient,
@@ -328,98 +329,7 @@ var TokenManager = class {
   }
 };
 
-// src/modules/database-postgrest.ts
-var import_postgrest_js = require("@supabase/postgrest-js");
-function createInsForgePostgrestFetch(httpClient, tokenManager) {
-  return async (input, init) => {
-    const url = typeof input === "string" ? input : input.toString();
-    const urlObj = new URL(url);
-    const tableName = urlObj.pathname.slice(1);
-    const insforgeUrl = `${httpClient.baseUrl}/api/database/records/${tableName}${urlObj.search}`;
-    const token = tokenManager.getAccessToken();
-    const httpHeaders = httpClient.getHeaders();
-    const authToken = token || httpHeaders["Authorization"]?.replace("Bearer ", "");
-    const headers = new Headers(init?.headers);
-    if (authToken && !headers.has("Authorization")) {
-      headers.set("Authorization", `Bearer ${authToken}`);
-    }
-    const response = await fetch(insforgeUrl, {
-      ...init,
-      headers
-    });
-    return response;
-  };
-}
-var Database = class {
-  constructor(httpClient, tokenManager) {
-    this.postgrest = new import_postgrest_js.PostgrestClient("http://dummy", {
-      fetch: createInsForgePostgrestFetch(httpClient, tokenManager),
-      headers: {}
-    });
-  }
-  /**
-   * Create a query builder for a table
-   * 
-   * @example
-   * // Basic query
-   * const { data, error } = await client.database
-   *   .from('posts')
-   *   .select('*')
-   *   .eq('user_id', userId);
-   * 
-   * // With count (Supabase style!)
-   * const { data, error, count } = await client.database
-   *   .from('posts')
-   *   .select('*', { count: 'exact' })
-   *   .range(0, 9);
-   * 
-   * // Just get count, no data
-   * const { count } = await client.database
-   *   .from('posts')
-   *   .select('*', { count: 'exact', head: true });
-   * 
-   * // Complex queries with OR
-   * const { data } = await client.database
-   *   .from('posts')
-   *   .select('*, users!inner(*)')
-   *   .or('status.eq.active,status.eq.pending');
-   * 
-   * // All features work:
-   * - Nested selects
-   * - Foreign key expansion  
-   * - OR/AND/NOT conditions
-   * - Count with head
-   * - Range pagination
-   * - Upserts
-   */
-  from(table) {
-    return this.postgrest.from(table);
-  }
-};
-
 // src/modules/auth.ts
-function convertDbProfileToCamelCase(dbProfile) {
-  const result = {
-    id: dbProfile.id
-  };
-  Object.keys(dbProfile).forEach((key) => {
-    result[key] = dbProfile[key];
-    if (key.includes("_")) {
-      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;
-}
 function isHostedAuthEnvironment() {
   if (typeof window === "undefined") {
     return false;
@@ -437,12 +347,11 @@ var Auth = class {
   constructor(http, tokenManager) {
     this.http = http;
     this.tokenManager = tokenManager;
-    this.database = new Database(http, tokenManager);
     this.detectAuthCallback();
   }
   /**
    * Automatically detect and handle OAuth callback parameters in the URL
-   * This runs on initialization to seamlessly complete the OAuth flow
+   * This runs after initialization to seamlessly complete the OAuth flow
    * Matches the backend's OAuth callback response (backend/src/api/routes/auth.ts:540-544)
    */
   detectAuthCallback() {
@@ -464,7 +373,8 @@ var Auth = class {
           user: {
             id: userId,
             email,
-            name: name || "",
+            profile: { name: name || "" },
+            metadata: null,
             // These fields are not provided by backend OAuth callback
             // They'll be populated when calling getCurrentUser()
             emailVerified: false,
@@ -659,20 +569,19 @@ var Auth = class {
    */
   async getCurrentUser() {
     try {
-      const session = this.tokenManager.getSession();
-      if (!session?.accessToken) {
+      const user = this.tokenManager.getUser();
+      if (user) {
+        return { data: { user }, error: null };
+      }
+      const accessToken = this.tokenManager.getAccessToken();
+      if (!accessToken) {
         return { data: null, error: null };
       }
-      this.http.setAuthToken(session.accessToken);
+      this.http.setAuthToken(accessToken);
       const authResponse = await this.http.get("/api/auth/sessions/current");
-      const { data: profile, error: profileError } = await this.database.from("users").select("*").eq("id", authResponse.user.id).single();
-      if (profileError && profileError.code !== "PGRST116") {
-        return { data: null, error: profileError };
-      }
       return {
         data: {
-          user: authResponse.user,
-          profile: profile ? convertDbProfileToCamelCase(profile) : null
+          user: authResponse.user
         },
         error: null
       };
@@ -696,17 +605,28 @@ var Auth = class {
   }
   /**
    * Get any user's profile by ID
-   * Returns profile information from the users table (dynamic fields)
+   * Returns profile information from the users table
    */
   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 };
-    }
-    if (data) {
-      return { data: convertDbProfileToCamelCase(data), error: null };
+    try {
+      const response = await this.http.get(`/api/auth/profiles/${userId}`);
+      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 user profile",
+          500,
+          "UNEXPECTED_ERROR"
+        )
+      };
     }
-    return { data: null, error };
   }
   /**
    * Get the current session (only session data, no API call)
@@ -777,42 +697,31 @@ var Auth = class {
   /**
    * Set/Update the current user's profile
    * Updates profile information in the users table (supports any dynamic fields)
+   * Requires authentication
    */
   async setProfile(profile) {
-    const session = this.tokenManager.getSession();
-    if (!session?.accessToken) {
+    try {
+      const response = await this.http.patch(
+        "/api/auth/profiles/current",
+        { profile }
+      );
+      return {
+        data: response,
+        error: null
+      };
+    } catch (error) {
+      if (error instanceof InsForgeError) {
+        return { data: null, error };
+      }
       return {
         data: null,
         error: new InsForgeError(
-          "No authenticated user found",
-          401,
-          "UNAUTHENTICATED"
+          "An unexpected error occurred while updating user profile",
+          500,
+          "UNEXPECTED_ERROR"
         )
       };
     }
-    if (!session.user?.id) {
-      const { data: data2, error: error2 } = await this.getCurrentUser();
-      if (error2) {
-        return { data: null, error: error2 };
-      }
-      if (data2?.user) {
-        session.user = {
-          id: data2.user.id,
-          email: data2.user.email,
-          name: "",
-          emailVerified: false,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        this.tokenManager.saveSession(session);
-      }
-    }
-    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 based on config)
@@ -997,6 +906,75 @@ var Auth = class {
   }
 };
 
+// src/modules/database-postgrest.ts
+var import_postgrest_js = require("@supabase/postgrest-js");
+function createInsForgePostgrestFetch(httpClient, tokenManager) {
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input.toString();
+    const urlObj = new URL(url);
+    const tableName = urlObj.pathname.slice(1);
+    const insforgeUrl = `${httpClient.baseUrl}/api/database/records/${tableName}${urlObj.search}`;
+    const token = tokenManager.getAccessToken();
+    const httpHeaders = httpClient.getHeaders();
+    const authToken = token || httpHeaders["Authorization"]?.replace("Bearer ", "");
+    const headers = new Headers(init?.headers);
+    if (authToken && !headers.has("Authorization")) {
+      headers.set("Authorization", `Bearer ${authToken}`);
+    }
+    const response = await fetch(insforgeUrl, {
+      ...init,
+      headers
+    });
+    return response;
+  };
+}
+var Database = class {
+  constructor(httpClient, tokenManager) {
+    this.postgrest = new import_postgrest_js.PostgrestClient("http://dummy", {
+      fetch: createInsForgePostgrestFetch(httpClient, tokenManager),
+      headers: {}
+    });
+  }
+  /**
+   * Create a query builder for a table
+   * 
+   * @example
+   * // Basic query
+   * const { data, error } = await client.database
+   *   .from('posts')
+   *   .select('*')
+   *   .eq('user_id', userId);
+   * 
+   * // With count (Supabase style!)
+   * const { data, error, count } = await client.database
+   *   .from('posts')
+   *   .select('*', { count: 'exact' })
+   *   .range(0, 9);
+   * 
+   * // Just get count, no data
+   * const { count } = await client.database
+   *   .from('posts')
+   *   .select('*', { count: 'exact', head: true });
+   * 
+   * // Complex queries with OR
+   * const { data } = await client.database
+   *   .from('posts')
+   *   .select('*, users!inner(*)')
+   *   .or('status.eq.active,status.eq.pending');
+   * 
+   * // All features work:
+   * - Nested selects
+   * - Foreign key expansion  
+   * - OR/AND/NOT conditions
+   * - Count with head
+   * - Range pagination
+   * - Upserts
+   */
+  from(table) {
+    return this.postgrest.from(table);
+  }
+};
+
 // src/modules/storage.ts
 var StorageBucket = class {
   constructor(bucketName, http) {
@@ -1522,13 +1500,14 @@ var Functions = class {
 var import_socket = require("socket.io-client");
 var CONNECT_TIMEOUT = 1e4;
 var Realtime = class {
-  constructor(baseUrl, tokenManager) {
+  constructor(baseUrl, tokenManager, anonKey) {
     this.socket = null;
     this.connectPromise = null;
     this.subscribedChannels = /* @__PURE__ */ new Set();
     this.eventListeners = /* @__PURE__ */ new Map();
     this.baseUrl = baseUrl;
     this.tokenManager = tokenManager;
+    this.anonKey = anonKey;
   }
   notifyListeners(event, payload) {
     const listeners = this.eventListeners.get(event);
@@ -1554,7 +1533,7 @@ var Realtime = class {
     }
     this.connectPromise = new Promise((resolve, reject) => {
       const session = this.tokenManager.getSession();
-      const token = session?.accessToken;
+      const token = session?.accessToken ?? this.anonKey;
       this.socket = (0, import_socket.io)(this.baseUrl, {
         transports: ["websocket"],
         auth: token ? { token } : void 0
@@ -1751,6 +1730,29 @@ var Realtime = class {
   }
 };
 
+// src/modules/email.ts
+var Emails = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Send a custom HTML email
+   * @param options Email options including recipients, subject, and HTML content
+   */
+  async send(options) {
+    try {
+      const data = await this.http.post(
+        "/api/email/send-raw",
+        options
+      );
+      return { data, error: null };
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      return { data: null, error: normalizedError };
+    }
+  }
+};
+
 // src/client.ts
 var InsForgeClient = class {
   constructor(config = {}) {
@@ -1773,7 +1775,8 @@ var InsForgeClient = class {
     this.storage = new Storage(this.http);
     this.ai = new AI(this.http);
     this.functions = new Functions(this.http);
-    this.realtime = new Realtime(this.http.baseUrl, this.tokenManager);
+    this.realtime = new Realtime(this.http.baseUrl, this.tokenManager, config.anonKey);
+    this.emails = new Emails(this.http);
   }
   /**
    * Get the underlying HTTP client for custom requests
@@ -1807,6 +1810,7 @@ var index_default = InsForgeClient;
   AI,
   Auth,
   Database,
+  Emails,
   Functions,
   HttpClient,
   InsForgeClient,