aurabase-js 0.1.0

package/dist/index.js

@@ -0,0 +1,769 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuraBaseClient: () => AuraBaseClient,
+  createClient: () => createClient,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/QueryBuilder.ts
+var QueryBuilder = class {
+  constructor(url, anonKey, accessToken, tableName, headers = {}) {
+    this.isSingle = false;
+    this.url = url;
+    this.anonKey = anonKey;
+    this.accessToken = accessToken;
+    this.tableName = tableName;
+    this.queryParams = new URLSearchParams();
+    this.headers = { ...headers };
+  }
+  /**
+   * Select columns
+   * @example
+   * .select('id, name, email')
+   * .select('*')
+   */
+  select(columns = "*") {
+    this.queryParams.set("select", columns);
+    return this;
+  }
+  /**
+   * Filter by column equality
+   * @example
+   * .eq('id', 1)
+   * .eq('status', 'active')
+   */
+  eq(column, value) {
+    this.queryParams.append(column, `eq.${value}`);
+    return this;
+  }
+  /**
+   * Filter by column inequality
+   */
+  neq(column, value) {
+    this.queryParams.append(column, `neq.${value}`);
+    return this;
+  }
+  /**
+   * Filter by greater than
+   */
+  gt(column, value) {
+    this.queryParams.append(column, `gt.${value}`);
+    return this;
+  }
+  /**
+   * Filter by greater than or equal
+   */
+  gte(column, value) {
+    this.queryParams.append(column, `gte.${value}`);
+    return this;
+  }
+  /**
+   * Filter by less than
+   */
+  lt(column, value) {
+    this.queryParams.append(column, `lt.${value}`);
+    return this;
+  }
+  /**
+   * Filter by less than or equal
+   */
+  lte(column, value) {
+    this.queryParams.append(column, `lte.${value}`);
+    return this;
+  }
+  /**
+   * Filter by like pattern
+   */
+  like(column, pattern) {
+    this.queryParams.append(column, `like.${pattern}`);
+    return this;
+  }
+  /**
+   * Filter by case-insensitive like pattern
+   */
+  ilike(column, pattern) {
+    this.queryParams.append(column, `ilike.${pattern}`);
+    return this;
+  }
+  /**
+   * Filter by array contains
+   */
+  contains(column, value) {
+    this.queryParams.append(column, `cs.{${value.join(",")}}`);
+    return this;
+  }
+  /**
+   * Filter by value in array
+   */
+  in(column, values) {
+    this.queryParams.append(column, `in.(${values.join(",")})`);
+    return this;
+  }
+  /**
+   * Filter for null values
+   */
+  isNull(column) {
+    this.queryParams.append(column, "is.null");
+    return this;
+  }
+  /**
+   * Filter for non-null values
+   */
+  isNotNull(column) {
+    this.queryParams.append(column, "is.not.null");
+    return this;
+  }
+  /**
+   * Order results
+   * @example
+   * .order('created_at', { ascending: false })
+   */
+  order(column, options = {}) {
+    const { ascending = true, nullsFirst } = options;
+    let orderStr = column;
+    if (!ascending) orderStr += ".desc";
+    if (nullsFirst !== void 0) {
+      orderStr += nullsFirst ? ".nullsfirst" : ".nullslast";
+    }
+    this.queryParams.append("order", orderStr);
+    return this;
+  }
+  /**
+   * Limit results
+   */
+  limit(count) {
+    this.queryParams.set("limit", String(count));
+    return this;
+  }
+  /**
+   * Offset results
+   */
+  offset(count) {
+    this.queryParams.set("offset", String(count));
+    return this;
+  }
+  /**
+   * Range of results (offset + limit)
+   */
+  range(from, to) {
+    this.queryParams.set("offset", String(from));
+    this.queryParams.set("limit", String(to - from + 1));
+    return this;
+  }
+  /**
+   * Return single result
+   */
+  single() {
+    this.isSingle = true;
+    return this;
+  }
+  /**
+   * Return single result or null
+   */
+  maybeSingle() {
+    this.isSingle = true;
+    return this;
+  }
+  getHeaders() {
+    const token = this.accessToken || this.anonKey;
+    return {
+      "Content-Type": "application/json",
+      "apikey": this.anonKey,
+      "Authorization": `Bearer ${token}`,
+      ...this.headers
+    };
+  }
+  async request(method, body) {
+    const queryString = this.queryParams.toString();
+    const fullUrl = `${this.url}/rest/v1/${this.tableName}${queryString ? `?${queryString}` : ""}`;
+    const options = {
+      method,
+      headers: this.getHeaders()
+    };
+    if (body && method !== "GET") {
+      options.body = JSON.stringify(body);
+      options.headers["Prefer"] = "return=representation";
+    }
+    try {
+      const response = await fetch(fullUrl, options);
+      let data = null;
+      let error = null;
+      const text = await response.text();
+      if (text) {
+        try {
+          const parsed = JSON.parse(text);
+          if (!response.ok) {
+            error = {
+              message: parsed.message || parsed.error || `HTTP ${response.status}`,
+              code: parsed.code,
+              details: parsed.details
+            };
+          } else {
+            data = this.isSingle && Array.isArray(parsed) ? parsed[0] ?? null : parsed;
+          }
+        } catch {
+          if (!response.ok) {
+            error = {
+              message: text || `HTTP ${response.status}`
+            };
+          }
+        }
+      }
+      return {
+        data,
+        error,
+        status: response.status,
+        statusText: response.statusText
+      };
+    } catch (err) {
+      return {
+        data: null,
+        error: {
+          message: err instanceof Error ? err.message : "Network error"
+        },
+        status: 0,
+        statusText: "Network Error"
+      };
+    }
+  }
+  /**
+   * Execute SELECT query
+   */
+  async then(resolve, reject) {
+    try {
+      const result = await this.request("GET");
+      await resolve(result);
+    } catch (err) {
+      if (reject) {
+        await reject(err);
+      }
+    }
+  }
+  /**
+   * Insert row(s)
+   */
+  async insert(row) {
+    const rows = Array.isArray(row) ? row : [row];
+    return this.request("POST", rows.length === 1 ? rows[0] : rows);
+  }
+  /**
+   * Update row(s)
+   */
+  async update(data) {
+    return this.request("PATCH", data);
+  }
+  /**
+   * Upsert row(s)
+   */
+  async upsert(row) {
+    const rows = Array.isArray(row) ? row : [row];
+    this.headers["Prefer"] = "resolution=merge-duplicates,return=representation";
+    return this.request("POST", rows.length === 1 ? rows[0] : rows);
+  }
+  /**
+   * Delete row(s)
+   */
+  async delete() {
+    return this.request("DELETE");
+  }
+};
+
+// src/Auth.ts
+var AuthClient = class {
+  constructor(url, anonKey) {
+    this.listeners = /* @__PURE__ */ new Map();
+    this.currentSession = null;
+    this.storageKey = "aurabase_session";
+    this.url = url;
+    this.anonKey = anonKey;
+    this.loadSession();
+  }
+  loadSession() {
+    if (typeof window === "undefined") return;
+    try {
+      const stored = localStorage.getItem(this.storageKey);
+      if (stored) {
+        this.currentSession = JSON.parse(stored);
+      }
+    } catch {
+    }
+  }
+  saveSession(session) {
+    this.currentSession = session;
+    if (typeof window === "undefined") return;
+    if (session) {
+      localStorage.setItem(this.storageKey, JSON.stringify(session));
+    } else {
+      localStorage.removeItem(this.storageKey);
+    }
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "apikey": this.anonKey
+    };
+  }
+  emitEvent(event, session) {
+    const listeners = this.listeners.get(event) || [];
+    listeners.forEach((listener) => listener(event, session));
+    const allListeners = this.listeners.get("*") || [];
+    allListeners.forEach((listener) => listener(event, session));
+  }
+  /**
+   * Sign in with email and password
+   */
+  async signInWithPassword(credentials) {
+    try {
+      const response = await fetch(`${this.url}/auth/login`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(credentials)
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        const errorMsg = typeof data.detail === "string" ? data.detail : Array.isArray(data.detail) ? data.detail.map((e) => e.msg).join(", ") : data.error || "Login failed";
+        return {
+          data: null,
+          error: { error: errorMsg }
+        };
+      }
+      const session = {
+        access_token: data.access_token,
+        token_type: "bearer",
+        user: data.user
+      };
+      this.saveSession(session);
+      this.emitEvent("SIGNED_IN", session);
+      return {
+        data: { user: data.user, session },
+        error: null
+      };
+    } catch (err) {
+      return {
+        data: null,
+        error: { error: err instanceof Error ? err.message : "Network error" }
+      };
+    }
+  }
+  /**
+   * Sign up with email and password
+   */
+  async signUp(credentials) {
+    try {
+      const response = await fetch(`${this.url}/auth/register`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(credentials)
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          data: null,
+          error: { error: data.detail || data.error || "Registration failed" }
+        };
+      }
+      return {
+        data: { user: data.user || data },
+        error: null
+      };
+    } catch (err) {
+      return {
+        data: null,
+        error: { error: err instanceof Error ? err.message : "Network error" }
+      };
+    }
+  }
+  /**
+   * Sign out
+   */
+  async signOut() {
+    try {
+      const token = this.currentSession?.access_token;
+      if (token) {
+        await fetch(`${this.url}/auth/logout`, {
+          method: "POST",
+          headers: {
+            ...this.getHeaders(),
+            "Authorization": `Bearer ${token}`
+          }
+        });
+      }
+      this.saveSession(null);
+      this.emitEvent("SIGNED_OUT", null);
+      return { error: null };
+    } catch (err) {
+      return { error: { error: err instanceof Error ? err.message : "Network error" } };
+    }
+  }
+  /**
+   * Get current session
+   */
+  getSession() {
+    return { data: { session: this.currentSession } };
+  }
+  /**
+   * Get current user
+   */
+  async getUser() {
+    const token = this.currentSession?.access_token;
+    if (!token) {
+      return { data: { user: null }, error: null };
+    }
+    try {
+      const response = await fetch(`${this.url}/auth/me`, {
+        headers: {
+          ...this.getHeaders(),
+          "Authorization": `Bearer ${token}`
+        }
+      });
+      if (!response.ok) {
+        return {
+          data: { user: null },
+          error: { error: "Failed to get user" }
+        };
+      }
+      const user = await response.json();
+      return { data: { user }, error: null };
+    } catch (err) {
+      return {
+        data: { user: null },
+        error: { error: err instanceof Error ? err.message : "Network error" }
+      };
+    }
+  }
+  /**
+   * Update user
+   */
+  async updateUser(attributes) {
+    const token = this.currentSession?.access_token;
+    if (!token) {
+      return {
+        data: null,
+        error: { error: "Not authenticated" }
+      };
+    }
+    try {
+      const response = await fetch(`${this.url}/auth/me`, {
+        method: "PATCH",
+        headers: {
+          ...this.getHeaders(),
+          "Authorization": `Bearer ${token}`
+        },
+        body: JSON.stringify(attributes)
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          data: null,
+          error: { error: data.detail || data.error || "Update failed" }
+        };
+      }
+      if (this.currentSession) {
+        this.currentSession.user = data;
+        this.saveSession(this.currentSession);
+      }
+      this.emitEvent("USER_UPDATED", this.currentSession);
+      return { data: { user: data }, error: null };
+    } catch (err) {
+      return {
+        data: null,
+        error: { error: err instanceof Error ? err.message : "Network error" }
+      };
+    }
+  }
+  /**
+   * Request password reset
+   */
+  async resetPasswordForEmail(email) {
+    try {
+      const response = await fetch(`${this.url}/auth/find-password`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({ email })
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return { error: { error: data.detail || data.error || "Request failed" } };
+      }
+      return { error: null };
+    } catch (err) {
+      return { error: { error: err instanceof Error ? err.message : "Network error" } };
+    }
+  }
+  /**
+   * Subscribe to auth state changes
+   */
+  onAuthStateChange(callback) {
+    const addListener = (event) => {
+      if (!this.listeners.has(event)) {
+        this.listeners.set(event, []);
+      }
+      this.listeners.get(event).push(callback);
+    };
+    addListener("SIGNED_IN");
+    addListener("SIGNED_OUT");
+    addListener("TOKEN_REFRESHED");
+    addListener("USER_UPDATED");
+    return {
+      data: {
+        subscription: {
+          unsubscribe: () => {
+            this.listeners.forEach((listeners) => {
+              const index = listeners.indexOf(callback);
+              if (index > -1) {
+                listeners.splice(index, 1);
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/AuraBaseClient.ts
+var AuraBaseClient = class {
+  constructor(options) {
+    this.accessToken = null;
+    this.url = options.url;
+    this.anonKey = options.anonKey;
+    this.customHeaders = options.headers || {};
+    this.auth = new AuthClient(this.url, this.anonKey);
+  }
+  /**
+   * Set access token for authenticated requests
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  /**
+   * Get the current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /**
+   * Query a table
+   * @example
+   * const { data, error } = await client.from('todos').select('*')
+   */
+  from(tableName) {
+    return new QueryBuilder(
+      this.url,
+      this.anonKey,
+      this.accessToken,
+      tableName,
+      this.customHeaders
+    );
+  }
+  /**
+   * Execute raw SQL (RPC function call)
+   * @example
+   * const { data, error } = await client.rpc('my_function', { arg1: 'value' })
+   */
+  async rpc(functionName, params) {
+    const token = this.accessToken || this.anonKey;
+    try {
+      const response = await fetch(`${this.url}/rpc/v1/${functionName}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "apikey": this.anonKey,
+          "Authorization": `Bearer ${token}`,
+          ...this.customHeaders
+        },
+        body: JSON.stringify(params || {})
+      });
+      const text = await response.text();
+      let data = null;
+      let error = null;
+      if (text) {
+        try {
+          const parsed = JSON.parse(text);
+          if (!response.ok) {
+            error = { message: parsed.message || parsed.error || `HTTP ${response.status}` };
+          } else {
+            data = parsed;
+          }
+        } catch {
+          if (!response.ok) {
+            error = { message: text || `HTTP ${response.status}` };
+          }
+        }
+      }
+      return { data, error };
+    } catch (err) {
+      return {
+        data: null,
+        error: { message: err instanceof Error ? err.message : "Network error" }
+      };
+    }
+  }
+  /**
+   * Get storage client (if available)
+   */
+  get storage() {
+    return {
+      from: (bucket) => new StorageBucket(this.url, this.anonKey, bucket, this.accessToken)
+    };
+  }
+};
+var StorageBucket = class {
+  constructor(url, anonKey, bucket, accessToken) {
+    this.url = url;
+    this.anonKey = anonKey;
+    this.bucket = bucket;
+    this.accessToken = accessToken;
+  }
+  getHeaders() {
+    const token = this.accessToken || this.anonKey;
+    return {
+      "apikey": this.anonKey,
+      "Authorization": `Bearer ${token}`
+    };
+  }
+  /**
+   * Upload a file
+   */
+  async upload(path, file, options) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const headers = this.getHeaders();
+    if (options?.contentType) {
+      headers["Content-Type"] = options.contentType;
+    }
+    try {
+      const response = await fetch(
+        `${this.url}/storage/v1/object/${this.bucket}/${path}`,
+        {
+          method: "POST",
+          headers,
+          body: formData
+        }
+      );
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          data: null,
+          error: { message: data.message || data.error || "Upload failed" }
+        };
+      }
+      return { data: { path: data.path || path }, error: null };
+    } catch (err) {
+      return {
+        data: null,
+        error: { message: err instanceof Error ? err.message : "Network error" }
+      };
+    }
+  }
+  /**
+   * Download a file
+   */
+  async download(path) {
+    try {
+      const response = await fetch(
+        `${this.url}/storage/v1/object/${this.bucket}/${path}`,
+        {
+          headers: this.getHeaders()
+        }
+      );
+      if (!response.ok) {
+        const data = await response.json();
+        return {
+          data: null,
+          error: { message: data.message || data.error || "Download failed" }
+        };
+      }
+      return { data: await response.blob(), error: null };
+    } catch (err) {
+      return {
+        data: null,
+        error: { message: err instanceof Error ? err.message : "Network error" }
+      };
+    }
+  }
+  /**
+   * Get public URL for a file
+   */
+  getPublicUrl(path) {
+    return `${this.url}/storage/v1/object/public/${this.bucket}/${path}`;
+  }
+  /**
+   * Delete a file
+   */
+  async remove(paths) {
+    try {
+      const response = await fetch(`${this.url}/storage/v1/object/${this.bucket}`, {
+        method: "DELETE",
+        headers: {
+          ...this.getHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ prefixes: paths })
+      });
+      if (!response.ok) {
+        const data = await response.json();
+        return { error: { message: data.message || data.error || "Delete failed" } };
+      }
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err instanceof Error ? err.message : "Network error" } };
+    }
+  }
+  /**
+   * List files in a bucket
+   */
+  async list(prefix) {
+    try {
+      const url = prefix ? `${this.url}/storage/v1/object/list/${this.bucket}?prefix=${prefix}` : `${this.url}/storage/v1/object/list/${this.bucket}`;
+      const response = await fetch(url, {
+        headers: this.getHeaders()
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          data: null,
+          error: { message: data.message || data.error || "List failed" }
+        };
+      }
+      return { data, error: null };
+    } catch (err) {
+      return {
+        data: null,
+        error: { message: err instanceof Error ? err.message : "Network error" }
+      };
+    }
+  }
+};
+
+// src/index.ts
+function createClient(options) {
+  return new AuraBaseClient(options);
+}
+var index_default = createClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuraBaseClient,
+  createClient
+});