@ragable/sdk 0.4.1 → 0.5.0

package/dist/index.mjs

@@ -358,6 +358,18 @@ function quoteIdent(name) {
   assertIdent(name, "column");
   return `"${name}"`;
 }
+function parseConflictColumns(onConflict) {
+  const parts = onConflict.split(",").map((s) => s.trim()).filter(Boolean);
+  if (parts.length === 0) {
+    throw new RagableError(
+      "upsert requires onConflict with at least one column (e.g. 'id' or 'org_id,user_id')",
+      400,
+      null
+    );
+  }
+  for (const p of parts) assertIdent(p, "onConflict");
+  return parts;
+}
 var OP_SQL = {
   eq: "=",
   neq: "<>",
@@ -440,7 +452,6 @@ var PostgrestSelectBuilder = class {
     this._order = { column, ascending: options?.ascending !== false };
     return this;
   }
-  /** @param includeUserLimit when false, omit `.limit()` (for `.single()` / `.maybeSingle()`). */
   buildSelectCore(params, includeUserLimit) {
     const tbl = quoteIdent(this.table);
     const { clause } = buildWhere(this.filters, params);
@@ -480,12 +491,7 @@ var PostgrestSelectBuilder = class {
         params,
         readOnly: true
       });
-      if (res.rows.length === 0) {
-        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
-          code: "PGRST116"
-        });
-      }
-      if (res.rows.length > 1) {
+      if (res.rows.length === 0 || res.rows.length > 1) {
         throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
           code: "PGRST116"
         });
@@ -513,23 +519,70 @@ var PostgrestSelectBuilder = class {
     });
   }
 };
-var PostgrestInsertBuilder = class {
+var PostgrestInsertRootBuilder = class {
   constructor(run, databaseInstanceId, table, rows) {
     this.run = run;
     this.databaseInstanceId = databaseInstanceId;
     this.table = table;
     this.rows = rows;
-    __publicField(this, "returning", "*");
     assertIdent(table, "table");
   }
+  /**
+   * Return inserted rows (Supabase: chain `.select()` to get data).
+   * @see https://supabase.com/docs/reference/javascript/insert
+   */
   select(columns = "*") {
-    this.returning = columns;
-    return this;
+    return new PostgrestInsertReturningBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      this.rows,
+      columns
+    );
+  }
+  then(onfulfilled, onrejected) {
+    return this.executeNoReturn().then(onfulfilled, onrejected);
+  }
+  async executeNoReturn() {
+    return asPostgrestResponse(async () => {
+      if (this.rows.length === 0) return null;
+      const keys = Object.keys(this.rows[0]);
+      for (const k of keys) assertIdent(k, "column");
+      const tbl = quoteIdent(this.table);
+      const params = [];
+      const valueGroups = [];
+      for (const row of this.rows) {
+        const placeholders = [];
+        for (const k of keys) {
+          params.push(row[k]);
+          placeholders.push(`$${params.length}`);
+        }
+        valueGroups.push(`(${placeholders.join(", ")})`);
+      }
+      const cols = keys.map(quoteIdent).join(", ");
+      const sql = `INSERT INTO ${tbl} (${cols}) VALUES ${valueGroups.join(", ")}`;
+      await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: false
+      });
+      return null;
+    });
+  }
+};
+var PostgrestInsertReturningBuilder = class {
+  constructor(run, databaseInstanceId, table, rows, returning) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    this.rows = rows;
+    this.returning = returning;
   }
   then(onfulfilled, onrejected) {
-    return this.execute().then(onfulfilled, onrejected);
+    return this.executeMany().then(onfulfilled, onrejected);
   }
