@giaeulate/baas-sdk 1.1.1 → 1.3.0

package/dist/index.js

@@ -0,0 +1,1956 @@
+// src/http-client.ts
+var HttpClient = class {
+  url;
+  apiKey = "";
+  keyType;
+  token = null;
+  environment = "prod";
+  _onForceLogout = null;
+  constructor(url, apiKey, options) {
+    let baseUrl = url || (typeof window !== "undefined" ? window.location.origin : "http://localhost:8080");
+    this.url = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    if (apiKey) this.apiKey = apiKey;
+    this.keyType = options?.keyType ?? "service_role";
+    this.warnIfUnsafeKey();
+    this.token = typeof localStorage !== "undefined" ? this.cleanValue(localStorage.getItem("baas_token")) : null;
+  }
+  /** SECURITY: a service_role key bypasses RLS and grants admin over every
+   *  tenant. If it ends up in a browser bundle, anyone can extract it. Warn
+   *  loudly when a non-anon key is constructed in a browser context. */
+  warnIfUnsafeKey() {
+    const inBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+    if (inBrowser && this.apiKey && this.keyType !== "anon") {
+      console.warn(
+        '[baas-sdk] SECURITY WARNING: a non-anon (service_role) key is running in a browser. It bypasses Row-Level Security and grants admin over ALL tenants, and is extractable from the bundle. Mint an anon key in the dashboard and construct the client with { keyType: "anon" }.'
+      );
+    }
+  }
+  /**
+   * Set the auth token manually (e.g. restoring from SecureStore in React Native).
+   * Persists to both the in-memory property and localStorage so getDynamicToken() works.
+   */
+  setToken(token) {
+    this.token = token;
+    if (token) {
+      localStorage.setItem("baas_token", token);
+    } else {
+      localStorage.removeItem("baas_token");
+    }
+  }
+  /**
+   * Register a callback invoked on forced logout (401).
+   * Use this in React Native instead of the default window.location redirect.
+   */
+  onForceLogout(callback) {
+    this._onForceLogout = callback;
+  }
+  cleanValue(val) {
+    if (!val || val === "null" || val === "undefined") return null;
+    return val.trim();
+  }
+  /**
+   * Public header generator for adapters
+   */
+  getHeaders(contentType = "application/json") {
+    const dynamicToken = this.getDynamicToken();
+    const headers = {
+      "apikey": this.apiKey
+    };
+    if (contentType) {
+      headers["Content-Type"] = contentType;
+    }
+    if (dynamicToken) {
+      headers["Authorization"] = `Bearer ${dynamicToken}`;
+    }
+    if (this.environment && this.environment !== "prod") {
+      headers["X-Environment"] = this.environment;
+    }
+    const csrfToken = this.getCSRFToken();
+    if (csrfToken) {
+      headers["X-CSRF-Token"] = csrfToken;
+    }
+    return headers;
+  }
+  getDynamicToken() {
+    return this.cleanValue(this.token || localStorage.getItem("baas_token"));
+  }
+  /**
+   * Core HTTP request method - DRY principle
+   */
+  async request(endpoint, options = {}) {
+    const { method = "GET", body, headers: customHeaders, skipAuth = false } = options;
+    const headers = { ...this.getHeaders(), ...customHeaders };
+    const fetchOptions = {
+      method,
+      headers,
+      credentials: "include"
+    };
+    if (body !== void 0) {
+      fetchOptions.body = JSON.stringify(body);
+    }
+    const res = await fetch(`${this.url}${endpoint}`, fetchOptions);
+    if (res.status === 204) {
+      return { success: true };
+    }
+    const data = await res.json().catch(() => null);
+    if (!res.ok) {
+      if (res.status === 401 && !skipAuth) {
+        this.forceLogout();
+      }
+      if (res.status === 403 && data?.error === "ip_not_allowed") {
+        this.handleIPBlocked(data.ip);
+      }
+      const rateLimited = res.status === 429;
+      const retryHint = res.headers.get("retry-after") || res.headers.get("x-ratelimit-reset");
+      return {
+        error: data?.error || `Request failed: ${res.status}`,
+        status: res.status,
+        ...rateLimited ? { rateLimited: true, retryAfter: retryHint ? parseInt(retryHint, 10) : void 0 } : {},
+        ...data
+      };
+    }
+    return data;
+  }
+  get(endpoint) {
+    return this.request(endpoint);
+  }
+  post(endpoint, body) {
+    return this.request(endpoint, { method: "POST", body });
+  }
+  put(endpoint, body) {
+    return this.request(endpoint, { method: "PUT", body });
+  }
+  patch(endpoint, body) {
+    return this.request(endpoint, { method: "PATCH", body });
+  }
+  delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  getCSRFToken() {
+    if (typeof document === "undefined") return null;
+    const match = document.cookie.match(/(?:^|;\s*)csrf_token=([^;]*)/);
+    return match ? decodeURIComponent(match[1]) : null;
+  }
+  setEnvironment(env) {
+    this.environment = env;
+  }
+  getEnvironment() {
+    return this.environment;
+  }
+  logout() {
+    this.token = null;
+    localStorage.removeItem("baas_token");
+  }
+  forceLogout() {
+    this.logout();
+    if (this._onForceLogout) {
+      this._onForceLogout();
+      return;
+    }
+    if (typeof window !== "undefined" && window.location && window.location.search !== void 0) {
+      if (!window.location.search.includes("expired")) {
+        window.location.href = "/authentication/login?reason=expired";
+      }
+    }
+  }
+  handleIPBlocked(ip) {
+    if (typeof window !== "undefined") {
+      const params = ip ? `?ip=${encodeURIComponent(ip)}` : "";
+      if (!window.location.pathname.includes("/blocked")) {
+        window.location.href = `/blocked${params}`;
+      }
+    }
+  }
+};
+
+// src/query-builder.ts
+var QueryBuilder = class {
+  table;
+  url;
+  client;
+  queryParams = new URLSearchParams();
+  // @ts-ignore - used for future filter improvements
+  filters = [];
+  constructor(table, url, client) {
+    this.table = table;
+    this.url = url;
+    this.client = client;
+  }
+  select(columns = "*") {
+    this.queryParams.set("select", columns);
+    return this;
+  }
+  eq(column, value) {
+    this.queryParams.set(column, `eq.${value}`);
+    return this;
+  }
+  neq(column, value) {
+    this.queryParams.set(column, `neq.${value}`);
+    return this;
+  }
+  gt(column, value) {
+    this.queryParams.set(column, `gt.${value}`);
+    return this;
+  }
+  gte(column, value) {
+    this.queryParams.set(column, `gte.${value}`);
+    return this;
+  }
+  lt(column, value) {
+    this.queryParams.set(column, `lt.${value}`);
+    return this;
+  }
+  lte(column, value) {
+    this.queryParams.set(column, `lte.${value}`);
+    return this;
+  }
+  like(column, value) {
+    this.queryParams.set(column, `like.${value}`);
+    return this;
+  }
+  ilike(column, value) {
+    this.queryParams.set(column, `ilike.${value}`);
+    return this;
+  }
+  is(column, value) {
+    this.queryParams.set(column, `is.${value}`);
+    return this;
+  }
+  in(column, values) {
+    this.queryParams.set(column, `in.(${values.join(",")})`);
+    return this;
+  }
+  not(column, operator, value) {
+    this.queryParams.set(column, `not.${operator}.${value}`);
+    return this;
+  }
+  /** Array/jsonb/range contains (@>). Arrays become a `{a,b}` literal. */
+  contains(column, values) {
+    this.queryParams.set(column, `cs.${this.arrayLiteral(values)}`);
+    return this;
+  }
+  /** Array/jsonb/range contained-by (<@). */
+  containedBy(column, values) {
+    this.queryParams.set(column, `cd.${this.arrayLiteral(values)}`);
+    return this;
+  }
+  /** Array/range overlap (&&). */
+  overlaps(column, values) {
+    this.queryParams.set(column, `ov.${this.arrayLiteral(values)}`);
+    return this;
+  }
+  /** Full-text search (@@). type: fts|plfts|phfts|wfts (tsquery flavour). */
+  textSearch(column, query, type = "fts") {
+    this.queryParams.set(column, `${type}.${query}`);
+    return this;
+  }
+  arrayLiteral(values) {
+    return Array.isArray(values) ? `{${values.join(",")}}` : `${values}`;
+  }
+  /** OR group: `or=(c1,c2)`. Members are dotted `col.op.value` strings. */
+  or(filters) {
+    this.queryParams.set("or", `(${filters})`);
+    return this;
+  }
+  /** AND group: `and=(c1,c2)` — e.g. a range `qty.gt.5,qty.lt.20`. */
+  and(filters) {
+    this.queryParams.set("and", `(${filters})`);
+    return this;
+  }
+  /** Negated AND group: `not.and=(...)`. */
+  notAnd(filters) {
+    this.queryParams.set("not.and", `(${filters})`);
+    return this;
+  }
+  /** Negated OR group: `not.or=(...)`. */
+  notOr(filters) {
+    this.queryParams.set("not.or", `(${filters})`);
+    return this;
+  }
+  order(column, { ascending = true } = {}) {
+    this.queryParams.set("order", `${column}.${ascending ? "asc" : "desc"}`);
+    return this;
+  }
+  limit(count) {
+    this.queryParams.set("limit", count.toString());
+    return this;
+  }
+  offset(count) {
+    this.queryParams.set("offset", count.toString());
+    return this;
+  }
+  async get() {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}?${this.queryParams.toString()}`, {
+      headers: { ...this.getHeaders(), "Cache-Control": "no-cache" },
+      cache: "no-store"
+    });
+    return await this.handleResponse(res);
+  }
+  async insert(data) {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(data)
+    });
+    return await this.handleResponse(res);
+  }
+  async update(id, data) {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}/${id}`, {
+      method: "PATCH",
+      headers: this.getHeaders(),
+      body: JSON.stringify(data)
+    });
+    return await this.handleResponse(res);
+  }
+  async delete(id) {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}/${id}`, {
+      method: "DELETE",
+      headers: this.getHeaders()
+    });
+    if (res.status === 204) return { success: true };
+    return await this.handleResponse(res);
+  }
+  /** Insert-or-update on conflict. [onConflict] is the conflict-target column(s). */
+  async upsert(data, onConflict) {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}/upsert`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ ...data, on_conflict: onConflict })
+    });
+    return await this.handleResponse(res);
+  }
+  /**
+   * Count rows matching the current filters (PostgREST parity). Sends
+   * `Prefer: count=exact` and parses the total from the `Content-Range`
+   * response header. Returns `{ count, error, status }`.
+   */
+  async count() {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}?${this.queryParams.toString()}`, {
+      headers: { ...this.getHeaders(), Prefer: "count=exact", "Cache-Control": "no-cache" },
+      cache: "no-store"
+    });
+    if (!res.ok) {
+      if (res.status === 401) this.client.forceLogout();
+      const body = await res.json().catch(() => null);
+      return { count: 0, error: body?.error || "Request failed", status: res.status };
+    }
+    const cr = res.headers.get("content-range");
+    const total = cr && cr.includes("/") ? parseInt(cr.split("/").pop() || "", 10) : NaN;
+    return { count: Number.isNaN(total) ? 0 : total, error: null, status: res.status };
+  }
+  getHeaders() {
+    return this.client.getHeaders();
+  }
+  async handleResponse(res) {
+    const text = await res.text();
+    let data = null;
+    try {
+      data = text ? JSON.parse(text) : null;
+    } catch {
+    }
+    if (!res.ok) {
+      if (res.status === 401) {
+        this.client.forceLogout();
+      }
+      return { data: null, error: data?.error || "Request failed", status: res.status };
+    }
+    return { data, error: null, status: res.status };
+  }
+};
+
+// src/modules/auth.ts
+function createAuthModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  return {
+    async login(email, password) {
+      const res = await fetch(`${client.url}/api/login`, {
+        method: "POST",
+        headers: client.getHeaders(),
+        body: JSON.stringify({ email, password })
+      });
+      const contentType = res.headers.get("content-type");
+      if (!contentType?.includes("application/json")) {
+        throw new Error(`Login failed: Server returned ${res.status}. Please check your connection.`);
+      }
+      const data = await res.json().catch(() => {
+        throw new Error(`Login failed: Invalid JSON response (status ${res.status})`);
+      });
+      if (!res.ok) {
+        throw new Error(data?.error || `Login failed: ${res.status}`);
+      }
+      if (data.token) {
+        client.token = data.token;
+        localStorage.setItem("baas_token", data.token);
+      }
+      return data;
+    },
+    async logout() {
+      try {
+        await post("/api/logout");
+      } finally {
+        client.token = null;
+        localStorage.removeItem("baas_token");
+      }
+    },
+    // Anonymous sign-in (Supabase parity). Response carries access_token (+ a
+    // back-compat `token`); store whichever is present.
+    async signInAnonymous() {
+      const data = await post("/api/auth/anonymous");
+      const tok = data?.access_token || data?.token;
+      if (tok) {
+        client.token = tok;
+        localStorage.setItem("baas_token", tok);
+      }
+      return data;
+    },
+    // Passwordless: request a magic link + 6-digit email OTP. Always resolves on
+    // a well-formed request (no account enumeration).
+    async requestOtp(email, createUser = true) {
+      return post("/api/auth/otp", { email, create_user: createUser });
+    },
+    // Verify a passwordless OTP/magic-link and complete sign-in.
+    async verifyOtp(type, email, token) {
+      const data = await post("/api/auth/verify", { type, email, token });
+      const tok = data?.access_token || data?.token;
+      if (tok) {
+        client.token = tok;
+        localStorage.setItem("baas_token", tok);
+      }
+      return data;
+    },
+    // Upgrade the current anonymous guest to a real account (preserves user id).
+    // Requires the anonymous Bearer to be set (call after signInAnonymous).
+    async upgradeAnonymous(email, password) {
+      const data = await post("/api/auth/upgrade", { email, password });
+      const tok = data?.access_token || data?.token;
+      if (tok) {
+        client.token = tok;
+        localStorage.setItem("baas_token", tok);
+      }
+      return data;
+    },
+    async verifyMFA(mfaToken, code) {
+      const data = await post("/api/mfa/finalize", { mfa_token: mfaToken, code });
+      if (data.token) {
+        client.token = data.token;
+        localStorage.setItem("baas_token", data.token);
+      }
+      return data;
+    },
+    async verifyMFAWithRecoveryCode(mfaToken, recoveryCode) {
+      const data = await post("/api/mfa/finalize", { mfa_token: mfaToken, recovery_code: recoveryCode });
+      if (data.token) {
+        client.token = data.token;
+        localStorage.setItem("baas_token", data.token);
+      }
+      return data;
+    },
+    async setupMFA() {
+      return post("/api/mfa/setup");
+    },
+    async enableMFA(secret, code, recoveryCodes) {
+      const body = { secret, code };
+      if (recoveryCodes) {
+        body.recovery_codes = recoveryCodes;
+      }
+      return post("/api/mfa/enable", body);
+    },
+    async disableMFA(code) {
+      return post("/api/mfa/disable", { code });
+    },
+    async getProfile() {
+      return get("/api/profile");
+    },
+    async register(email, password) {
+      const data = await post("/api/register", { email, password });
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return data;
+    },
+    async forgotPassword(email) {
+      return post("/api/auth/forgot-password", { email });
+    },
+    async resetPassword(token, newPassword) {
+      return post("/api/auth/reset-password", { token, new_password: newPassword });
+    },
+    async validateResetToken(token) {
+      return get(`/api/auth/validate-reset-token?token=${token}`);
+    },
+    async verifyEmail(token) {
+      return post("/api/auth/verify-email", { token });
+    },
+    async requestEmailVerification() {
+      return post("/api/auth/request-verification");
+    },
+    async getAuthProviders() {
+      return get("/api/auth/providers");
+    },
+    async getAuthProvider(provider) {
+      return get(`/api/auth/providers/${provider}`);
+    },
+    async configureAuthProvider(provider, clientID, clientSecret, enabled) {
+      return post("/api/auth/providers", {
+        provider,
+        client_id: clientID,
+        client_secret: clientSecret,
+        enabled
+      });
+    }
+  };
+}
+
+// src/modules/users.ts
+function createUsersModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const put = (endpoint, body) => client.put(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async list(limit = 20, offset = 0) {
+      return get(`/api/users?limit=${limit}&offset=${offset}`);
+    },
+    async update(id, updates) {
+      return put(`/api/users/${id}`, updates);
+    },
+    async delete(id) {
+      return del(`/api/users/${id}`);
+    }
+  };
+}
+
+// src/modules/database.ts
+function createDatabaseModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const patch = (endpoint, body) => client.patch(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    // Schemas
+    async getSchemas(options) {
+      const params = new URLSearchParams();
+      if (options?.search) params.append("search", options.search);
+      if (options?.limit) params.append("limit", options.limit.toString());
+      if (options?.offset) params.append("offset", options.offset.toString());
+      const query = params.toString();
+      return get(`/api/schemas${query ? `?${query}` : ""}`);
+    },
+    async getSchema(name) {
+      return get(`/api/schemas/${name}`);
+    },
+    async saveSchemas(data) {
+      return post("/api/schemas", data);
+    },
+    // Tables
+    async createTable(tableName, definition) {
+      return post("/api/schemas/tables", { table_name: tableName, definition });
+    },
+    async dropTable(tableName) {
+      return del(`/api/schemas/tables/${tableName}`);
+    },
+    async renameTable(tableName, newName) {
+      return post(`/api/schemas/tables/${tableName}/rename`, { new_name: newName });
+    },
+    // Columns
+    async addColumn(tableName, column) {
+      return post(`/api/schemas/tables/${tableName}/columns`, column);
+    },
+    async dropColumn(tableName, columnName) {
+      return del(`/api/schemas/tables/${tableName}/columns/${columnName}`);
+    },
+    async modifyColumn(tableName, columnName, changes) {
+      return patch(`/api/schemas/tables/${tableName}/columns/${columnName}`, changes);
+    },
+    async renameColumn(tableName, columnName, newName) {
+      return post(`/api/schemas/tables/${tableName}/columns/${columnName}/rename`, { new_name: newName });
+    },
+    async setColumnDefault(tableName, columnName, defaultValue) {
+      return patch(`/api/schemas/tables/${tableName}/columns/${columnName}/default`, { default_value: defaultValue });
+    },
+    // Foreign Keys
+    async addForeignKey(tableName, fk) {
+      return post(`/api/schemas/tables/${tableName}/foreign-keys`, fk);
+    },
+    async listForeignKeys(tableName) {
+      return get(`/api/schemas/tables/${tableName}/foreign-keys`);
+    },
+    async dropForeignKey(tableName, constraintName) {
+      return del(`/api/schemas/tables/${tableName}/foreign-keys/${constraintName}`);
+    },
+    // Constraints
+    async addUniqueConstraint(tableName, columnName) {
+      return post(`/api/schemas/tables/${tableName}/constraints/unique`, { column: columnName });
+    },
+    async dropConstraint(tableName, constraintName) {
+      return del(`/api/schemas/tables/${tableName}/constraints/${constraintName}`);
+    },
+    // Data operations
+    async raw(query) {
+      return post("/api/v1/sql", { query });
+    },
+    async queryData(tableName, options) {
+      const params = new URLSearchParams();
+      if (options.page) params.append("page", options.page.toString());
+      if (options.limit) params.append("limit", options.limit.toString());
+      if (options.filters && options.filters.length > 0) {
+        params.append("filters", JSON.stringify(options.filters));
+      }
+      return get(`/api/v1/data/${tableName}/query?${params.toString()}`);
+    },
+    async downloadExport(tableName, format, filters) {
+      const params = new URLSearchParams();
+      if (filters && filters.length > 0) {
+        params.append("filters", JSON.stringify(filters));
+      }
+      const res = await fetch(`${client.url}/api/v1/export/${tableName}/${format}?${params.toString()}`, {
+        headers: client.getHeaders()
+      });
+      if (!res.ok) {
+        const data = await res.json();
+        return { error: data.error || `Export failed: ${res.status}` };
+      }
+      const blob = await res.blob();
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `${tableName}_${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${format === "backup" ? "dump" : format}`;
+      document.body.appendChild(a);
+      a.click();
+      window.URL.revokeObjectURL(url);
+      document.body.removeChild(a);
+      return { success: true };
+    }
+  };
+}
+
+// src/modules/storage.ts
+function createStorageModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const put = (endpoint, body) => client.put(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  async function uploadFile(fileOrTable, fileOrBucketId) {
+    let file;
+    let bucketId;
+    if (fileOrTable instanceof File) {
+      file = fileOrTable;
+      bucketId = typeof fileOrBucketId === "string" ? fileOrBucketId : void 0;
+    } else {
+      file = fileOrBucketId;
+      bucketId = void 0;
+    }
+    const formData = new FormData();
+    formData.append("file", file);
+    if (bucketId) {
+      formData.append("bucket_id", bucketId);
+    }
+    const headers = client.getHeaders("");
+    const res = await fetch(`${client.url}/api/storage/upload`, {
+      method: "POST",
+      headers,
+      body: formData
+    });
+    if (!res.ok) {
+      if (res.status === 401) client.forceLogout();
+      const err = await res.json().catch(() => ({ error: `Upload failed: ${res.status}` }));
+      throw new Error(err.error ?? `Upload failed: ${res.status}`);
+    }
+    return res.json();
+  }
+  return {
+    upload: uploadFile,
+    async listFiles() {
+      return get("/api/storage/files");
+    },
+    async getFile(fileId, expiresIn) {
+      const q = expiresIn && expiresIn > 0 ? `?expiresIn=${expiresIn}` : "";
+      return get(`/api/storage/files/${fileId}${q}`);
+    },
+    async createSignedUrl(fileId, expiresIn) {
+      const res = await get(
+        `/api/storage/files/${fileId}${expiresIn && expiresIn > 0 ? `?expiresIn=${expiresIn}` : ""}`
+      );
+      return { signedUrl: res?.url };
+    },
+    async deleteFile(fileId) {
+      return del(`/api/storage/files/${fileId}`);
+    },
+    async createBucket(name, isPublic = false) {
+      return post("/api/storage/buckets", { name, is_public: isPublic });
+    },
+    async updateBucket(bucketId, opts) {
+      return put(`/api/storage/buckets/${bucketId}`, { is_public: opts.isPublic });
+    },
+    async listBuckets() {
+      return get("/api/storage/buckets");
+    },
+    async getBucket(bucketId) {
+      return get(`/api/storage/buckets/${bucketId}`);
+    },
+    async deleteBucket(bucketId) {
+      return del(`/api/storage/buckets/${bucketId}`);
+    },
+    async listBucketFiles(bucketId) {
+      return get(`/api/storage/buckets/${bucketId}/files`);
+    },
+    async download(fileId) {
+      const res = await fetch(`${client.url}/api/storage/files/${fileId}/download`, {
+        headers: client.getHeaders("")
+      });
+      if (!res.ok) {
+        if (res.status === 401) client.forceLogout();
+        const err = await res.json().catch(() => ({ error: `Download failed: ${res.status}` }));
+        throw new Error(err.error ?? `Download failed: ${res.status}`);
+      }
+      return res.blob();
+    }
+  };
+}
+
+// src/modules/backups.ts
+function createBackupsModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async create(options) {
+      return post("/api/backups", options || {});
+    },
+    async list() {
+      return get("/api/backups");
+    },
+    async get(backupId) {
+      return get(`/api/backups/${backupId}`);
+    },
+    async restore(backupId) {
+      return post(`/api/backups/${backupId}/restore`, {});
+    },
+    async delete(backupId) {
+      return del(`/api/backups/${backupId}`);
+    },
+    getDownloadUrl(backupId) {
+      const token = client.getDynamicToken();
+      return `${client.url}/api/backups/${backupId}/download?access_token=${token}&apikey=${client.apiKey}`;
+    },
+    async listTables() {
+      return get("/api/backups/tables");
+    },
+    async importFile(formData) {
+      const headers = client.getHeaders();
+      delete headers["Content-Type"];
+      const res = await fetch(`${client.url}/api/import`, {
+        method: "POST",
+        headers,
+        body: formData
+      });
+      const data = await res.json();
+      if (!res.ok && res.status === 401) client.forceLogout();
+      return data;
+    }
+  };
+}
+
+// src/modules/migrations.ts
+function createMigrationsModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async create(input) {
+      return post("/api/migrations", input);
+    },
+    async list() {
+      return get("/api/migrations");
+    },
+    async get(id) {
+      return get(`/api/migrations/${id}`);
+    },
+    async apply(id) {
+      return post(`/api/migrations/${id}/apply`, {});
+    },
+    async rollback(id) {
+      return post(`/api/migrations/${id}/rollback`, {});
+    },
+    async delete(id) {
+      return del(`/api/migrations/${id}`);
+    },
+    async generate(tableName, changes) {
+      return post("/api/migrations/generate", { table_name: tableName, changes });
+    }
+  };
+}
+
+// src/modules/functions.ts
+function createFunctionsModule(client) {
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const get = (endpoint) => client.get(endpoint);
+  const del = (endpoint) => client.delete(endpoint);
+  const put = (endpoint, body) => client.put(endpoint, body);
+  return {
+    async invoke(id, data = {}) {
+      return post(`/api/functions/${id}/execute`, data);
+    },
+    async get(id) {
+      return get(`/api/functions/${id}`);
+    },
+    async list() {
+      return get("/api/functions");
+    },
+    async create(name, code, options) {
+      return post("/api/functions", { name, code, ...options });
+    },
+    async delete(id) {
+      return del(`/api/functions/${id}`);
+    },
+    async update(id, code, options) {
+      const current = await get(`/api/functions/${id}`);
+      const name = current?.name ?? current?.data?.name;
+      return post("/api/functions", { name, code, ...options });
+    },
+    async executeCode(code, options) {
+      return post("/api/functions/execute", { code, ...options });
+    },
+    async listHooks() {
+      return get("/api/hooks");
+    },
+    async createHook(data) {
+      return post("/api/hooks", data);
+    },
+    async deleteHook(id) {
+      return del(`/api/hooks/${id}`);
+    }
+  };
+}
+
+// src/modules/jobs.ts
+function createJobsModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const put = (endpoint, body) => client.put(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async create(input) {
+      return post("/api/jobs", input);
+    },
+    async list() {
+      return get("/api/jobs");
+    },
+    async get(id) {
+      return get(`/api/jobs/${id}`);
+    },
+    async update(id, input) {
+      return put(`/api/jobs/${id}`, input);
+    },
+    async delete(id) {
+      return del(`/api/jobs/${id}`);
+    },
+    async toggle(id, enabled) {
+      return post(`/api/jobs/${id}/toggle`, { enabled });
+    },
+    async runNow(id) {
+      return post(`/api/jobs/${id}/run`);
+    },
+    async getExecutions(id, limit) {
+      const params = new URLSearchParams();
+      if (limit) params.set("limit", limit.toString());
+      return get(`/api/jobs/${id}/executions?${params.toString()}`);
+    }
+  };
+}
+
+// src/modules/env-vars.ts
+function createEnvVarsModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const put = (endpoint, body) => client.put(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async create(input) {
+      return post("/api/env-vars", input);
+    },
+    async list() {
+      return get("/api/env-vars");
+    },
+    async get(id) {
+      return get(`/api/env-vars/${id}`);
+    },
+    async update(id, value) {
+      return put(`/api/env-vars/${id}`, { value });
+    },
+    async delete(id) {
+      return del(`/api/env-vars/${id}`);
+    }
+  };
+}
+
+// src/modules/email.ts
+function createEmailModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const put = (endpoint, body) => client.put(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async send(input) {
+      return post("/api/email/send", input);
+    },
+    async getConfig() {
+      return get("/api/email/config");
+    },
+    async saveConfig(config) {
+      return post("/api/email/config", config);
+    },
+    async createTemplate(template) {
+      return post("/api/email/templates", template);
+    },
+    async listTemplates() {
+      return get("/api/email/templates");
+    },
+    async getTemplate(id) {
+      return get(`/api/email/templates/${id}`);
+    },
+    async updateTemplate(id, template) {
+      return put(`/api/email/templates/${id}`, template);
+    },
+    async deleteTemplate(id) {
+      return del(`/api/email/templates/${id}`);
+    },
+    async getLogs(options) {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set("limit", options.limit.toString());
+      if (options?.offset) params.set("offset", options.offset.toString());
+      return get(`/api/email/logs?${params.toString()}`);
+    }
+  };
+}
+
+// src/modules/search.ts
+function createSearchModule(client) {
+  const post = (endpoint, body) => client.post(endpoint, body);
+  return {
+    async search(query, options) {
+      return post("/api/search", {
+        query,
+        tables: options?.tables,
+        columns: options?.columns,
+        limit: options?.limit,
+        offset: options?.offset
+      });
+    },
+    async createIndex(table, columns) {
+      return post("/api/search/index", { table, columns });
+    }
+  };
+}
+
+// src/modules/graphql.ts
+function createGraphQLModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  return {
+    async query(query, variables) {
+      return post("/api/graphql", { query, variables });
+    },
+    async getSchema() {
+      return post("/api/graphql", {
+        query: "{ __schema { queryType { name } mutationType { name } types { name kind } } }"
+      });
+    },
+    getPlaygroundUrl() {
+      return `${client.url}/api/graphql/playground`;
+    }
+  };
+}
+
+// src/modules/metrics.ts
+function createMetricsModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  return {
+    async getDashboardStats() {
+      return get("/api/metrics/dashboard");
+    },
+    async getRequestLogs(options) {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set("limit", options.limit.toString());
+      if (options?.offset) params.set("offset", options.offset.toString());
+      if (options?.method) params.set("method", options.method);
+      if (options?.status) params.set("status", options.status);
+      if (options?.path) params.set("path", options.path);
+      return get(`/api/metrics/requests?${params.toString()}`);
+    },
+    async getApplicationLogs(options) {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set("limit", options.limit.toString());
+      if (options?.offset) params.set("offset", options.offset.toString());
+      if (options?.level) params.set("level", options.level);
+      if (options?.source) params.set("source", options.source);
+      if (options?.search) params.set("search", options.search);
+      return get(`/api/metrics/logs?${params.toString()}`);
+    },
+    async getTimeseries(metric, options) {
+      const params = new URLSearchParams({ metric });
+      if (options?.interval) params.set("interval", options.interval);
+      if (options?.start) params.set("start", options.start);
+      if (options?.end) params.set("end", options.end);
+      return get(`/api/metrics/timeseries?${params.toString()}`);
+    }
+  };
+}
+
+// src/modules/audit.ts
+function createAuditModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async list(options) {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set("limit", options.limit.toString());
+      if (options?.offset) params.set("offset", options.offset.toString());
+      if (options?.action) params.set("action", options.action);
+      if (options?.user_id) params.set("user_id", options.user_id);
+      if (options?.method) params.set("method", options.method);
+      if (options?.path) params.set("path", options.path);
+      if (options?.status_code) params.set("status_code", options.status_code.toString());
+      if (options?.start_date) params.set("start_date", options.start_date);
+      if (options?.end_date) params.set("end_date", options.end_date);
+      return get(`/api/audit/logs?${params.toString()}`);
+    },
+    async getActions() {
+      return get("/api/audit/actions");
+    },
+    async exportLogs(format, options) {
+      const params = new URLSearchParams();
+      params.set("format", format);
+      if (options?.action) params.set("action", options.action);
+      if (options?.method) params.set("method", options.method);
+      if (options?.path) params.set("path", options.path);
+      if (options?.status_code) params.set("status_code", options.status_code.toString());
+      if (options?.start_date) params.set("start_date", options.start_date);
+      if (options?.end_date) params.set("end_date", options.end_date);
+      const res = await fetch(`${client.url}/api/audit/export?${params.toString()}`, {
+        headers: client.getHeaders(),
+        credentials: "include"
+      });
+      if (!res.ok) {
+        const data = await res.json();
+        return { error: data.error || `Export failed: ${res.status}` };
+      }
+      const blob = await res.blob();
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `audit_logs_${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${format}`;
+      document.body.appendChild(a);
+      a.click();
+      window.URL.revokeObjectURL(url);
+      document.body.removeChild(a);
+      return { success: true };
+    },
+    async purgePreview(olderThanDays) {
+      return get(`/api/audit/purge/preview?older_than_days=${olderThanDays}`);
+    },
+    async purge(olderThanDays) {
+      return del(`/api/audit/purge?older_than_days=${olderThanDays}`);
+    }
+  };
+}
+
+// src/modules/webhooks.ts
+function createWebhooksModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const put = (endpoint, body) => client.put(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async list() {
+      return get("/api/webhooks");
+    },
+    async get(id) {
+      return get(`/api/webhooks/${id}`);
+    },
+    async create(input) {
+      return post("/api/webhooks", input);
+    },
+    async update(id, input) {
+      return put(`/api/webhooks/${id}`, input);
+    },
+    async delete(id) {
+      return del(`/api/webhooks/${id}`);
+    },
+    async test(id) {
+      return post(`/api/webhooks/${id}/test`);
+    }
+  };
+}
+
+// src/modules/log-drains.ts
+function createLogDrainsModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const put = (endpoint, body) => client.put(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async create(input) {
+      return post("/api/log-drains", input);
+    },
+    async list() {
+      return get("/api/log-drains");
+    },
+    async get(id) {
+      return get(`/api/log-drains/${id}`);
+    },
+    async update(id, input) {
+      return put(`/api/log-drains/${id}`, input);
+    },
+    async delete(id) {
+      return del(`/api/log-drains/${id}`);
+    },
+    async toggle(id, enabled) {
+      return post(`/api/log-drains/${id}/toggle`, { enabled });
+    },
+    async test(id) {
+      return post(`/api/log-drains/${id}/test`);
+    }
+  };
+}
+
+// src/modules/branches.ts
+function createBranchesModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async create(input) {
+      return post("/api/branches", input);
+    },
+    async list() {
+      return get("/api/branches");
+    },
+    async get(id) {
+      return get(`/api/branches/${id}`);
+    },
+    async delete(id) {
+      return del(`/api/branches/${id}`);
+    },
+    async merge(id, targetBranchId) {
+      return post(`/api/branches/${id}/merge`, { target_branch_id: targetBranchId });
+    },
+    async reset(id) {
+      return post(`/api/branches/${id}/reset`);
+    }
+  };
+}
+
+// src/realtime.ts
+var RealtimeService = class {
+  constructor(url, apiKey, tokenProvider, wsConstructor = typeof WebSocket !== "undefined" ? WebSocket : null) {
+    this.url = url;
+    this.apiKey = apiKey;
+    this.tokenProvider = tokenProvider;
+    this.wsConstructor = wsConstructor;
+  }
+  socket = null;
+  subscribers = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  reconnectInterval = 3e3;
+  /**
+   * Initialize the WebSocket connection
+   */
+  connect() {
+    if (this.socket?.readyState === WebSocket.OPEN) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const token = this.tokenProvider();
+      if (!token) {
+        reject(new Error("Missing authentication token for Realtime connection"));
+        return;
+      }
+      const wsUrl = this.url.replace(/^http/, "ws") + "/api/ws";
+      const fullUrl = this.apiKey ? `${wsUrl}?apikey=${this.apiKey}&token=${token}` : `${wsUrl}?token=${token}`;
+      if (!this.wsConstructor) {
+        reject(new Error("WebSocket constructor not provided or available in this environment"));
+        return;
+      }
+      const socket = new this.wsConstructor(fullUrl);
+      this.socket = socket;
+      socket.onopen = () => {
+        console.log("BaaS Realtime: Connected");
+        this.reconnectAttempts = 0;
+        for (const table of this.subscribers.keys()) {
+          this.sendSub("subscribe", table);
+        }
+        resolve();
+      };
+      socket.onmessage = (event) => {
+        const raw = event.data;
+        const parts = raw.split("\n").filter((s) => s.trim());
+        for (const part of parts) {
+          try {
+            const payload = JSON.parse(part);
+            this.handleEvent(payload);
+          } catch {
+            const chunks = part.replace(/\}\s*\{/g, "}\n{").split("\n");
+            for (const chunk of chunks) {
+              try {
+                const payload = JSON.parse(chunk);
+                this.handleEvent(payload);
+              } catch {
+              }
+            }
+          }
+        }
+      };
+      socket.onerror = (error) => {
+        console.error("BaaS Realtime: WebSocket Error", error);
+        reject(error);
+      };
+      socket.onclose = () => {
+        console.log("BaaS Realtime: Disconnected");
+        this.socket = null;
+        this.attemptReconnect();
+      };
+    });
+  }
+  /**
+   * Subscribe to changes on a specific table
+   */
+  async subscribe(table, action, callback) {
+    await this.connect();
+    const isNewTable = !this.subscribers.has(table);
+    if (isNewTable) {
+      this.subscribers.set(table, /* @__PURE__ */ new Set());
+    }
+    const sub = { action, callback };
+    this.subscribers.get(table).add(sub);
+    if (isNewTable && table !== "*") {
+      this.sendSub("subscribe", table);
+    }
+    return {
+      unsubscribe: () => {
+        const tableSubs = this.subscribers.get(table);
+        if (tableSubs) {
+          tableSubs.delete(sub);
+          if (tableSubs.size === 0) {
+            this.subscribers.delete(table);
+            if (table !== "*") this.sendSub("unsubscribe", table);
+          }
+        }
+      }
+    };
+  }
+  /** Send a subscribe/unsubscribe control frame to the server. */
+  sendSub(event, table) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ event, table }));
+    }
+  }
+  /**
+   * Handle incoming CDC events from the server
+   */
+  handleEvent(payload) {
+    const tableSubs = this.subscribers.get(payload.table);
+    if (tableSubs) {
+      for (const sub of tableSubs) {
+        if (sub.action === "*" || sub.action.toLowerCase() === payload.action.toLowerCase()) {
+          sub.callback(payload);
+        }
+      }
+    }
+    const wildcardSubs = this.subscribers.get("*");
+    if (wildcardSubs) {
+      for (const sub of wildcardSubs) {
+        if (sub.action === "*" || sub.action.toLowerCase() === payload.action.toLowerCase()) {
+          sub.callback(payload);
+        }
+      }
+    }
+  }
+  /**
+   * Attempt to reconnect on connection loss
+   */
+  attemptReconnect() {
+    if (this.reconnectAttempts < this.maxReconnectAttempts) {
+      this.reconnectAttempts++;
+      console.log(`BaaS Realtime: Attempting reconnect ${this.reconnectAttempts}/${this.maxReconnectAttempts}...`);
+      setTimeout(() => this.connect(), this.reconnectInterval);
+    } else {
+      console.error("BaaS Realtime: Max reconnect attempts reached");
+    }
+  }
+  /**
+   * Close the connection
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.onclose = null;
+      this.socket.close();
+      this.socket = null;
+    }
+  }
+  /** @internal - For testing only */
+  get _socket() {
+    return this.socket;
+  }
+};
+
+// src/modules/realtime.ts
+function createRealtimeModule(client) {
+  const service = new RealtimeService(
+    client.url,
+    client.apiKey,
+    () => client.getDynamicToken(),
+    typeof WebSocket !== "undefined" ? WebSocket : void 0
+  );
+  return {
+    async subscribe(table, action, callback) {
+      return service.subscribe(table, action, callback);
+    }
+  };
+}
+
+// src/modules/api-keys.ts
+function createApiKeysModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async create(name, permissions, expiresAt) {
+      return post("/api/api-keys", { name, permissions, expires_at: expiresAt });
+    },
+    async list() {
+      return get("/api/api-keys");
+    },
+    async revoke(keyId) {
+      return post(`/api/api-keys/${keyId}/revoke`, {});
+    },
+    async delete(keyId) {
+      return del(`/api/api-keys/${keyId}`);
+    },
+    async getInstanceToken() {
+      return get("/api/api-keys/instance");
+    },
+    async regenerateInstanceToken() {
+      return post("/api/api-keys/instance/regenerate", {});
+    }
+  };
+}
+
+// src/modules/environments.ts
+function createEnvironmentsModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  return {
+    async status() {
+      return get("/api/environments/status");
+    },
+    async init() {
+      return post("/api/environments/init");
+    },
+    async promote() {
+      return post("/api/environments/promote");
+    },
+    async revert() {
+      return post("/api/environments/revert");
+    },
+    setActive(env) {
+      client.setEnvironment(env);
+    },
+    getActive() {
+      return client.getEnvironment();
+    }
+  };
+}
+
+// src/modules/cors-origins.ts
+function createCorsOriginsModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async list() {
+      return get("/api/cors-origins");
+    },
+    async create(origin, description) {
+      return post("/api/cors-origins", { origin, description: description || "" });
+    },
+    async delete(id) {
+      return del(`/api/cors-origins/${id}`);
+    }
+  };
+}
+
+// src/modules/policies.ts
+function createPoliciesModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async create(input) {
+      return post("/api/policies", input);
+    },
+    async list() {
+      return get("/api/policies");
+    },
+    async delete(id) {
+      return del(`/api/policies/${id}`);
+    }
+  };
+}
+
+// src/modules/ip-whitelist.ts
+function createIPWhitelistModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async list() {
+      return get("/api/ip-whitelist");
+    },
+    async create(ipAddress, description) {
+      return post("/api/ip-whitelist", { ip_address: ipAddress, description: description || "" });
+    },
+    async delete(id) {
+      return del(`/api/ip-whitelist/${id}`);
+    }
+  };
+}
+
+// src/modules/cache.ts
+function createCacheModule(client) {
+  const get = (endpoint) => client.get(endpoint);
+  const post = (endpoint, body) => client.post(endpoint, body);
+  const patch = (endpoint, body) => client.patch(endpoint, body);
+  const del = (endpoint) => client.delete(endpoint);
+  return {
+    async getStatus() {
+      return get("/api/cache/status");
+    },
+    async getStats() {
+      return get("/api/cache/stats");
+    },
+    async listPolicies() {
+      return get("/api/cache/policies");
+    },
+    async updatePolicy(namespace, body) {
+      return patch(`/api/cache/policies/${encodeURIComponent(namespace)}`, body);
+    },
+    async removePolicy(namespace) {
+      return del(`/api/cache/policies/${encodeURIComponent(namespace)}`);
+    },
+    async invalidateNamespace(namespace) {
+      return post(`/api/cache/invalidate/${encodeURIComponent(namespace)}`);
+    },
+    async invalidateAll() {
+      return post("/api/cache/invalidate-all");
+    },
+    async listKeys(prefix, cursor = 0, count = 100) {
+      const params = new URLSearchParams({ prefix, cursor: String(cursor), count: String(count) });
+      return get(`/api/cache/keys?${params}`);
+    },
+    async inspectKey(key) {
+      return get(`/api/cache/keys/inspect?key=${encodeURIComponent(key)}`);
+    }
+  };
+}
+
+// src/client.ts
+var BaasClient = class extends HttpClient {
+  // Feature modules
+  auth;
+  users;
+  database;
+  storage;
+  backups;
+  migrations;
+  functions;
+  jobs;
+  envVars;
+  email;
+  searchService;
+  graphqlService;
+  metrics;
+  audit;
+  webhooks;
+  logDrains;
+  branches;
+  realtime;
+  apiKeys;
+  environments;
+  corsOrigins;
+  policies;
+  ipWhitelist;
+  cache;
+  constructor(url, apiKey, options) {
+    super(url, apiKey, options);
+    this.auth = createAuthModule(this);
+    this.users = createUsersModule(this);
+    this.database = createDatabaseModule(this);
+    this.storage = createStorageModule(this);
+    this.backups = createBackupsModule(this);
+    this.migrations = createMigrationsModule(this);
+    this.functions = createFunctionsModule(this);
+    this.jobs = createJobsModule(this);
+    this.envVars = createEnvVarsModule(this);
+    this.email = createEmailModule(this);
+    this.searchService = createSearchModule(this);
+    this.graphqlService = createGraphQLModule(this);
+    this.metrics = createMetricsModule(this);
+    this.audit = createAuditModule(this);
+    this.webhooks = createWebhooksModule(this);
+    this.logDrains = createLogDrainsModule(this);
+    this.branches = createBranchesModule(this);
+    this.realtime = createRealtimeModule(this);
+    this.apiKeys = createApiKeysModule(this);
+    this.environments = createEnvironmentsModule(this);
+    this.corsOrigins = createCorsOriginsModule(this);
+    this.policies = createPoliciesModule(this);
+    this.ipWhitelist = createIPWhitelistModule(this);
+    this.cache = createCacheModule(this);
+  }
+  /**
+   * Create a query builder for fluent data queries
+   */
+  from(table) {
+    return new QueryBuilder(table, this.url, this);
+  }
+  /**
+   * Invoke a PL/pgSQL function (PostgREST `.rpc()` parity). Runs under the
+   * caller's RLS context; args bind by name and are $N-safe. Pass [params] for
+   * POST (named args in the body) or set `opts.get = true` for the GET variant.
+   */
+  async rpc(fn, params, opts) {
+    if (opts?.get) {
+      const qs = params ? "?" + new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)])).toString() : "";
+      return this.get(`/api/v1/rpc/${fn}${qs}`);
+    }
+    return this.post(`/api/v1/rpc/${fn}`, params ?? {});
+  }
+  // ============================================
+  // BACKWARD COMPATIBILITY METHODS
+  // These delegate to the appropriate modules
+  // ============================================
+  // Auth shortcuts
+  async login(email, password) {
+    return this.auth.login(email, password);
+  }
+  async verifyMFA(mfaToken, code) {
+    return this.auth.verifyMFA(mfaToken, code);
+  }
+  async getProfile() {
+    return this.auth.getProfile();
+  }
+  async register(email, password) {
+    return this.auth.register(email, password);
+  }
+  async forgotPassword(email) {
+    return this.auth.forgotPassword(email);
+  }
+  async resetPassword(token, newPassword) {
+    return this.auth.resetPassword(token, newPassword);
+  }
+  async validateResetToken(token) {
+    return this.auth.validateResetToken(token);
+  }
+  async verifyEmail(token) {
+    return this.auth.verifyEmail(token);
+  }
+  async requestEmailVerification() {
+    return this.auth.requestEmailVerification();
+  }
+  async getAuthProviders() {
+    return this.auth.getAuthProviders();
+  }
+  async getAuthProvider(provider) {
+    return this.auth.getAuthProvider(provider);
+  }
+  async configureAuthProvider(provider, clientID, clientSecret, enabled) {
+    return this.auth.configureAuthProvider(provider, clientID, clientSecret, enabled);
+  }
+  // Users shortcuts
+  async listUsers(limit = 20, offset = 0) {
+    return this.users.list(limit, offset);
+  }
+  async updateUser(id, updates) {
+    return this.users.update(id, updates);
+  }
+  async deleteUser(id) {
+    return this.users.delete(id);
+  }
+  // Database shortcuts
+  async raw(query) {
+    return this.database.raw(query);
+  }
+  async getSchemas(options) {
+    return this.database.getSchemas(options);
+  }
+  async getSchema(name) {
+    return this.database.getSchema(name);
+  }
+  async createTable(tableName, definition) {
+    return this.database.createTable(tableName, definition);
+  }
+  async dropTable(tableName) {
+    return this.database.dropTable(tableName);
+  }
+  async renameTable(tableName, newName) {
+    return this.database.renameTable(tableName, newName);
+  }
+  async addColumn(tableName, column) {
+    return this.database.addColumn(tableName, column);
+  }
+  async dropColumn(tableName, columnName) {
+    return this.database.dropColumn(tableName, columnName);
+  }
+  async modifyColumn(tableName, columnName, changes) {
+    return this.database.modifyColumn(tableName, columnName, changes);
+  }
+  async renameColumn(tableName, columnName, newName) {
+    return this.database.renameColumn(tableName, columnName, newName);
+  }
+  async setColumnDefault(tableName, columnName, defaultValue) {
+    return this.database.setColumnDefault(tableName, columnName, defaultValue);
+  }
+  async addForeignKey(tableName, fk) {
+    return this.database.addForeignKey(tableName, fk);
+  }
+  async listForeignKeys(tableName) {
+    return this.database.listForeignKeys(tableName);
+  }
+  async dropForeignKey(tableName, constraintName) {
+    return this.database.dropForeignKey(tableName, constraintName);
+  }
+  async addUniqueConstraint(tableName, columnName) {
+    return this.database.addUniqueConstraint(tableName, columnName);
+  }
+  async dropConstraint(tableName, constraintName) {
+    return this.database.dropConstraint(tableName, constraintName);
+  }
+  async queryData(tableName, options) {
+    return this.database.queryData(tableName, options);
+  }
+  async downloadExport(tableName, format, filters) {
+    return this.database.downloadExport(tableName, format, filters);
+  }
+  // Storage shortcuts
+  async upload(file, bucketId) {
+    return this.storage.upload(file, bucketId);
+  }
+  async listStorageFiles() {
+    return this.storage.listFiles();
+  }
+  async getStorageFile(fileId) {
+    return this.storage.getFile(fileId);
+  }
+  async deleteStorageFile(fileId) {
+    return this.storage.deleteFile(fileId);
+  }
+  async createStorageBucket(name, isPublic) {
+    return this.storage.createBucket(name, isPublic);
+  }
+  async listStorageBuckets() {
+    return this.storage.listBuckets();
+  }
+  async getStorageBucket(bucketId) {
+    return this.storage.getBucket(bucketId);
+  }
+  async deleteStorageBucket(bucketId) {
+    return this.storage.deleteBucket(bucketId);
+  }
+  async listStorageBucketFiles(bucketId) {
+    return this.storage.listBucketFiles(bucketId);
+  }
+  // Functions shortcuts
+  async invokeFunction(id, data) {
+    return this.functions.invoke(id, data);
+  }
+  // API Keys shortcuts
+  async createApiKey(name, permissions, expiresAt) {
+    return this.apiKeys.create(name, permissions, expiresAt);
+  }
+  async listApiKeys() {
+    return this.apiKeys.list();
+  }
+  async revokeApiKey(keyId) {
+    return this.apiKeys.revoke(keyId);
+  }
+  async deleteApiKey(keyId) {
+    return this.apiKeys.delete(keyId);
+  }
+  async getInstanceToken() {
+    return this.apiKeys.getInstanceToken();
+  }
+  async regenerateInstanceToken() {
+    return this.apiKeys.regenerateInstanceToken();
+  }
+  // Backups shortcuts
+  async createBackup(options) {
+    return this.backups.create(options);
+  }
+  async listBackups() {
+    return this.backups.list();
+  }
+  async getBackup(backupId) {
+    return this.backups.get(backupId);
+  }
+  async restoreBackup(backupId) {
+    return this.backups.restore(backupId);
+  }
+  async deleteBackup(backupId) {
+    return this.backups.delete(backupId);
+  }
+  getBackupDownloadUrl(backupId) {
+    return this.backups.getDownloadUrl(backupId);
+  }
+  async listBackupTables() {
+    return this.backups.listTables();
+  }
+  async importFile(formData) {
+    return this.backups.importFile(formData);
+  }
+  // Search shortcuts
+  async search(query, options) {
+    return this.searchService.search(query, options);
+  }
+  async createSearchIndex(table, columns) {
+    return this.searchService.createIndex(table, columns);
+  }
+  // GraphQL shortcuts
+  async graphql(query, variables) {
+    return this.graphqlService.query(query, variables);
+  }
+  getGraphQLPlaygroundUrl() {
+    return this.graphqlService.getPlaygroundUrl();
+  }
+  // Migrations shortcuts
+  async createMigration(input) {
+    return this.migrations.create(input);
+  }
+  async listMigrations() {
+    return this.migrations.list();
+  }
+  async getMigration(id) {
+    return this.migrations.get(id);
+  }
+  async applyMigration(id) {
+    return this.migrations.apply(id);
+  }
+  async rollbackMigration(id) {
+    return this.migrations.rollback(id);
+  }
+  async deleteMigration(id) {
+    return this.migrations.delete(id);
+  }
+  async generateMigration(tableName, changes) {
+    return this.migrations.generate(tableName, changes);
+  }
+  // Email shortcuts
+  async sendEmail(input) {
+    return this.email.send(input);
+  }
+  async getEmailConfig() {
+    return this.email.getConfig();
+  }
+  async saveEmailConfig(config) {
+    return this.email.saveConfig(config);
+  }
+  async createEmailTemplate(template) {
+    return this.email.createTemplate(template);
+  }
+  async listEmailTemplates() {
+    return this.email.listTemplates();
+  }
+  async getEmailTemplate(id) {
+    return this.email.getTemplate(id);
+  }
+  async updateEmailTemplate(id, template) {
+    return this.email.updateTemplate(id, template);
+  }
+  async deleteEmailTemplate(id) {
+    return this.email.deleteTemplate(id);
+  }
+  async getEmailLogs(options) {
+    return this.email.getLogs(options);
+  }
+  // Metrics shortcuts
+  async getDashboardStats() {
+    return this.metrics.getDashboardStats();
+  }
+  async getRequestLogs(options) {
+    return this.metrics.getRequestLogs(options);
+  }
+  async getApplicationLogs(options) {
+    return this.metrics.getApplicationLogs(options);
+  }
+  async getMetricTimeseries(metric, options) {
+    return this.metrics.getTimeseries(metric, options);
+  }
+  // Jobs shortcuts
+  async createJob(input) {
+    return this.jobs.create(input);
+  }
+  async listJobs() {
+    return this.jobs.list();
+  }
+  async getJob(id) {
+    return this.jobs.get(id);
+  }
+  async updateJob(id, input) {
+    return this.jobs.update(id, input);
+  }
+  async deleteJob(id) {
+    return this.jobs.delete(id);
+  }
+  async toggleJob(id, enabled) {
+    return this.jobs.toggle(id, enabled);
+  }
+  async runJobNow(id) {
+    return this.jobs.runNow(id);
+  }
+  async getJobExecutions(id, limit) {
+    return this.jobs.getExecutions(id, limit);
+  }
+  // Env Vars shortcuts
+  async createEnvVar(input) {
+    return this.envVars.create(input);
+  }
+  async listEnvVars() {
+    return this.envVars.list();
+  }
+  async getEnvVar(id) {
+    return this.envVars.get(id);
+  }
+  async updateEnvVar(id, value) {
+    return this.envVars.update(id, value);
+  }
+  async deleteEnvVar(id) {
+    return this.envVars.delete(id);
+  }
+  // Branches shortcuts
+  async createBranch(input) {
+    return this.branches.create(input);
+  }
+  async listBranches() {
+    return this.branches.list();
+  }
+  async getBranch(id) {
+    return this.branches.get(id);
+  }
+  async deleteBranch(id) {
+    return this.branches.delete(id);
+  }
+  async mergeBranch(id, targetBranchId) {
+    return this.branches.merge(id, targetBranchId);
+  }
+  async resetBranch(id) {
+    return this.branches.reset(id);
+  }
+  // Log Drains shortcuts
+  async createLogDrain(input) {
+    return this.logDrains.create(input);
+  }
+  async listLogDrains() {
+    return this.logDrains.list();
+  }
+  async getLogDrain(id) {
+    return this.logDrains.get(id);
+  }
+  async updateLogDrain(id, input) {
+    return this.logDrains.update(id, input);
+  }
+  async deleteLogDrain(id) {
+    return this.logDrains.delete(id);
+  }
+  async toggleLogDrain(id, enabled) {
+    return this.logDrains.toggle(id, enabled);
+  }
+  async testLogDrain(id) {
+    return this.logDrains.test(id);
+  }
+  // Webhooks shortcuts
+  async listWebhooks() {
+    return this.webhooks.list();
+  }
+  async getWebhook(id) {
+    return this.webhooks.get(id);
+  }
+  async createWebhook(input) {
+    return this.webhooks.create(input);
+  }
+  async updateWebhook(id, input) {
+    return this.webhooks.update(id, input);
+  }
+  async deleteWebhook(id) {
+    return this.webhooks.delete(id);
+  }
+  async testWebhook(id) {
+    return this.webhooks.test(id);
+  }
+  // Audit shortcuts
+  async listAuditLogs(options) {
+    return this.audit.list(options);
+  }
+  async getAuditActions() {
+    return this.audit.getActions();
+  }
+  async exportAuditLogs(format, options) {
+    return this.audit.exportLogs(format, options);
+  }
+  async previewPurgeAuditLogs(olderThanDays) {
+    return this.audit.purgePreview(olderThanDays);
+  }
+  async purgeAuditLogs(olderThanDays) {
+    return this.audit.purge(olderThanDays);
+  }
+  // Realtime shortcuts
+  subscribe(table, action, callback) {
+    return this.realtime.subscribe(table, action, callback);
+  }
+  // Environment shortcuts
+  async getEnvironmentStatus() {
+    return this.environments.status();
+  }
+  async initTestEnvironment() {
+    return this.environments.init();
+  }
+  async promoteTestToProd() {
+    return this.environments.promote();
+  }
+  async revertTestEnvironment() {
+    return this.environments.revert();
+  }
+  // CORS Origins shortcuts
+  async listCorsOrigins() {
+    return this.corsOrigins.list();
+  }
+  async addCorsOrigin(origin, description) {
+    return this.corsOrigins.create(origin, description);
+  }
+  async deleteCorsOrigin(id) {
+    return this.corsOrigins.delete(id);
+  }
+  // Policies shortcuts
+  async listPolicies() {
+    return this.policies.list();
+  }
+  async createPolicy(input) {
+    return this.policies.create(input);
+  }
+  async deletePolicy(id) {
+    return this.policies.delete(id);
+  }
+  // IP Whitelist shortcuts
+  async listIPWhitelist() {
+    return this.ipWhitelist.list();
+  }
+  async addIPWhitelistEntry(ipAddress, description) {
+    return this.ipWhitelist.create(ipAddress, description);
+  }
+  async deleteIPWhitelistEntry(id) {
+    return this.ipWhitelist.delete(id);
+  }
+};
+export {
+  BaasClient,
+  HttpClient,
+  QueryBuilder
+};
+//# sourceMappingURL=index.js.map