@fluxbase/sdk 0.0.1-rc.30 → 0.0.1-rc.32

package/dist/index.js

@@ -3959,8 +3959,12 @@ var QueryBuilder = class {
   constructor(fetch2, table) {
     this.selectQuery = "*";
     this.filters = [];
+    this.orFilters = [];
+    this.andFilters = [];
     this.orderBys = [];
     this.singleRow = false;
+    this.maybeSingleRow = false;
+    this.operationType = "select";
     this.fetch = fetch2;
     this.table = table;
   }
@@ -3977,27 +3981,35 @@ var QueryBuilder = class {
   /**
    * Insert a single row or multiple rows
    */
-  async insert(data) {
-    const body = Array.isArray(data) ? data : data;
-    const response = await this.fetch.post(`/api/v1/tables/${this.table}`, body);
-    return {
-      data: response,
-      error: null,
-      count: Array.isArray(data) ? data.length : 1,
-      status: 201,
-      statusText: "Created"
-    };
+  insert(data) {
+    this.operationType = "insert";
+    this.insertData = data;
+    return this;
   }
   /**
-   * Upsert (insert or update) rows
+   * Upsert (insert or update) rows (Supabase-compatible)
+   * @param data - Row(s) to upsert
+   * @param options - Upsert options (onConflict, ignoreDuplicates, defaultToNull)
    */
-  async upsert(data) {
+  async upsert(data, options) {
     const body = Array.isArray(data) ? data : data;
-    const response = await this.fetch.post(`/api/v1/tables/${this.table}`, body, {
-      headers: {
-        Prefer: "resolution=merge-duplicates"
-      }
-    });
+    const preferValues = [];
+    if (options?.ignoreDuplicates) {
+      preferValues.push("resolution=ignore-duplicates");
+    } else {
+      preferValues.push("resolution=merge-duplicates");
+    }
+    if (options?.defaultToNull) {
+      preferValues.push("missing=default");
+    }
+    const headers = {
+      Prefer: preferValues.join(",")
+    };
+    let path = `/api/v1/tables/${this.table}`;
+    if (options?.onConflict) {
+      path += `?on_conflict=${encodeURIComponent(options.onConflict)}`;
+    }
+    const response = await this.fetch.post(path, body, { headers });
     return {
       data: response,
       error: null,
@@ -4009,32 +4021,17 @@ var QueryBuilder = class {
   /**
    * Update rows matching the filters
    */
-  async update(data) {
-    const queryString = this.buildQueryString();
-    const path = `/api/v1/tables/${this.table}${queryString}`;
-    const response = await this.fetch.patch(path, data);
-    return {
-      data: response,
-      error: null,
-      count: null,
-      status: 200,
-      statusText: "OK"
-    };
+  update(data) {
+    this.operationType = "update";
+    this.updateData = data;
+    return this;
   }
   /**
    * Delete rows matching the filters
    */
-  async delete() {
-    const queryString = this.buildQueryString();
-    const path = `/api/v1/tables/${this.table}${queryString}`;
-    await this.fetch.delete(path);
-    return {
-      data: null,
-      error: null,
-      count: null,
-      status: 204,
-      statusText: "No Content"
-    };
+  delete() {
+    this.operationType = "delete";
+    return this;
   }
   /**
    * Equal to
@@ -4120,6 +4117,71 @@ var QueryBuilder = class {
     this.filters.push({ column, operator: "fts", value: query });
     return this;
   }
+  /**
+   * Negate a filter condition (Supabase-compatible)
+   * @example not('status', 'eq', 'deleted')
+   * @example not('completed_at', 'is', null)
+   */
+  not(column, operator, value) {
+    this.filters.push({ column, operator: "not", value: `${operator}.${this.formatValue(value)}` });
+    return this;
+  }
+  /**
+   * Apply OR logic to filters (Supabase-compatible)
+   * @example or('status.eq.active,status.eq.pending')
+   * @example or('id.eq.2,name.eq.Han')
+   */
+  or(filters) {
+    this.orFilters.push(filters);
+    return this;
+  }
+  /**
+   * Apply AND logic to filters (Supabase-compatible)
+   * Groups multiple conditions that must all be true
+   * @example and('status.eq.active,verified.eq.true')
+   * @example and('age.gte.18,age.lte.65')
+   */
+  and(filters) {
+    this.andFilters.push(filters);
+    return this;
+  }
+  /**
+   * Match multiple columns with exact values (Supabase-compatible)
+   * Shorthand for multiple .eq() calls
+   * @example match({ id: 1, status: 'active', role: 'admin' })
+   */
+  match(conditions) {
+    for (const [column, value] of Object.entries(conditions)) {
+      this.eq(column, value);
+    }
+    return this;
+  }
+  /**
+   * Generic filter method using PostgREST syntax (Supabase-compatible)
+   * @example filter('name', 'in', '("Han","Yoda")')
+   * @example filter('age', 'gte', '18')
+   */
+  filter(column, operator, value) {
+    this.filters.push({ column, operator, value });
+    return this;
+  }
+  /**
+   * Check if column is contained by value (Supabase-compatible)
+   * For arrays and JSONB
+   * @example containedBy('tags', '["news","update"]')
+   */
+  containedBy(column, value) {
+    this.filters.push({ column, operator: "cd", value });
+    return this;
+  }
+  /**
+   * Check if arrays have common elements (Supabase-compatible)
+   * @example overlaps('tags', '["news","sports"]')
+   */
+  overlaps(column, value) {
+    this.filters.push({ column, operator: "ov", value });
+    return this;
+  }
   /**
    * Order results
    */
@@ -4147,12 +4209,32 @@ var QueryBuilder = class {
   }
   /**
    * Return a single row (adds limit(1))
+   * Errors if no rows found
    */
   single() {
     this.singleRow = true;
     this.limitValue = 1;
     return this;
   }
+  /**
+   * Return a single row or null (adds limit(1))
+   * Does not error if no rows found (Supabase-compatible)
+   * @example
+   * ```typescript
+   * // Returns null instead of erroring when no row exists
+   * const { data, error } = await client
+   *   .from('users')
+   *   .select('*')
+   *   .eq('id', 999)
+   *   .maybeSingle()
+   * // data will be null if no row found
+   * ```
+   */
+  maybeSingle() {
+    this.maybeSingleRow = true;
+    this.limitValue = 1;
+    return this;
+  }
   /**
    * Range selection (pagination)
    */
@@ -4328,13 +4410,13 @@ var QueryBuilder = class {
    *   { name: 'Alice', email: 'alice@example.com' },
    *   { name: 'Bob', email: 'bob@example.com' },
    *   { name: 'Charlie', email: 'charlie@example.com' }
-   * ]).execute()
+   * ])
    * ```
    *
    * @category Batch Operations
    */
   async insertMany(rows) {
-    return this.insert(rows);
+    return this.insert(rows).execute();
   }
   /**
    * Update multiple rows matching the filters (batch update)
@@ -4351,19 +4433,17 @@ var QueryBuilder = class {
    * const { data } = await client.from('products')
    *   .eq('category', 'electronics')
    *   .updateMany({ discount: 10, updated_at: new Date() })
-   *   .execute()
    *
    * // Mark all pending orders as processing
    * const { data } = await client.from('orders')
    *   .eq('status', 'pending')
    *   .updateMany({ status: 'processing' })
-   *   .execute()
    * ```
    *
    * @category Batch Operations
    */
   async updateMany(data) {
-    return this.update(data);
+    return this.update(data).execute();
   }
   /**
    * Delete multiple rows matching the filters (batch delete)
@@ -4379,27 +4459,66 @@ var QueryBuilder = class {
    * await client.from('users')
    *   .eq('active', false)
    *   .deleteMany()
-   *   .execute()
    *
    * // Delete old logs
    * await client.from('logs')
    *   .lt('created_at', '2024-01-01')
    *   .deleteMany()
-   *   .execute()
    * ```
    *
    * @category Batch Operations
    */
   async deleteMany() {
-    return this.delete();
+    return this.delete().execute();
   }
   /**
    * Execute the query and return results
    */
   async execute() {
-    const queryString = this.buildQueryString();
-    const path = `/api/v1/tables/${this.table}${queryString}`;
     try {
+      if (this.operationType === "insert") {
+        if (!this.insertData) {
+          throw new Error("Insert data is required for insert operation");
+        }
+        const body = Array.isArray(this.insertData) ? this.insertData : this.insertData;
+        const response = await this.fetch.post(`/api/v1/tables/${this.table}`, body);
+        return {
+          data: response,
+          error: null,
+          count: Array.isArray(this.insertData) ? this.insertData.length : 1,
+          status: 201,
+          statusText: "Created"
+        };
+      }
+      if (this.operationType === "update") {
+        if (!this.updateData) {
+          throw new Error("Update data is required for update operation");
+        }
+        const queryString2 = this.buildQueryString();
+        const path2 = `/api/v1/tables/${this.table}${queryString2}`;
+        const response = await this.fetch.patch(path2, this.updateData);
+        return {
+          data: response,
+          error: null,
+          count: null,
+          status: 200,
+          statusText: "OK"
+        };
+      }
+      if (this.operationType === "delete") {
+        const queryString2 = this.buildQueryString();
+        const path2 = `/api/v1/tables/${this.table}${queryString2}`;
+        await this.fetch.delete(path2);
+        return {
+          data: null,
+          error: null,
+          count: null,
+          status: 204,
+          statusText: "No Content"
+        };
+      }
+      const queryString = this.buildQueryString();
+      const path = `/api/v1/tables/${this.table}${queryString}`;
       const data = await this.fetch.get(path);
       if (this.singleRow) {
         if (Array.isArray(data) && data.length === 0) {
@@ -4420,6 +4539,25 @@ var QueryBuilder = class {
           statusText: "OK"
         };
       }
+      if (this.maybeSingleRow) {
+        if (Array.isArray(data) && data.length === 0) {
+          return {
+            data: null,
+            error: null,
+            count: 0,
+            status: 200,
+            statusText: "OK"
+          };
+        }
+        const singleData = Array.isArray(data) ? data[0] : data;
+        return {
+          data: singleData,
+          error: null,
+          count: 1,
+          status: 200,
+          statusText: "OK"
+        };
+      }
       return {
         data,
         error: null,
@@ -4441,6 +4579,37 @@ var QueryBuilder = class {
       };
     }
   }
+  /**
+   * Execute the query and throw an error if one occurs (Supabase-compatible)
+   * Returns the data directly instead of { data, error } wrapper
+   *
+   * @throws {Error} If the query fails or returns an error
+   * @example
+   * ```typescript
+   * // Throws error instead of returning { data, error }
+   * try {
+   *   const user = await client
+   *     .from('users')
+   *     .select('*')
+   *     .eq('id', 1)
+   *     .single()
+   *     .throwOnError()
+   * } catch (error) {
+   *   console.error('Query failed:', error)
+   * }
+   * ```
+   */
+  async throwOnError() {
+    const response = await this.execute();
+    if (response.error) {
+      const error = new Error(response.error.message);
+      if (response.error.code) {
+        error.code = response.error.code;
+      }
+      throw error;
+    }
+    return response.data;
+  }
   /**
    * Make QueryBuilder awaitable (implements PromiseLike)
    * This allows using `await client.from('table').select()` without calling `.execute()`
@@ -4468,6 +4637,12 @@ var QueryBuilder = class {
     for (const filter of this.filters) {
       params.append(filter.column, `${filter.operator}.${this.formatValue(filter.value)}`);
     }
+    for (const orFilter of this.orFilters) {
+      params.append("or", `(${orFilter})`);
+    }
+    for (const andFilter of this.andFilters) {
+      params.append("and", `(${andFilter})`);
+    }
     if (this.groupByColumns && this.groupByColumns.length > 0) {
       params.append("group_by", this.groupByColumns.join(","));
     }