@ragable/sdk 0.3.0 → 0.4.0

package/dist/index.js

@@ -23,6 +23,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var index_exports = {};
 __export(index_exports, {
   AgentsClient: () => AgentsClient,
+  PostgrestDeleteBuilder: () => PostgrestDeleteBuilder,
+  PostgrestInsertBuilder: () => PostgrestInsertBuilder,
+  PostgrestSelectBuilder: () => PostgrestSelectBuilder,
+  PostgrestTableApi: () => PostgrestTableApi,
+  PostgrestUpdateBuilder: () => PostgrestUpdateBuilder,
   Ragable: () => Ragable,
   RagableBrowser: () => RagableBrowser,
   RagableBrowserAgentsClient: () => RagableBrowserAgentsClient,
@@ -31,9 +36,12 @@ __export(index_exports, {
   RagableError: () => RagableError,
   RagableRequestClient: () => RagableRequestClient,
   ShiftClient: () => ShiftClient,
+  asPostgrestResponse: () => asPostgrestResponse,
   createBrowserClient: () => createBrowserClient,
   createClient: () => createClient,
   createRagPipeline: () => createRagPipeline,
+  createRagableBrowserClient: () => createRagableBrowserClient,
+  createRagableServerClient: () => createRagableServerClient,
   extractErrorMessage: () => extractErrorMessage,
   formatRetrievalContext: () => formatRetrievalContext,
   normalizeBrowserApiBase: () => normalizeBrowserApiBase,
@@ -378,6 +386,356 @@ var AgentsClient = class {
   }
 };
 
+// src/browser-postgrest.ts
+function assertIdent(name, ctx) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new RagableError(
+      `Invalid ${ctx} identifier "${name}" (use letters, numbers, underscore)`,
+      400,
+      null
+    );
+  }
+}
+function quoteIdent(name) {
+  assertIdent(name, "column");
+  return `"${name}"`;
+}
+var OP_SQL = {
+  eq: "=",
+  neq: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<=",
+  like: "LIKE",
+  ilike: "ILIKE"
+};
+async function asPostgrestResponse(fn) {
+  try {
+    const data = await fn();
+    return { data, error: null };
+  } catch (e) {
+    const err = e instanceof RagableError ? e : new RagableError(e.message, 500, null);
+    return { data: null, error: err };
+  }
+}
+function buildWhere(filters, params) {
+  if (filters.length === 0) return { clause: "", nextIdx: 1 };
+  const parts = [];
+  let i = params.length;
+  for (const f of filters) {
+    assertIdent(f.column, "filter");
+    i += 1;
+    parts.push(`${quoteIdent(f.column)} ${OP_SQL[f.op]} $${i}`);
+    params.push(f.value);
+  }
+  return { clause: ` WHERE ${parts.join(" AND ")}`, nextIdx: i };
+}
+var PostgrestSelectBuilder = class {
+  constructor(run, databaseInstanceId, table, columns) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    this.columns = columns;
+    __publicField(this, "filters", []);
+    __publicField(this, "_limit");
+    __publicField(this, "_order");
+    assertIdent(table, "table");
+  }
+  eq(column, value) {
+    this.filters.push({ op: "eq", column, value });
+    return this;
+  }
+  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;
+  }
+  limit(n) {
+    this._limit = n;
+    return this;
+  }
+  order(column, options) {
+    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);
+    let sql = `SELECT ${this.columns} FROM ${tbl}${clause}`;
+    if (this._order) {
+      sql += ` ORDER BY ${quoteIdent(this._order.column)} ${this._order.ascending ? "ASC" : "DESC"}`;
+    }
+    if (includeUserLimit && this._limit != null) {
+      sql += ` LIMIT ${Math.max(0, Math.floor(this._limit))}`;
+    }
+    return sql;
+  }
+  then(onfulfilled, onrejected) {
+    return this.executeMany().then(onfulfilled, onrejected);
+  }
+  async executeMany() {
+    return asPostgrestResponse(async () => {
+      const params = [];
+      const sql = this.buildSelectCore(params, true);
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: true
+      });
+      return res.rows;
+    });
+  }
+  async single() {
+    return asPostgrestResponse(async () => {
+      const params = [];
+      const base = this.buildSelectCore(params, false);
+      const sql = `${base} LIMIT 2`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        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) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return res.rows[0];
+    });
+  }
+  async maybeSingle() {
+    return asPostgrestResponse(async () => {
+      const params = [];
+      const base = this.buildSelectCore(params, false);
+      const sql = `${base} LIMIT 2`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: true
+      });
+      if (res.rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return res.rows[0] ?? null;
+    });
+  }
+};
+var PostgrestInsertBuilder = class {
+  constructor(run, databaseInstanceId, table, rows) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    this.rows = rows;
+    __publicField(this, "returning", "*");
+    assertIdent(table, "table");
+  }
+  select(columns = "*") {
+    this.returning = columns;
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+  async execute() {
+    return asPostgrestResponse(async () => {
+      if (this.rows.length === 0) return [];
+      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(", ")} RETURNING ${this.returning}`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: false
+      });
+      return res.rows;
+    });
+  }
+};
+var PostgrestUpdateBuilder = 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;
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+  async execute() {
+    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} RETURNING ${this.returning}`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: false
+      });
+      return res.rows;
+    });
+  }
+};
+var PostgrestDeleteBuilder = 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;
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+  async execute() {
+    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} RETURNING ${this.returning}`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: false
+      });
+      return res.rows;
+    });
+  }
+};
+var PostgrestTableApi = class {
+  constructor(run, databaseInstanceId, table) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+  }
+  select(columns = "*") {
+    return new PostgrestSelectBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      columns
+    );
+  }
+  insert(values) {
+    const rows = Array.isArray(values) ? values : [values];
+    return new PostgrestInsertBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      rows
+    );
+  }
+  update(patch) {
+    return new PostgrestUpdateBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      patch
+    );
+  }
+  delete() {
+    return new PostgrestDeleteBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table
+    );
+  }
+};
+
 // src/browser.ts
 function normalizeBrowserApiBase(baseUrl) {
   return (baseUrl ?? "http://localhost:8080/api").replace(/\/+$/, "");
@@ -412,6 +770,27 @@ async function parseJsonOrThrow(response) {
   }
   return payload;
 }
+function parseExpiresInSeconds(expiresIn) {
+  const s = expiresIn.trim().toLowerCase();
+  const m = /^(\d+)([smhd])?$/.exec(s);
+  if (m) {
+    const n = Number(m[1]);
+    const u = m[2] ?? "s";
+    const mult = u === "s" ? 1 : u === "m" ? 60 : u === "h" ? 3600 : u === "d" ? 86400 : 1;
+    return n * mult;
+  }
+  const asNum = Number(s);
+  return Number.isFinite(asNum) ? asNum : 0;
+}
+function toSupabaseSession(s) {
+  return {
+    access_token: s.accessToken,
+    refresh_token: s.refreshToken,
+    expires_in: parseExpiresInSeconds(s.expiresIn),
+    token_type: "bearer",
+    user: s.user
+  };
+}
 var RagableBrowserAuthClient = class {
   constructor(options) {
     this.options = options;
@@ -433,6 +812,69 @@ var RagableBrowserAuthClient = class {
     const gid = requireAuthGroupId(this.options);
     return `/auth-groups/${gid}/auth`;
   }
+  /** Supabase: `signUp` → `{ data: { user, session }, error }` */
+  async signUp(credentials) {
+    return asPostgrestResponse(async () => {
+      const name = typeof credentials.options?.data?.name === "string" ? credentials.options.data.name : void 0;
+      const session = await this.register({
+        email: credentials.email,
+        password: credentials.password,
+        name
+      });
+      return { user: session.user, session: toSupabaseSession(session) };
+    });
+  }
+  /** Supabase: `signInWithPassword` */
+  async signInWithPassword(credentials) {
+    return asPostgrestResponse(async () => {
+      const session = await this.login(credentials);
+      return { user: session.user, session: toSupabaseSession(session) };
+    });
+  }
+  /** Supabase: `refreshSession` */
+  async refreshSession(refreshToken) {
+    return asPostgrestResponse(async () => {
+      const tokens = await this.refresh({ refreshToken });
+      const me = await this.getUserFromToken(tokens.accessToken);
+      const session = {
+        access_token: tokens.accessToken,
+        refresh_token: tokens.refreshToken,
+        expires_in: parseExpiresInSeconds(tokens.expiresIn),
+        token_type: "bearer",
+        user: me.user
+      };
+      return { session, user: me.user };
+    });
+  }
+  /** Supabase: `getUser()` — needs `getAccessToken` on the client */
+  async getUser() {
+    return asPostgrestResponse(() => this.getMe());
+  }
+  /** Supabase: `updateUser` */
+  async updateUser(attributes) {
+    return asPostgrestResponse(
+      () => this.updateMe({
+        password: attributes.password,
+        name: attributes.data?.name
+      })
+    );
+  }
+  /**
+   * Supabase/Firebase: no server call — clear tokens in your app.
+   * Returns `{ error: null }` for API compatibility.
+   */
+  async signOut(_options) {
+    return { error: null };
+  }
+  async getUserFromToken(accessToken) {
+    const headers = this.baseHeaders(false);
+    headers.set("Authorization", `Bearer ${accessToken}`);
+    const response = await this.fetchImpl(`${this.toUrl(this.authPrefix())}/me`, {
+      method: "GET",
+      headers
+    });
+    return parseJsonOrThrow(response);
+  }
   async register(body) {
     const response = await this.fetchImpl(`${this.toUrl(this.authPrefix())}/register`, {
       method: "POST",
@@ -504,6 +946,7 @@ var RagableBrowserDatabaseClient = class {
           databaseInstanceId: params.databaseInstanceId,
           sql: params.sql,
           ...params.params !== void 0 ? { params: params.params } : {},
+          ...params.readOnly === false ? { readOnly: false } : {},
           ...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
           ...params.rowLimit !== void 0 ? { rowLimit: params.rowLimit } : {}
         })
@@ -563,14 +1006,31 @@ var RagableBrowser = class {
     __publicField(this, "agents");
     __publicField(this, "auth");
     __publicField(this, "database");
+    __publicField(this, "options");
+    this.options = options;
     this.agents = new RagableBrowserAgentsClient(options);
     this.auth = new RagableBrowserAuthClient(options);
     this.database = new RagableBrowserDatabaseClient(options);
   }
+  /**
+   * Supabase-style table API: `.from('items').select().eq('id', 1).single()`.
+   * Pass `databaseInstanceId` here or set `databaseInstanceId` on the client options.
+   */
+  from(table, databaseInstanceId) {
+    const id = databaseInstanceId?.trim() || this.options.databaseInstanceId?.trim();
+    if (!id) {
+      throw new Error(
+        "RagableBrowser.from() requires databaseInstanceId in client options or as the second argument"
+      );
+    }
+    const run = (p) => this.database.query(p);
+    return new PostgrestTableApi(run, id, table);
+  }
 };
 function createBrowserClient(options) {
   return new RagableBrowser(options);
 }
+var createRagableBrowserClient = createBrowserClient;
 
 // src/rag.ts
 function formatRetrievalContext(results, options = {}) {
@@ -628,12 +1088,46 @@ var Ragable = class {
     };
   }
 };
-function createClient(options) {
+function isServerClientOptions(o) {
+  return typeof o === "object" && o !== null && "apiKey" in o && typeof o.apiKey === "string" && o.apiKey.length > 0;
+}
+function createClient(urlOrOptions, browserOptions) {
+  if (typeof urlOrOptions === "string") {
+    if (!browserOptions) {
+      throw new Error(
+        "createClient(url, options) requires options with at least organizationId"
+      );
+    }
+    const raw = urlOrOptions.trim().replace(/\/+$/, "");
+    const baseUrl = raw.endsWith("/api") ? raw : `${raw}/api`;
+    return createBrowserClient({
+      ...browserOptions,
+      baseUrl: normalizeBrowserApiBase(baseUrl)
+    });
+  }
+  if (isServerClientOptions(urlOrOptions)) {
+    return new Ragable(urlOrOptions);
+  }
+  if (typeof urlOrOptions === "object" && urlOrOptions !== null && "organizationId" in urlOrOptions && typeof urlOrOptions.organizationId === "string") {
+    return createBrowserClient(
+      urlOrOptions
+    );
+  }
+  throw new Error(
+    "createClient(options) requires apiKey (server) or organizationId (browser)"
+  );
+}
+function createRagableServerClient(options) {
   return new Ragable(options);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentsClient,
+  PostgrestDeleteBuilder,
+  PostgrestInsertBuilder,
+  PostgrestSelectBuilder,
+  PostgrestTableApi,
+  PostgrestUpdateBuilder,
   Ragable,
   RagableBrowser,
   RagableBrowserAgentsClient,
@@ -642,9 +1136,12 @@ function createClient(options) {
   RagableError,
   RagableRequestClient,
   ShiftClient,
+  asPostgrestResponse,
   createBrowserClient,
   createClient,
   createRagPipeline,
+  createRagableBrowserClient,
+  createRagableServerClient,
   extractErrorMessage,
   formatRetrievalContext,
   normalizeBrowserApiBase,