@insforge/sdk 0.0.20 → 0.0.22

package/dist/index.js

@@ -20,12 +20,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AI: () => AI,
   Auth: () => Auth,
   Database: () => Database,
   HttpClient: () => HttpClient,
   InsForgeClient: () => InsForgeClient,
   InsForgeError: () => InsForgeError,
-  QueryBuilder: () => QueryBuilder,
   Storage: () => Storage,
   StorageBucket: () => StorageBucket,
   TokenManager: () => TokenManager,
@@ -61,9 +61,6 @@ var HttpClient = class {
     this.defaultHeaders = {
       ...config.headers
     };
-    if (config.apiKey) {
-      this.defaultHeaders["Authorization"] = `Bearer ${config.apiKey}`;
-    }
     if (!this.fetch) {
       throw new Error(
         "Fetch is not available. Please provide a fetch implementation in the config."
@@ -208,294 +205,70 @@ var TokenManager = class {
   }
 };
 
-// src/modules/database.ts
-var QueryBuilder = class {
-  constructor(table, http) {
-    this.table = table;
-    this.http = http;
-    this.method = "GET";
-    this.headers = {};
-    this.queryParams = {};
-  }
-  /**
-   * 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 = "*") {
-    if (this.method !== "GET") {
-      const existingPrefer = this.headers["Prefer"] || "";
-      const preferParts = existingPrefer ? [existingPrefer] : [];
-      if (!preferParts.some((p) => p.includes("return="))) {
-        preferParts.push("return=representation");
-      }
-      this.headers["Prefer"] = preferParts.join(",");
-    }
-    if (this.method === "GET" && columns) {
-      this.queryParams.select = columns;
-    } else if (columns !== "*") {
-      this.queryParams.select = columns;
-    }
-    return 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, options) {
-    this.method = "POST";
-    this.body = Array.isArray(values) ? values : [values];
-    if (options?.upsert) {
-      this.headers["Prefer"] = "resolution=merge-duplicates";
-    }
-    return this;
-  }
-  /**
-   * Perform an UPDATE
-   * @param values - Object with fields to update
-   * @example
-   * .update({ title: 'Updated Title' }).select()
-   */
-  update(values) {
-    this.method = "PATCH";
-    this.body = values;
-    return this;
-  }
-  /**
-   * Perform a DELETE
-   * @example
-   * .delete().select()
-   */
-  delete() {
-    this.method = "DELETE";
-    return this;
-  }
-  /**
-   * Perform an UPSERT
-   * @param values - Single object or array of objects
-   * @example
-   * .upsert({ id: 1, title: 'Hello' })
-   */
-  upsert(values) {
-    return this.insert(values, { upsert: true });
-  }
-  // FILTERS
-  /**
-   * Filter by column equal to value
-   * @example .eq('id', 123)
-   */
-  eq(column, value) {
-    this.queryParams[column] = `eq.${value}`;
-    return this;
-  }
-  /**
-   * Filter by column not equal to value
-   * @example .neq('status', 'draft')
-   */
-  neq(column, value) {
-    this.queryParams[column] = `neq.${value}`;
-    return this;
-  }
-  /**
-   * Filter by column greater than value
-   * @example .gt('age', 18)
-   */
-  gt(column, value) {
-    this.queryParams[column] = `gt.${value}`;
-    return this;
-  }
-  /**
-   * Filter by column greater than or equal to value
-   * @example .gte('price', 100)
-   */
-  gte(column, value) {
-    this.queryParams[column] = `gte.${value}`;
-    return this;
-  }
-  /**
-   * Filter by column less than value
-   * @example .lt('stock', 10)
-   */
-  lt(column, value) {
-    this.queryParams[column] = `lt.${value}`;
-    return this;
-  }
-  /**
-   * Filter by column less than or equal to value
-   * @example .lte('discount', 50)
-   */
-  lte(column, value) {
-    this.queryParams[column] = `lte.${value}`;
-    return this;
-  }
-  /**
-   * Filter by pattern matching (case-sensitive)
-   * @example .like('email', '%@gmail.com')
-   */
-  like(column, pattern) {
-    this.queryParams[column] = `like.${pattern}`;
-    return this;
-  }
-  /**
-   * Filter by pattern matching (case-insensitive)
-   * @example .ilike('name', '%john%')
-   */
-  ilike(column, pattern) {
-    this.queryParams[column] = `ilike.${pattern}`;
-    return this;
-  }
-  /**
-   * Filter by checking if column is a value
-   * @example .is('deleted_at', null)
-   */
-  is(column, value) {
-    if (value === null) {
-      this.queryParams[column] = "is.null";
-    } else {
-      this.queryParams[column] = `is.${value}`;
-    }
-    return this;
-  }
-  /**
-   * Filter by checking if value is in array
-   * @example .in('status', ['active', 'pending'])
-   */
-  in(column, values) {
-    this.queryParams[column] = `in.(${values.join(",")})`;
-    return this;
-  }
-  // MODIFIERS
-  /**
-   * Order by column
-   * @example 
-   * .order('created_at')  // ascending
-   * .order('created_at', { ascending: false })  // descending
-   */
-  order(column, options) {
-    const ascending = options?.ascending !== false;
-    this.queryParams.order = ascending ? column : `${column}.desc`;
-    return this;
-  }
-  /**
-   * Limit the number of rows returned
-   * @example .limit(10)
-   */
-  limit(count) {
-    this.queryParams.limit = count.toString();
-    return this;
-  }
-  /**
-   * Return results from an offset
-   * @example .offset(20)
-   */
-  offset(count) {
-    this.queryParams.offset = count.toString();
-    return this;
-  }
-  /**
-   * Set a range of rows to return
-   * @example .range(0, 9)  // First 10 rows
-   */
-  range(from, to) {
-    this.headers["Range"] = `${from}-${to}`;
-    return this;
-  }
-  /**
-   * Return a single object instead of array
-   * @example .single()
-   */
-  single() {
-    this.headers["Accept"] = "application/vnd.pgrst.object+json";
-    return this;
-  }
-  /**
-   * Get the total count (use with select)
-   * @example .select('*', { count: 'exact' })
-   */
-  count(algorithm = "exact") {
-    const prefer = this.headers["Prefer"] || "";
-    this.headers["Prefer"] = prefer ? `${prefer},count=${algorithm}` : `count=${algorithm}`;
-    return this;
-  }
-  /**
-   * Execute the query and return results
-   */
-  async execute() {
-    try {
-      const path = `/api/database/records/${this.table}`;
-      let response;
-      switch (this.method) {
-        case "GET":
-          response = await this.http.get(path, {
-            params: this.queryParams,
-            headers: this.headers
-          });
-          break;
-        case "POST":
-          response = await this.http.post(path, this.body, {
-            params: this.queryParams,
-            headers: this.headers
-          });
-          break;
-        case "PATCH":
-          response = await this.http.patch(path, this.body, {
-            params: this.queryParams,
-            headers: this.headers
-          });
-          break;
-        case "DELETE":
-          response = await this.http.delete(path, {
-            params: this.queryParams,
-            headers: this.headers
-          });
-          break;
-      }
-      return { data: response, error: null };
-    } catch (error) {
-      return {
-        data: null,
-        error: error instanceof InsForgeError ? error : new InsForgeError(
-          "Database operation failed",
-          500,
-          "DATABASE_ERROR"
-        )
-      };
+// 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 headers = new Headers(init?.headers);
+    if (token && !headers.has("Authorization")) {
+      headers.set("Authorization", `Bearer ${token}`);
     }
-  }
-  /**
-   * Make QueryBuilder thenable for async/await
-   */
-  then(onfulfilled, onrejected) {
-    return this.execute().then(onfulfilled, onrejected);
-  }
-};
+    const response = await fetch(insforgeUrl, {
+      ...init,
+      headers
+    });
+    return response;
+  };
+}
 var Database = class {
-  constructor(http) {
-    this.http = http;
+  constructor(httpClient, tokenManager) {
+    this.postgrest = new import_postgrest_js.PostgrestClient("http://dummy", {
+      fetch: createInsForgePostgrestFetch(httpClient, tokenManager),
+      headers: {}
+    });
   }
   /**
    * 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);
+   *   .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 new QueryBuilder(table, this.http);
+    return this.postgrest.from(table);
   }
 };
 
@@ -504,7 +277,7 @@ var Auth = class {
   constructor(http, tokenManager) {
     this.http = http;
     this.tokenManager = tokenManager;
-    this.database = new Database(http);
+    this.database = new Database(http, tokenManager);
     this.detectOAuthCallback();
   }
   /**
@@ -675,7 +448,7 @@ var Auth = class {
       this.http.setAuthToken(session.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.statusCode !== 406) {
+      if (profileError && profileError.code !== "PGRST116") {
         return { data: null, error: profileError };
       }
       return {
@@ -709,7 +482,7 @@ var Auth = class {
    */
   async getProfile(userId) {
     const { data, error } = await this.database.from("users").select("*").eq("id", userId).single();
-    if (error && error.statusCode === 406) {
+    if (error && error.code === "PGRST116") {
       return { data: null, error: null };
     }
     return { data, error };
@@ -756,7 +529,8 @@ var Auth = class {
         )
       };
     }
-    return await this.database.from("users").update(profile).eq("id", session.user.id).select().single();
+    const { data, error } = await this.database.from("users").update(profile).eq("id", session.user.id).select().single();
+    return { data, error };
   }
 };
 
@@ -936,6 +710,133 @@ var Storage = class {
   }
 };
 
