@ragable/sdk 0.4.2 → 0.5.1

package/dist/index.mjs

@@ -9,6 +9,7 @@ function bindFetch(custom) {
     return f.call(globalThis, input, init);
   };
 }
+var DEFAULT_RAGABLE_API_BASE = "https://ragable-341305259977.asia-southeast1.run.app/api";
 var RagableError = class extends Error {
   constructor(message, status, body) {
     super(message);
@@ -40,7 +41,7 @@ var RagableRequestClient = class {
     __publicField(this, "fetchImpl");
     __publicField(this, "defaultHeaders");
     this.apiKey = options.apiKey;
-    this.baseUrl = options.baseUrl ?? "http://localhost:8080/api";
+    this.baseUrl = options.baseUrl ?? DEFAULT_RAGABLE_API_BASE;
     this.fetchImpl = bindFetch(options.fetch);
     this.defaultHeaders = options.headers;
   }
@@ -358,6 +359,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 +453,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 +492,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 +520,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.execute().then(onfulfilled, onrejected);
+    return this.executeNoReturn().then(onfulfilled, onrejected);
   }
-  async execute() {
+  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.executeMany().then(onfulfilled, onrejected);
+  }
+  async executeMany() {
     return asPostgrestResponse(async () => {
       if (this.rows.length === 0) return [];
       const keys = Object.keys(this.rows[0]);
@@ -556,29 +610,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 +772,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 +911,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 +1067,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 +1075,7 @@ var PostgrestTableApi = class {
     );
   }
   update(patch) {
-    return new PostgrestUpdateBuilder(
+    return new PostgrestUpdateRootBuilder(
       this.run,
       this.databaseInstanceId,
       this.table,
@@ -686,17 +1083,33 @@ 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
 function normalizeBrowserApiBase(baseUrl) {
-  return (baseUrl ?? "http://localhost:8080/api").replace(/\/+$/, "");
+  const trimmed = (baseUrl ?? DEFAULT_RAGABLE_API_BASE).trim().replace(/\/+$/, "");
+  return trimmed.endsWith("/api") ? trimmed : `${trimmed}/api`;
 }
 function requireAuthGroupId(options) {
   const id = options.authGroupId?.trim();
@@ -720,6 +1133,20 @@ async function requireAccessToken(options) {
   }
   return token.trim();
 }
+async function resolveDatabaseAuthBearer(options) {
+  const mode = options.dataAuth ?? "user";
+  if (mode === "user") {
+    return requireAccessToken(options);
+  }
+  const fromGetter = options.getDataStaticKey ? await options.getDataStaticKey() : null;
+  const key = (fromGetter?.trim() || options.dataStaticKey?.trim()) ?? "";
+  if (!key) {
+    throw new Error(
+      mode === "publicAnon" ? "dataAuth publicAnon requires getDataStaticKey or dataStaticKey (rotate key in dashboard)" : "dataAuth admin requires getDataStaticKey or dataStaticKey (server-side only; rotate in dashboard)"
+    );
+  }
+  return key;
+}
 async function parseJsonOrThrow(response) {
   const payload = await parseMaybeJsonBody(response);
   if (!response.ok) {
@@ -889,7 +1316,7 @@ var RagableBrowserDatabaseClient = class {
   }
   async query(params) {
     const gid = requireAuthGroupId(this.options);
-    const token = await requireAccessToken(this.options);
+    const token = await resolveDatabaseAuthBearer(this.options);
     const databaseInstanceId = params.databaseInstanceId?.trim() || this.options.databaseInstanceId?.trim();
     if (!databaseInstanceId) {
       throw new Error(
@@ -899,6 +1326,7 @@ var RagableBrowserDatabaseClient = class {
     const headers = this.baseHeaders();
     headers.set("Authorization", `Bearer ${token}`);
     headers.set("Content-Type", "application/json");
+    const readOnly = (this.options.dataAuth ?? "user") === "publicAnon" ? true : params.readOnly !== false;
     const response = await this.fetchImpl(
       this.toUrl(`/auth-groups/${gid}/data/query`),
       {
@@ -908,7 +1336,7 @@ var RagableBrowserDatabaseClient = class {
           databaseInstanceId,
           sql: params.sql,
           ...params.params !== void 0 ? { params: params.params } : {},
-          ...params.readOnly === false ? { readOnly: false } : {},
+          readOnly,
           ...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
           ...params.rowLimit !== void 0 ? { rowLimit: params.rowLimit } : {}
         })
@@ -1083,11 +1511,17 @@ function createRagableServerClient(options) {
 }
 export {
   AgentsClient,
-  PostgrestDeleteBuilder,
-  PostgrestInsertBuilder,
+  DEFAULT_RAGABLE_API_BASE,
+  PostgrestDeleteReturningBuilder,
+  PostgrestDeleteRootBuilder,
+  PostgrestInsertReturningBuilder,
+  PostgrestInsertRootBuilder,
   PostgrestSelectBuilder,
   PostgrestTableApi,
-  PostgrestUpdateBuilder,
+  PostgrestUpdateReturningBuilder,
+  PostgrestUpdateRootBuilder,
+  PostgrestUpsertReturningBuilder,
+  PostgrestUpsertRootBuilder,
   Ragable,
   RagableBrowser,
   RagableBrowserAgentsClient,