-  async execute() {
+  async executeMany() {
     return asPostgrestResponse(async () => {
       if (this.rows.length === 0) return [];
       const keys = Object.keys(this.rows[0]);
@@ -556,29 +609,137 @@ var PostgrestInsertBuilder = class {
       return res.rows;
     });
   }
+  async single() {
+    return asPostgrestResponse(async () => {
+      const { data, error } = await this.executeMany();
+      if (error) throw error;
+      const rows = data ?? [];
+      if (rows.length === 0 || rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return rows[0];
+    });
+  }
+  async maybeSingle() {
+    return asPostgrestResponse(async () => {
+      const { data, error } = await this.executeMany();
+      if (error) throw error;
+      const rows = data ?? [];
+      if (rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return rows[0] ?? null;
+    });
+  }
 };
-var PostgrestUpdateBuilder = class {
+var PostgrestUpdateRootBuilder = class {
   constructor(run, databaseInstanceId, table, patch) {
     this.run = run;
     this.databaseInstanceId = databaseInstanceId;
     this.table = table;
     this.patch = patch;
     __publicField(this, "filters", []);
-    __publicField(this, "returning", "*");
     assertIdent(table, "table");
   }
   eq(column, value) {
     this.filters.push({ op: "eq", column, value });
     return this;
   }
-  select(columns = "*") {
-    this.returning = columns;
+  neq(column, value) {
+    this.filters.push({ op: "neq", column, value });
+    return this;
+  }
+  gt(column, value) {
+    this.filters.push({ op: "gt", column, value });
+    return this;
+  }
+  gte(column, value) {
+    this.filters.push({ op: "gte", column, value });
+    return this;
+  }
+  lt(column, value) {
+    this.filters.push({ op: "lt", column, value });
+    return this;
+  }
+  lte(column, value) {
+    this.filters.push({ op: "lte", column, value });
+    return this;
+  }
+  like(column, value) {
+    this.filters.push({ op: "like", column, value });
+    return this;
+  }
+  ilike(column, value) {
+    this.filters.push({ op: "ilike", column, value });
     return this;
   }
+  /**
+   * Return updated rows (Supabase: `.update().eq().select()`).
+   * @see https://supabase.com/docs/reference/javascript/update
+   */
+  select(columns = "*") {
+    return new PostgrestUpdateReturningBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      this.patch,
+      this.filters,
+      columns
+    );
+  }
+  then(onfulfilled, onrejected) {
+    return this.executeNoReturn().then(onfulfilled, onrejected);
+  }
+  async executeNoReturn() {
+    return asPostgrestResponse(async () => {
+      const keys = Object.keys(this.patch);
+      if (keys.length === 0) {
+        throw new RagableError("Empty update payload", 400, null);
+      }
+      for (const k of keys) assertIdent(k, "column");
+      if (this.filters.length === 0) {
+        throw new RagableError(
+          "UPDATE requires a filter (e.g. .eq('id', value)) \u2014 refusing unscoped update",
+          400,
+          null
+        );
+      }
+      const params = [];
+      const sets = [];
+      for (const k of keys) {
+        params.push(this.patch[k]);
+        sets.push(`${quoteIdent(k)} = $${params.length}`);
+      }
+      const { clause } = buildWhere(this.filters, params);
+      const tbl = quoteIdent(this.table);
+      const sql = `UPDATE ${tbl} SET ${sets.join(", ")}${clause}`;
+      await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: false
+      });
+      return null;
+    });
+  }
+};
+var PostgrestUpdateReturningBuilder = class {
+  constructor(run, databaseInstanceId, table, patch, filters, returning) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    this.patch = patch;
+    this.filters = filters;
+    this.returning = returning;
+  }
   then(onfulfilled, onrejected) {
-    return this.execute().then(onfulfilled, onrejected);
+    return this.executeMany().then(onfulfilled, onrejected);
   }
-  async execute() {
+  async executeMany() {
     return asPostgrestResponse(async () => {
       const keys = Object.keys(this.patch);
       if (keys.length === 0) {
@@ -610,28 +771,124 @@ var PostgrestUpdateBuilder = class {
       return res.rows;
     });
   }
+  async single() {
+    return asPostgrestResponse(async () => {
+      const { data, error } = await this.executeMany();
+      if (error) throw error;
+      const rows = data ?? [];
+      if (rows.length === 0 || rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return rows[0];
+    });
+  }
+  async maybeSingle() {
+    return asPostgrestResponse(async () => {
+      const { data, error } = await this.executeMany();
+      if (error) throw error;
+      const rows = data ?? [];
+      if (rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return rows[0] ?? null;
+    });
+  }
 };
-var PostgrestDeleteBuilder = class {
+var PostgrestDeleteRootBuilder = class {
   constructor(run, databaseInstanceId, table) {
     this.run = run;
     this.databaseInstanceId = databaseInstanceId;
     this.table = table;
     __publicField(this, "filters", []);
-    __publicField(this, "returning", "*");
     assertIdent(table, "table");
   }
   eq(column, value) {
     this.filters.push({ op: "eq", column, value });
     return this;
   }
-  select(columns = "*") {
-    this.returning = columns;
+  neq(column, value) {
+    this.filters.push({ op: "neq", column, value });
+    return this;
+  }
+  gt(column, value) {
+    this.filters.push({ op: "gt", column, value });
+    return this;
+  }
+  gte(column, value) {
+    this.filters.push({ op: "gte", column, value });
+    return this;
+  }
+  lt(column, value) {
+    this.filters.push({ op: "lt", column, value });
+    return this;
+  }
+  lte(column, value) {
+    this.filters.push({ op: "lte", column, value });
     return this;
   }
+  like(column, value) {
+    this.filters.push({ op: "like", column, value });
+    return this;
+  }
+  ilike(column, value) {
+    this.filters.push({ op: "ilike", column, value });
+    return this;
+  }
+  /**
+   * Return deleted rows (Supabase: `.delete().eq().select()`).
+   * @see https://supabase.com/docs/reference/javascript/delete
+   */
+  select(columns = "*") {
+    return new PostgrestDeleteReturningBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      this.filters,
+      columns
+    );
+  }
+  then(onfulfilled, onrejected) {
+    return this.executeNoReturn().then(onfulfilled, onrejected);
+  }
+  async executeNoReturn() {
+    return asPostgrestResponse(async () => {
+      if (this.filters.length === 0) {
+        throw new RagableError(
+          "DELETE requires a filter (e.g. .eq('id', value)) \u2014 refusing unscoped delete",
+          400,
+          null
+        );
+      }
+      const params = [];
+      const { clause } = buildWhere(this.filters, params);
+      const tbl = quoteIdent(this.table);
+      const sql = `DELETE FROM ${tbl}${clause}`;
+      await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: false
+      });
+      return null;
+    });
+  }
+};
+var PostgrestDeleteReturningBuilder = class {
+  constructor(run, databaseInstanceId, table, filters, returning) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    this.filters = filters;
+    this.returning = returning;
+  }
   then(onfulfilled, onrejected) {
-    return this.execute().then(onfulfilled, onrejected);
+    return this.executeMany().then(onfulfilled, onrejected);
   }
-  async execute() {
+  async executeMany() {
     return asPostgrestResponse(async () => {
       if (this.filters.length === 0) {
         throw new RagableError(
@@ -653,6 +910,145 @@ var PostgrestDeleteBuilder = class {
       return res.rows;
     });
   }
+  async single() {
+    return asPostgrestResponse(async () => {
+      const { data, error } = await this.executeMany();
+      if (error) throw error;
+      const rows = data ?? [];
+      if (rows.length === 0 || rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return rows[0];
+    });
+  }
+  async maybeSingle() {
+    return asPostgrestResponse(async () => {
+      const { data, error } = await this.executeMany();
+      if (error) throw error;
+      const rows = data ?? [];
+      if (rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return rows[0] ?? null;
+    });
+  }
+};
+var PostgrestUpsertRootBuilder = class {
+  constructor(run, databaseInstanceId, table, rows, onConflict, ignoreDuplicates) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    this.rows = rows;
+    this.ignoreDuplicates = ignoreDuplicates;
+    __publicField(this, "conflictCols");
+    assertIdent(table, "table");
+    this.conflictCols = parseConflictColumns(onConflict);
+  }
+  /**
+   * Return upserted rows (Supabase: `.upsert().select()`).
+   * @see https://supabase.com/docs/reference/javascript/upsert
+   */
+  select(columns = "*") {
+    return new PostgrestUpsertReturningBuilder(this, columns);
+  }
+  then(onfulfilled, onrejected) {
+    return this.executeNoReturn().then(onfulfilled, onrejected);
+  }
+  async executeNoReturn() {
+    return asPostgrestResponse(async () => {
+      await this.runUpsert(null);
+      return null;
+    });
+  }
+  async runUpsert(returning) {
+    if (this.rows.length === 0) {
+      return { command: "INSERT", rowCount: 0, truncated: false, rows: [] };
+    }
+    const keys = Object.keys(this.rows[0]);
+    for (const k of keys) assertIdent(k, "column");
+    const tbl = quoteIdent(this.table);
+    const conflictQuoted = this.conflictCols.map(quoteIdent).join(", ");
+    const params = [];
+    const valueGroups = [];
+    for (const row of this.rows) {
+      const placeholders = [];
+      for (const k of keys) {
+        params.push(row[k]);
+        placeholders.push(`$${params.length}`);
+      }
+      valueGroups.push(`(${placeholders.join(", ")})`);
+    }
+    const cols = keys.map(quoteIdent).join(", ");
+    let sql = `INSERT INTO ${tbl} (${cols}) VALUES ${valueGroups.join(", ")} ON CONFLICT (${conflictQuoted})`;
+    if (this.ignoreDuplicates) {
+      sql += " DO NOTHING";
+    } else {
+      const setParts = keys.filter((k) => !this.conflictCols.includes(k)).map((k) => `${quoteIdent(k)} = EXCLUDED.${quoteIdent(k)}`);
+      if (setParts.length === 0) {
+        sql += " DO NOTHING";
+      } else {
+        sql += ` DO UPDATE SET ${setParts.join(", ")}`;
+      }
+    }
+    if (returning) {
+      sql += ` RETURNING ${returning}`;
+    }
+    return this.run({
+      databaseInstanceId: this.databaseInstanceId,
+      sql,
+      params,
+      readOnly: false
+    });
+  }
+  /** Used by returning builder */
+  async runWithReturning(returning) {
+    return this.runUpsert(returning);
+  }
+};
+var PostgrestUpsertReturningBuilder = class {
+  constructor(root, returning) {
+    this.root = root;
+    this.returning = returning;
+  }
+  then(onfulfilled, onrejected) {
+    return this.executeMany().then(onfulfilled, onrejected);
+  }
+  async executeMany() {
+    return asPostgrestResponse(async () => {
+      const res = await this.root.runWithReturning(this.returning);
+      return res.rows;
+    });
+  }
+  async single() {
+    return asPostgrestResponse(async () => {
+      const { data, error } = await this.executeMany();
+      if (error) throw error;
+      const rows = data ?? [];
+      if (rows.length === 0 || rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return rows[0];
+    });
+  }
+  async maybeSingle() {
+    return asPostgrestResponse(async () => {
+      const { data, error } = await this.executeMany();
+      if (error) throw error;
+      const rows = data ?? [];
+      if (rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return rows[0] ?? null;
+    });
+  }
 };
 var PostgrestTableApi = class {
   constructor(run, databaseInstanceId, table) {
@@ -670,7 +1066,7 @@ var PostgrestTableApi = class {
   }
   insert(values) {
     const rows = Array.isArray(values) ? values : [values];
-    return new PostgrestInsertBuilder(
+    return new PostgrestInsertRootBuilder(
       this.run,
       this.databaseInstanceId,
       this.table,
@@ -678,7 +1074,7 @@ var PostgrestTableApi = class {
     );
   }
   update(patch) {
-    return new PostgrestUpdateBuilder(
+    return new PostgrestUpdateRootBuilder(
       this.run,
       this.databaseInstanceId,
       this.table,
@@ -686,12 +1082,27 @@ var PostgrestTableApi = class {
     );
   }
   delete() {
-    return new PostgrestDeleteBuilder(
+    return new PostgrestDeleteRootBuilder(
       this.run,
       this.databaseInstanceId,
       this.table
     );
   }
+  /**
+   * `INSERT ... ON CONFLICT ... DO UPDATE` (or `DO NOTHING` with `ignoreDuplicates`).
+   * @see https://supabase.com/docs/reference/javascript/upsert
+   */
+  upsert(values, options) {
+    const rows = Array.isArray(values) ? values : [values];
+    return new PostgrestUpsertRootBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      rows,
+      options.onConflict,
+      options.ignoreDuplicates === true
+    );
+  }
 };
 
 // src/browser.ts
@@ -890,6 +1301,12 @@ var RagableBrowserDatabaseClient = class {
   async query(params) {
     const gid = requireAuthGroupId(this.options);
     const token = await requireAccessToken(this.options);
+    const databaseInstanceId = params.databaseInstanceId?.trim() || this.options.databaseInstanceId?.trim();
+    if (!databaseInstanceId) {
+      throw new Error(
+        "database.query requires databaseInstanceId in the request or on createBrowserClient({ databaseInstanceId })"
+      );
+    }
     const headers = this.baseHeaders();
     headers.set("Authorization", `Bearer ${token}`);
     headers.set("Content-Type", "application/json");
@@ -899,7 +1316,7 @@ var RagableBrowserDatabaseClient = class {
         method: "POST",
         headers,
         body: JSON.stringify({
-          databaseInstanceId: params.databaseInstanceId,
+          databaseInstanceId,
           sql: params.sql,
           ...params.params !== void 0 ? { params: params.params } : {},
           ...params.readOnly === false ? { readOnly: false } : {},
@@ -1077,11 +1494,16 @@ function createRagableServerClient(options) {
 }
 export {
   AgentsClient,
-  PostgrestDeleteBuilder,
-  PostgrestInsertBuilder,
+  PostgrestDeleteReturningBuilder,
+  PostgrestDeleteRootBuilder,
+  PostgrestInsertReturningBuilder,
+  PostgrestInsertRootBuilder,
   PostgrestSelectBuilder,
   PostgrestTableApi,
-  PostgrestUpdateBuilder,
+  PostgrestUpdateReturningBuilder,
+  PostgrestUpdateRootBuilder,
+  PostgrestUpsertReturningBuilder,
+  PostgrestUpsertRootBuilder,
   Ragable,
   RagableBrowser,
   RagableBrowserAgentsClient,