@insforge/sdk 0.0.20 → 0.0.22

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import { UserSchema, CreateUserRequest, CreateUserResponse, CreateSessionRequest, CreateSessionResponse, StorageFileSchema, ListObjectsResponseSchema } from '@insforge/shared-schemas';
 export { AuthErrorResponse, CreateSessionRequest, CreateUserRequest, UserSchema } from '@insforge/shared-schemas';
+import * as _supabase_postgrest_js from '@supabase/postgrest-js';
 
 /**
  * InsForge SDK Types - only SDK-specific types here
@@ -151,7 +152,7 @@ declare class Auth {
             user: any;
             profile: any;
         } | null;
-        error: InsForgeError | null;
+        error: any | null;
     }>;
     /**
      * Get any user's profile by ID
@@ -159,7 +160,7 @@ declare class Auth {
      */
     getProfile(userId: string): Promise<{
         data: any | null;
-        error: InsForgeError | null;
+        error: any | null;
     }>;
     /**
      * Get the current session (only session data, no API call)
@@ -183,187 +184,53 @@ declare class Auth {
         [key: string]: any;
     }): Promise<{
         data: any | null;
-        error: InsForgeError | null;
+        error: any | null;
     }>;
 }
 
 /**
- * Database module for InsForge SDK
- * Supabase-style query builder for PostgREST operations
- */
-
-interface DatabaseResponse<T> {
-    data: T | null;
-    error: InsForgeError | null;
-    count?: number;
-}
-/**
- * Query builder for database operations
- * Uses method chaining like Supabase
- */
-declare class QueryBuilder<T = any> {
-    private table;
-    private http;
-    private method;
-    private headers;
-    private queryParams;
-    private body?;
-    constructor(table: string, http: HttpClient);
-    /**
-     * Perform a SELECT query
-     * For mutations (insert/update/delete), this enables returning data
-     * @param columns - Columns to select (default: '*')
-     * @example
-     * .select('*')
-     * .select('id, title, content')
-     * .select('*, users!inner(*)')  // Join with users table
-     * .select('*, profile:profiles(*)')  // Join with alias
-     * .insert({ title: 'New' }).select()  // Returns inserted data
-     */
-    select(columns?: string): this;
-    /**
-     * Perform an INSERT
-     * @param values - Single object or array of objects
-     * @param options - { upsert: true } for upsert behavior
-     * @example
-     * .insert({ title: 'Hello', content: 'World' }).select()
-     * .insert([{ title: 'Post 1' }, { title: 'Post 2' }]).select()
-     */
-    insert(values: Partial<T> | Partial<T>[], options?: {
-        upsert?: boolean;
-    }): this;
-    /**
-     * Perform an UPDATE
-     * @param values - Object with fields to update
-     * @example
-     * .update({ title: 'Updated Title' }).select()
-     */
-    update(values: Partial<T>): this;
-    /**
-     * Perform a DELETE
-     * @example
-     * .delete().select()
-     */
-    delete(): this;
-    /**
-     * Perform an UPSERT
-     * @param values - Single object or array of objects
-     * @example
-     * .upsert({ id: 1, title: 'Hello' })
-     */
-    upsert(values: Partial<T> | Partial<T>[]): this;
-    /**
-     * Filter by column equal to value
-     * @example .eq('id', 123)
-     */
-    eq(column: string, value: any): this;
-    /**
-     * Filter by column not equal to value
-     * @example .neq('status', 'draft')
-     */
-    neq(column: string, value: any): this;
-    /**
-     * Filter by column greater than value
-     * @example .gt('age', 18)
-     */
-    gt(column: string, value: any): this;
-    /**
-     * Filter by column greater than or equal to value
-     * @example .gte('price', 100)
-     */
-    gte(column: string, value: any): this;
-    /**
-     * Filter by column less than value
-     * @example .lt('stock', 10)
-     */
-    lt(column: string, value: any): this;
-    /**
-     * Filter by column less than or equal to value
-     * @example .lte('discount', 50)
-     */
-    lte(column: string, value: any): this;
-    /**
-     * Filter by pattern matching (case-sensitive)
-     * @example .like('email', '%@gmail.com')
-     */
-    like(column: string, pattern: string): this;
-    /**
-     * Filter by pattern matching (case-insensitive)
-     * @example .ilike('name', '%john%')
-     */
-    ilike(column: string, pattern: string): this;
-    /**
-     * Filter by checking if column is a value
-     * @example .is('deleted_at', null)
-     */
-    is(column: string, value: null | boolean): this;
-    /**
-     * Filter by checking if value is in array
-     * @example .in('status', ['active', 'pending'])
-     */
-    in(column: string, values: any[]): this;
-    /**
-     * Order by column
-     * @example
-     * .order('created_at')  // ascending
-     * .order('created_at', { ascending: false })  // descending
-     */
-    order(column: string, options?: {
-        ascending?: boolean;
-    }): this;
-    /**
-     * Limit the number of rows returned
-     * @example .limit(10)
-     */
-    limit(count: number): this;
-    /**
-     * Return results from an offset
-     * @example .offset(20)
-     */
-    offset(count: number): this;
-    /**
-     * Set a range of rows to return
-     * @example .range(0, 9)  // First 10 rows
-     */
-    range(from: number, to: number): this;
-    /**
-     * Return a single object instead of array
-     * @example .single()
-     */
-    single(): this;
-    /**
-     * Get the total count (use with select)
-     * @example .select('*', { count: 'exact' })
-     */
-    count(algorithm?: 'exact' | 'planned' | 'estimated'): this;
-    /**
-     * Execute the query and return results
-     */
-    execute(): Promise<DatabaseResponse<T>>;
-    /**
-     * Make QueryBuilder thenable for async/await
-     */
-    then<TResult1 = DatabaseResponse<T>, TResult2 = never>(onfulfilled?: ((value: DatabaseResponse<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
-}
-/**
- * Database client for InsForge SDK
- * Provides Supabase-style interface
+ * Database client using postgrest-js
+ * Drop-in replacement with FULL PostgREST capabilities
  */
 declare class Database {
-    private http;
-    constructor(http: HttpClient);
+    private postgrest;
+    constructor(httpClient: HttpClient, tokenManager: TokenManager);
     /**
      * Create a query builder for a table
-     * @param table - The table name
+     *
      * @example
+     * // Basic query
      * const { data, error } = await client.database
      *   .from('posts')
      *   .select('*')
-     *   .eq('user_id', userId)
-     *   .order('created_at', { ascending: false })
-     *   .limit(10);
-     */
-    from<T = any>(table: string): QueryBuilder<T>;
+     *   .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: string): _supabase_postgrest_js.PostgrestQueryBuilder<any, any, any, string, unknown>;
 }
 
 /**
@@ -441,6 +308,106 @@ declare class Storage {
     from(bucketName: string): StorageBucket;
 }
 
+/**
+ * AI Module for Insforge SDK
+ * Wrapper for AI endpoints that follows OpenAI-like patterns
+ *
+ * The backend handles all the complexity of different AI providers
+ * and returns a unified format. This SDK just calls the endpoints.
+ */
+
+declare class AI {
+    private http;
+    readonly chat: Chat;
+    readonly images: Images;
+    constructor(http: HttpClient);
+}
+declare class Chat {
+    readonly completions: ChatCompletions;
+    constructor(http: HttpClient);
+}
+declare class ChatCompletions {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a chat completion
+     *
+     * @example
+     * ```typescript
+     * // Non-streaming
+     * const response = await client.ai.chat.completions.create({
+     *   model: 'gpt-4',
+     *   messages: [{ role: 'user', content: 'Hello!' }]
+     * });
+     * console.log(response.response);
+     *
+     * // Streaming - returns async iterable
+     * const stream = await client.ai.chat.completions.create({
+     *   model: 'gpt-4',
+     *   messages: [{ role: 'user', content: 'Tell me a story' }],
+     *   stream: true
+     * });
+     *
+     * for await (const event of stream) {
+     *   if (event.chunk) {
+     *     process.stdout.write(event.chunk);
+     *   }
+     *   if (event.done) {
+     *     console.log('Stream complete!');
+     *   }
+     * }
+     * ```
+     */
+    create(params: {
+        model: string;
+        messages?: Array<{
+            role: 'user' | 'assistant' | 'system';
+            content: string;
+        }>;
+        message?: string;
+        temperature?: number;
+        maxTokens?: number;
+        topP?: number;
+        systemPrompt?: string;
+        stream?: boolean;
+    }): Promise<any>;
+    /**
+     * Parse SSE stream into async iterable of parsed events
+     * Users don't need to handle SSE parsing themselves
+     */
+    private parseSSEStream;
+}
+declare class Images {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Generate images
+     *
+     * @example
+     * ```typescript
+     * const response = await client.ai.images.generate({
+     *   model: 'dall-e-3',
+     *   prompt: 'A sunset over mountains',
+     *   numImages: 1,
+     *   size: '1024x1024'
+     * });
+     * console.log(response.images[0].url);
+     * ```
+     */
+    generate(params: {
+        model: string;
+        prompt: string;
+        negativePrompt?: string;
+        width?: number;
+        height?: number;
+        numImages?: number;
+        quality?: 'standard' | 'hd';
+        style?: 'vivid' | 'natural';
+        responseFormat?: 'url' | 'b64_json';
+        size?: string;
+    }): Promise<unknown>;
+}
+
 /**
  * Main InsForge SDK Client
  *
@@ -480,19 +447,8 @@ declare class InsForgeClient {
     readonly auth: Auth;
     readonly database: Database;
     readonly storage: Storage;
+    readonly ai: AI;
     constructor(config?: InsForgeConfig);
-    /**
-     * Set a custom API key for authentication
-     * This is useful for server-to-server communication
-     *
-     * @param apiKey - The API key (should start with 'ik_')
-     *
-     * @example
-     * ```typescript
-     * client.setApiKey('ik_your_api_key_here');
-     * ```
-     */
-    setApiKey(apiKey: string): void;
     /**
      * Get the underlying HTTP client for custom requests
      *
@@ -513,4 +469,4 @@ declare class InsForgeClient {
 
 declare function createClient(config: InsForgeConfig): InsForgeClient;
 
-export { type ApiError, Auth, type AuthSession, type InsForgeConfig as ClientOptions, Database, type DatabaseResponse, HttpClient, InsForgeClient, type InsForgeConfig, InsForgeError, QueryBuilder, Storage, StorageBucket, type StorageResponse, TokenManager, type TokenStorage, createClient, InsForgeClient as default };
+export { AI, type ApiError, Auth, type AuthSession, type InsForgeConfig as ClientOptions, Database, HttpClient, InsForgeClient, type InsForgeConfig, InsForgeError, Storage, StorageBucket, type StorageResponse, TokenManager, type TokenStorage, createClient, InsForgeClient as default };