krisspy-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,890 @@
+// src/http.ts
+var HttpClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    this.debug = options.debug ?? false;
+  }
+  /**
+   * Set authorization header
+   */
+  setAuth(token) {
+    this.headers["Authorization"] = `Bearer ${token}`;
+  }
+  /**
+   * Remove authorization header
+   */
+  clearAuth() {
+    delete this.headers["Authorization"];
+  }
+  /**
+   * Update headers
+   */
+  setHeaders(headers) {
+    this.headers = { ...this.headers, ...headers };
+  }
+  /**
+   * Build query string from params
+   */
+  buildQueryString(params) {
+    const parts = [];
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null) continue;
+      if (Array.isArray(value)) {
+        parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value.join(","))}`);
+      } else {
+        parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+      }
+    }
+    return parts.length > 0 ? `?${parts.join("&")}` : "";
+  }
+  /**
+   * Make HTTP request
+   */
+  async request(method, path, options) {
+    const url = `${this.baseUrl}${path}${options?.params ? this.buildQueryString(options.params) : ""}`;
+    const requestHeaders = {
+      ...this.headers,
+      ...options?.headers
+    };
+    if (this.debug) {
+      console.log(`[Krisspy SDK] ${method} ${url}`);
+      if (options?.body) {
+        console.log("[Krisspy SDK] Body:", JSON.stringify(options.body, null, 2));
+      }
+    }
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body: options?.body ? JSON.stringify(options.body) : void 0
+      });
+      const contentType = response.headers.get("content-type");
+      let data = null;
+      if (contentType?.includes("application/json")) {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+      if (this.debug) {
+        console.log(`[Krisspy SDK] Response ${response.status}:`, data);
+      }
+      if (!response.ok) {
+        const error = {
+          message: data?.error || data?.message || "Request failed",
+          code: data?.code,
+          details: data?.details,
+          hint: data?.hint,
+          status: response.status
+        };
+        return { data: null, error, status: response.status };
+      }
+      return { data, error: null, status: response.status };
+    } catch (err) {
+      if (this.debug) {
+        console.error("[Krisspy SDK] Error:", err);
+      }
+      const error = {
+        message: err.message || "Network error",
+        code: "NETWORK_ERROR",
+        status: 0
+      };
+      return { data: null, error, status: 0 };
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(path, params) {
+    return this.request("GET", path, { params });
+  }
+  /**
+   * POST request
+   */
+  async post(path, body, params) {
+    return this.request("POST", path, { body, params });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(path, body, params) {
+    return this.request("PATCH", path, { body, params });
+  }
+  /**
+   * PUT request
+   */
+  async put(path, body, params) {
+    return this.request("PUT", path, { body, params });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(path, params) {
+    return this.request("DELETE", path, { params });
+  }
+};
+
+// src/auth.ts
+var STORAGE_KEY = "krisspy-auth-session";
+var KrisspyAuth = class {
+  constructor(http, backendId) {
+    this.currentSession = null;
+    this.currentUser = null;
+    this.listeners = [];
+    this.http = http;
+    this.backendId = backendId;
+    this.restoreSession();
+  }
+  /**
+   * Get current session from storage
+   */
+  restoreSession() {
+    if (typeof window === "undefined") return;
+    try {
+      const stored = localStorage.getItem(`${STORAGE_KEY}-${this.backendId}`);
+      if (stored) {
+        const session = JSON.parse(stored);
+        if (session.expires_at && Date.now() > session.expires_at * 1e3) {
+          this.clearSession();
+          return;
+        }
+        this.setSession(session);
+      }
+    } catch (err) {
+      console.warn("[Krisspy Auth] Failed to restore session:", err);
+    }
+  }
+  /**
+   * Store session
+   */
+  saveSession(session) {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(`${STORAGE_KEY}-${this.backendId}`, JSON.stringify(session));
+    } catch (err) {
+      console.warn("[Krisspy Auth] Failed to save session:", err);
+    }
+  }
+  /**
+   * Clear session from storage
+   */
+  clearSession() {
+    this.currentSession = null;
+    this.currentUser = null;
+    this.http.clearAuth();
+    if (this.refreshInterval) {
+      clearInterval(this.refreshInterval);
+      this.refreshInterval = void 0;
+    }
+    if (typeof window !== "undefined") {
+      localStorage.removeItem(`${STORAGE_KEY}-${this.backendId}`);
+    }
+  }
+  /**
+   * Set current session
+   */
+  setSession(session) {
+    this.currentSession = session;
+    this.currentUser = session.user;
+    this.http.setAuth(session.access_token);
+    this.saveSession(session);
+    this.setupAutoRefresh(session);
+    this.notifyListeners("SIGNED_IN");
+  }
+  /**
+   * Setup auto-refresh of token
+   */
+  setupAutoRefresh(session) {
+    if (this.refreshInterval) {
+      clearInterval(this.refreshInterval);
+    }
+    if (!session.refresh_token || !session.expires_in) return;
+    const refreshIn = (session.expires_in - 300) * 1e3;
+    if (refreshIn > 0) {
+      this.refreshInterval = setInterval(() => {
+        this.refreshSession();
+      }, refreshIn);
+    }
+  }
+  /**
+   * Notify auth state change listeners
+   */
+  notifyListeners(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error("[Krisspy Auth] Listener error:", err);
+      }
+    }
+  }
+  /**
+   * Sign up with email and password
+   */
+  async signUp(credentials) {
+    const path = `/api/v1/cloud-backends/${this.backendId}/auth/signup`;
+    const response = await this.http.post(path, {
+      email: credentials.email,
+      password: credentials.password,
+      metadata: credentials.metadata
+    });
+    if (response.error) {
+      return {
+        data: { user: null, session: null },
+        error: response.error
+      };
+    }
+    if (response.data?.session) {
+      this.setSession(response.data.session);
+    }
+    return {
+      data: {
+        user: response.data?.user ?? null,
+        session: response.data?.session ?? null
+      },
+      error: null
+    };
+  }
+  /**
+   * Sign in with email and password
+   */
+  async signInWithPassword(credentials) {
+    const path = `/api/v1/cloud-backends/${this.backendId}/auth/login`;
+    const response = await this.http.post(path, {
+      email: credentials.email,
+      password: credentials.password
+    });
+    if (response.error) {
+      return {
+        data: { user: null, session: null },
+        error: response.error
+      };
+    }
+    if (response.data?.session) {
+      this.setSession(response.data.session);
+    }
+    return {
+      data: {
+        user: response.data?.user ?? null,
+        session: response.data?.session ?? null
+      },
+      error: null
+    };
+  }
+  /**
+   * Sign in with OAuth provider
+   */
+  async signInWithOAuth(options) {
+    const path = `/api/v1/cloud-backends/${this.backendId}/auth/oauth/${options.provider}`;
+    const response = await this.http.post(path, {
+      redirect_to: options.redirectTo
+    });
+    if (response.error) {
+      return { data: null, error: response.error };
+    }
+    if (typeof window !== "undefined" && response.data?.url) {
+      window.location.href = response.data.url;
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Sign out
+   */
+  async signOut() {
+    const path = `/api/v1/cloud-backends/${this.backendId}/auth/logout`;
+    await this.http.post(path);
+    this.clearSession();
+    this.notifyListeners("SIGNED_OUT");
+    return { error: null };
+  }
+  /**
+   * Refresh the session token
+   */
+  async refreshSession() {
+    if (!this.currentSession?.refresh_token) {
+      return {
+        data: { user: null, session: null },
+        error: { message: "No refresh token available" }
+      };
+    }
+    const path = `/api/v1/cloud-backends/${this.backendId}/auth/refresh`;
+    const response = await this.http.post(path, {
+      refresh_token: this.currentSession.refresh_token
+    });
+    if (response.error) {
+      this.clearSession();
+      this.notifyListeners("SIGNED_OUT");
+      return {
+        data: { user: null, session: null },
+        error: response.error
+      };
+    }
+    if (response.data?.session) {
+      this.setSession(response.data.session);
+    }
+    return {
+      data: {
+        user: response.data?.session?.user ?? null,
+        session: response.data?.session ?? null
+      },
+      error: null
+    };
+  }
+  /**
+   * Get current session
+   */
+  async getSession() {
+    return {
+      data: { session: this.currentSession },
+      error: null
+    };
+  }
+  /**
+   * Get current user
+   */
+  async getUser() {
+    return {
+      data: { user: this.currentUser },
+      error: null
+    };
+  }
+  /**
+   * Get current user synchronously
+   */
+  user() {
+    return this.currentUser;
+  }
+  /**
+   * Get current session synchronously
+   */
+  session() {
+    return this.currentSession;
+  }
+  /**
+   * Update user metadata
+   */
+  async updateUser(data) {
+    const path = `/api/v1/cloud-backends/${this.backendId}/auth/user`;
+    const response = await this.http.patch(path, data);
+    if (response.error) {
+      return { data: { user: null }, error: response.error };
+    }
+    if (response.data?.user) {
+      this.currentUser = response.data.user;
+      if (this.currentSession) {
+        this.currentSession.user = response.data.user;
+        this.saveSession(this.currentSession);
+      }
+    }
+    return { data: { user: response.data?.user ?? null }, error: null };
+  }
+  /**
+   * Request password reset
+   */
+  async resetPasswordForEmail(email) {
+    const path = `/api/v1/cloud-backends/${this.backendId}/auth/reset-password`;
+    const response = await this.http.post(path, { email });
+    return { error: response.error };
+  }
+  /**
+   * Listen for auth state changes
+   */
+  onAuthStateChange(callback) {
+    this.listeners.push(callback);
+    if (this.currentSession) {
+      callback("SIGNED_IN");
+    }
+    return {
+      unsubscribe: () => {
+        const index = this.listeners.indexOf(callback);
+        if (index > -1) {
+          this.listeners.splice(index, 1);
+        }
+      }
+    };
+  }
+  /**
+   * Set session from external source (e.g., OAuth callback)
+   */
+  async setSessionFromUrl() {
+    if (typeof window === "undefined") {
+      return { data: { user: null, session: null }, error: { message: "Not in browser" } };
+    }
+    const hash = window.location.hash.substring(1);
+    const params = new URLSearchParams(hash);
+    const accessToken = params.get("access_token");
+    const refreshToken = params.get("refresh_token");
+    if (!accessToken) {
+      return { data: { user: null, session: null }, error: { message: "No access token in URL" } };
+    }
+    try {
+      const payload = JSON.parse(atob(accessToken.split(".")[1]));
+      const session = {
+        access_token: accessToken,
+        refresh_token: refreshToken ?? void 0,
+        expires_at: payload.exp,
+        expires_in: payload.exp ? payload.exp - Math.floor(Date.now() / 1e3) : 3600,
+        user: {
+          id: payload.sub,
+          email: payload.email,
+          metadata: payload.metadata
+        }
+      };
+      this.setSession(session);
+      window.history.replaceState({}, document.title, window.location.pathname);
+      return {
+        data: { user: session.user, session },
+        error: null
+      };
+    } catch (err) {
+      return {
+        data: { user: null, session: null },
+        error: { message: "Failed to parse token" }
+      };
+    }
+  }
+};
+
+// src/query-builder.ts
+var QueryBuilder = class {
+  constructor(http, backendId, tableName, useRLS = true) {
+    this.queryParams = {};
+    this.selectColumns = [];
+    this.orderClauses = [];
+    this.isSingle = false;
+    this.http = http;
+    this.backendId = backendId;
+    this.tableName = tableName;
+    this.useRLS = useRLS;
+  }
+  /**
+   * Get the base path for data endpoints
+   * Uses /rls/data for RLS-enabled queries (requires auth)
+   * Uses /data for legacy queries (admin/owner only)
+   */
+  getBasePath() {
+    if (this.useRLS) {
+      return `/api/v1/cloud-backends/${this.backendId}/rls/data/${this.tableName}`;
+    }
+    return `/api/v1/cloud-backends/${this.backendId}/data/${this.tableName}`;
+  }
+  /**
+   * Select specific columns
+   * @example .select('id, name, price')
+   * @example .select('*')
+   */
+  select(columns = "*") {
+    this.selectColumns = columns.split(",").map((c) => c.trim());
+    return this;
+  }
+  /**
+   * Filter: equals
+   * @example .eq('id', 123)
+   */
+  eq(column, value) {
+    this.queryParams[column] = `eq.${value}`;
+    return this;
+  }
+  /**
+   * Filter: not equals
+   * @example .neq('status', 'deleted')
+   */
+  neq(column, value) {
+    this.queryParams[column] = `neq.${value}`;
+    return this;
+  }
+  /**
+   * Filter: greater than
+   * @example .gt('price', 100)
+   */
+  gt(column, value) {
+    this.queryParams[column] = `gt.${value}`;
+    return this;
+  }
+  /**
+   * Filter: greater than or equal
+   * @example .gte('age', 18)
+   */
+  gte(column, value) {
+    this.queryParams[column] = `gte.${value}`;
+    return this;
+  }
+  /**
+   * Filter: less than
+   * @example .lt('stock', 10)
+   */
+  lt(column, value) {
+    this.queryParams[column] = `lt.${value}`;
+    return this;
+  }
+  /**
+   * Filter: less than or equal
+   * @example .lte('price', 1000)
+   */
+  lte(column, value) {
+    this.queryParams[column] = `lte.${value}`;
+    return this;
+  }
+  /**
+   * Filter: pattern matching (case sensitive)
+   * @example .like('name', '%iPhone%')
+   */
+  like(column, pattern) {
+    this.queryParams[column] = `like.${pattern}`;
+    return this;
+  }
+  /**
+   * Filter: pattern matching (case insensitive)
+   * @example .ilike('name', '%iphone%')
+   */
+  ilike(column, pattern) {
+    this.queryParams[column] = `ilike.${pattern}`;
+    return this;
+  }
+  /**
+   * Filter: value in list
+   * @example .in('status', ['active', 'pending'])
+   */
+  in(column, values) {
+    this.queryParams[column] = `in.${values.join(",")}`;
+    return this;
+  }
+  /**
+   * Filter: is null/true/false
+   * @example .is('deleted_at', null)
+   */
+  is(column, value) {
+    const strValue = value === null ? "null" : value ? "true" : "false";
+    this.queryParams[column] = `is.${strValue}`;
+    return this;
+  }
+  /**
+   * Order by column
+   * @example .order('created_at', { ascending: false })
+   */
+  order(column, options) {
+    const direction = options?.ascending === false ? "desc" : "asc";
+    this.orderClauses.push(`${column}.${direction}`);
+    return this;
+  }
+  /**
+   * Limit number of rows
+   * @example .limit(10)
+   */
+  limit(count) {
+    this.limitValue = count;
+    return this;
+  }
+  /**
+   * Skip rows (for pagination)
+   * @example .range(0, 9) // First 10 rows
+   */
+  range(from, to) {
+    this.offsetValue = from;
+    this.limitValue = to - from + 1;
+    return this;
+  }
+  /**
+   * Return single row (throws if multiple or none)
+   */
+  single() {
+    this.isSingle = true;
+    this.limitValue = 1;
+    return this;
+  }
+  /**
+   * Return first row or null
+   */
+  maybeSingle() {
+    this.isSingle = true;
+    this.limitValue = 1;
+    return this;
+  }
+  /**
+   * Build query params for the request
+   */
+  buildParams() {
+    const params = { ...this.queryParams };
+    if (this.selectColumns.length > 0 && !this.selectColumns.includes("*")) {
+      params["select"] = this.selectColumns.join(",");
+    }
+    if (this.orderClauses.length > 0) {
+      params["order"] = this.orderClauses.join(",");
+    }
+    if (this.limitValue !== void 0) {
+      params["limit"] = String(this.limitValue);
+    }
+    if (this.offsetValue !== void 0) {
+      params["offset"] = String(this.offsetValue);
+    }
+    return params;
+  }
+  /**
+   * Execute SELECT query
+   */
+  async then(resolve, reject) {
+    try {
+      const result = await this.execute();
+      resolve(result);
+    } catch (err) {
+      if (reject) reject(err);
+    }
+  }
+  /**
+   * Execute the query
+   */
+  async execute() {
+    const path = this.getBasePath();
+    const params = this.buildParams();
+    const response = await this.http.get(path, params);
+    if (response.error) {
+      if (this.isSingle) {
+        return { data: null, error: response.error };
+      }
+      return { data: null, error: response.error, count: null };
+    }
+    if (this.isSingle) {
+      const item = response.data?.data?.[0] ?? null;
+      return { data: item, error: null };
+    }
+    return {
+      data: response.data?.data ?? [],
+      error: null,
+      count: response.data?.count ?? 0
+    };
+  }
+  /**
+   * Insert rows
+   * @example .insert({ name: 'iPhone', price: 999 })
+   * @example .insert([{ name: 'iPhone' }, { name: 'iPad' }])
+   */
+  async insert(data) {
+    const path = this.getBasePath();
+    const response = await this.http.post(path, data);
+    if (response.error) {
+      return { data: null, error: response.error, count: 0 };
+    }
+    return {
+      data: response.data?.data ?? [],
+      error: null,
+      count: response.data?.count ?? 0
+    };
+  }
+  /**
+   * Update rows (requires filters)
+   * @example .update({ price: 899 }).eq('id', 123)
+   */
+  async update(data) {
+    const path = this.getBasePath();
+    const params = this.buildParams();
+    delete params["select"];
+    delete params["order"];
+    delete params["limit"];
+    delete params["offset"];
+    const response = await this.http.patch(path, data, params);
+    if (response.error) {
+      return { data: null, error: response.error, count: 0 };
+    }
+    return {
+      data: response.data?.data ?? [],
+      error: null,
+      count: response.data?.count ?? 0
+    };
+  }
+  /**
+   * Delete rows (requires filters)
+   * @example .delete().eq('id', 123)
+   */
+  async delete() {
+    const path = this.getBasePath();
+    const params = this.buildParams();
+    delete params["select"];
+    delete params["order"];
+    delete params["limit"];
+    delete params["offset"];
+    const response = await this.http.delete(path, params);
+    if (response.error) {
+      return { data: null, error: response.error, count: 0 };
+    }
+    return {
+      data: response.data?.data ?? [],
+      error: null,
+      count: response.data?.count ?? 0
+    };
+  }
+  /**
+   * Upsert rows (insert or update on conflict)
+   * @example .upsert({ id: 1, name: 'iPhone' })
+   */
+  async upsert(data, options) {
+    return this.insert(data);
+  }
+};
+
+// src/client.ts
+var KrisspyClient = class {
+  constructor(options) {
+    const baseUrl = options.url || "https://api.krisspy.ai";
+    this.backendId = options.backendId;
+    this.useRLS = options.useRLS !== false;
+    this.http = new HttpClient({
+      baseUrl,
+      headers: {
+        ...options.headers,
+        ...options.apiKey ? { "Authorization": `Bearer ${options.apiKey}` } : {}
+      },
+      debug: options.debug
+    });
+    this._auth = new KrisspyAuth(this.http, this.backendId);
+  }
+  /**
+   * Auth module for user authentication
+   *
+   * @example
+   * // Sign up
+   * const { data, error } = await krisspy.auth.signUp({
+   *   email: 'user@example.com',
+   *   password: 'secret123'
+   * })
+   *
+   * // Sign in
+   * const { data, error } = await krisspy.auth.signInWithPassword({
+   *   email: 'user@example.com',
+   *   password: 'secret123'
+   * })
+   *
+   * // Get current user
+   * const user = krisspy.auth.user()
+   *
+   * // Sign out
+   * await krisspy.auth.signOut()
+   */
+  get auth() {
+    return this._auth;
+  }
+  /**
+   * Create a query builder for a table
+   *
+   * @example
+   * // Select all rows
+   * const { data, error } = await krisspy.from('products').select('*')
+   *
+   * // Select with filters
+   * const { data, error } = await krisspy
+   *   .from('products')
+   *   .select('id, name, price')
+   *   .eq('active', true)
+   *   .order('created_at', { ascending: false })
+   *   .limit(10)
+   *
+   * // Insert
+   * const { data, error } = await krisspy
+   *   .from('products')
+   *   .insert({ name: 'iPhone', price: 999 })
+   *
+   * // Update
+   * const { data, error } = await krisspy
+   *   .from('products')
+   *   .update({ price: 899 })
+   *   .eq('id', 123)
+   *
+   * // Delete
+   * const { data, error } = await krisspy
+   *   .from('products')
+   *   .delete()
+   *   .eq('id', 123)
+   */
+  from(table) {
+    return new QueryBuilder(this.http, this.backendId, table, this.useRLS);
+  }
+  /**
+   * Execute raw SQL query
+   *
+   * @example
+   * const { data, error } = await krisspy.rpc('SELECT * FROM products WHERE price > $1', [100])
+   */
+  async rpc(sql, params) {
+    const path = `/api/v1/cloud-backends/${this.backendId}/sql`;
+    const response = await this.http.post(path, { sql, params });
+    if (response.error) {
+      return { data: null, error: response.error };
+    }
+    return { data: response.data?.result ?? null, error: null };
+  }
+  /**
+   * Invoke a serverless function
+   *
+   * @example
+   * const { data, error } = await krisspy.functions.invoke('hello-world', {
+   *   body: { name: 'John' }
+   * })
+   */
+  get functions() {
+    return {
+      invoke: async (functionName, options) => {
+        const path = `/api/v1/cloud-backends/${this.backendId}/functions/${functionName}/invoke`;
+        const response = await this.http.post(path, options?.body, void 0);
+        if (response.error) {
+          return { data: null, error: response.error };
+        }
+        return { data: response.data, error: null };
+      },
+      list: async () => {
+        const path = `/api/v1/cloud-backends/${this.backendId}/functions`;
+        const response = await this.http.get(path);
+        if (response.error) {
+          return { data: null, error: response.error };
+        }
+        return { data: response.data?.functions ?? [], error: null };
+      }
+    };
+  }
+  /**
+   * Get backend info
+   */
+  async getBackendInfo() {
+    const path = `/api/v1/cloud-backends/${this.backendId}`;
+    const response = await this.http.get(path);
+    if (response.error) {
+      return { data: null, error: response.error };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * List tables in the backend
+   */
+  async listTables() {
+    const path = `/api/v1/cloud-backends/${this.backendId}/tables`;
+    const response = await this.http.get(path);
+    if (response.error) {
+      return { data: null, error: response.error };
+    }
+    return { data: response.data?.tables ?? [], error: null };
+  }
+  /**
+   * Get table schema (columns)
+   */
+  async getTableSchema(table) {
+    const path = `/api/v1/cloud-backends/${this.backendId}/tables/${table}`;
+    const response = await this.http.get(path);
+    if (response.error) {
+      return { data: null, error: response.error };
+    }
+    return { data: response.data?.columns ?? [], error: null };
+  }
+};
+
+// src/index.ts
+function createClient(options) {
+  return new KrisspyClient(options);
+}
+export {
+  HttpClient,
+  KrisspyAuth,
+  KrisspyClient,
+  QueryBuilder,
+  createClient
+};