@insforge/sdk 0.0.21 → 0.0.23

package/dist/index.mjs

@@ -25,9 +25,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."
@@ -172,294 +169,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"
-        )
-      };
-    }
-  }
-  /**
-   * Make QueryBuilder thenable for async/await
-   */
-  then(onfulfilled, onrejected) {
-    return this.execute().then(onfulfilled, onrejected);
-  }
-};
+// src/modules/database-postgrest.ts
+import { PostgrestClient } from "@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}`);
+    }
+    const response = await fetch(insforgeUrl, {
+      ...init,
+      headers
+    });
+    return response;
+  };
+}
 var Database = class {
-  constructor(http) {
-    this.http = http;
+  constructor(httpClient, tokenManager) {
+    this.postgrest = new 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);
   }
 };
 
@@ -468,7 +241,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();
   }
   /**
@@ -639,7 +412,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 {
@@ -673,7 +446,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 };
@@ -720,7 +493,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 };
   }
 };
 
@@ -1036,24 +810,10 @@ 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);
     this.ai = new AI(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);
-  }
   /**
    * Get the underlying HTTP client for custom requests
    * 
@@ -1088,7 +848,6 @@ export {
   HttpClient,
   InsForgeClient,
   InsForgeError,
-  QueryBuilder,
   Storage,
   StorageBucket,
   TokenManager,