+// src/modules/ai.ts
+var AI = class {
+  constructor(http) {
+    this.http = http;
+    this.chat = new Chat(http);
+    this.images = new Images(http);
+  }
+};
+var Chat = class {
+  constructor(http) {
+    this.completions = new ChatCompletions(http);
+  }
+};
+var ChatCompletions = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 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!');
+   *   }
+   * }
+   * ```
+   */
+  async create(params) {
+    if (params.stream) {
+      const headers = this.http.getHeaders();
+      headers["Content-Type"] = "application/json";
+      const response = await this.http.fetch(
+        `${this.http.baseUrl}/api/ai/chat/completion`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify(params)
+        }
+      );
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error || "Stream request failed");
+      }
+      return this.parseSSEStream(response);
+    }
+    return this.http.post("/api/ai/chat/completion", params);
+  }
+  /**
+   * Parse SSE stream into async iterable of parsed events
+   * Users don't need to handle SSE parsing themselves
+   */
+  async *parseSSEStream(response) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const dataStr = line.slice(6).trim();
+            if (dataStr) {
+              try {
+                const data = JSON.parse(dataStr);
+                yield data;
+                if (data.done) {
+                  reader.releaseLock();
+                  return;
+                }
+              } catch (e) {
+                console.warn("Failed to parse SSE data:", dataStr);
+              }
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+var Images = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 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);
+   * ```
+   */
+  async generate(params) {
+    return this.http.post("/api/ai/image/generation", params);
+  }
+};
+
 // src/client.ts
 var InsForgeClient = class {
   constructor(config = {}) {
@@ -945,22 +846,9 @@ var InsForgeClient = class {
       this.http,
       this.tokenManager
     );
-    this.database = new Database(this.http);
+    this.database = new Database(this.http, this.tokenManager);
     this.storage = new Storage(this.http);
-  }
-  /**
-   * 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) {
-    this.http.setAuthToken(apiKey);
+    this.ai = new AI(this.http);
   }
   /**
    * Get the underlying HTTP client for custom requests
@@ -991,12 +879,12 @@ function createClient(config) {
 var index_default = InsForgeClient;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AI,
   Auth,
   Database,
   HttpClient,
   InsForgeClient,
   InsForgeError,
-  QueryBuilder,
   Storage,
   StorageBucket,
   TokenManager,