@svarabase/js 1.0.0

package/src/auth/index.ts

@@ -0,0 +1,325 @@
+import { SessionManager, Session, UserData, AuthListener } from './session';
+
+type SvarabaseAuthAdminClient = {
+  createUser(attributes: {
+    email: string;
+    phone?: string;
+    password?: string;
+    email_confirm?: boolean;
+    user_metadata?: Record<string, unknown>;
+    app_metadata?: Record<string, unknown>;
+  }): Promise<{ data: { user: UserData | null }; error: Error | null }>;
+
+  updateUserById(
+    uid: string,
+    attributes: {
+      email?: string;
+      password?: string;
+      phone?: string;
+      user_metadata?: Record<string, unknown>;
+      app_metadata?: Record<string, unknown>;
+      ban_duration?: string;
+    }
+  ): Promise<{ data: { user: UserData | null }; error: Error | null }>;
+
+  deleteUser(
+    id: string,
+    options?: { shouldSoftDelete?: boolean }
+  ): Promise<{ data: object; error: Error | null }>;
+
+  listUsers(
+    params?: { page?: number; perPage?: number }
+  ): Promise<{ data: { users: UserData[] }; error: Error | null }>;
+
+  generateLink(params: {
+    type: 'signup' | 'invite' | 'magic_link' | 'recovery';
+    email: string;
+    password?: string;
+    data?: Record<string, unknown>;
+    options?: { redirectTo?: string };
+  }): Promise<{ data: { action_link: string } | null; error: Error | null }>;
+};
+
+export class SvarabaseAuthClient {
+  private url: string;
+  private key: string;
+  private sessionManager: SessionManager;
+  public admin: SvarabaseAuthAdminClient;
+
+  constructor(url: string, key: string, options?: { storageKey?: string; persistSession?: boolean; autoRefreshToken?: boolean }) {
+    this.url = `${url}/auth/v1`;
+    this.key = key;
+    this.sessionManager = new SessionManager(
+      options?.storageKey ?? 'svarabase.auth.token',
+      options?.persistSession !== false
+    );
+    this.admin = this._buildAdminClient();
+
+    // Auto-refresh token if enabled
+    if (options?.autoRefreshToken !== false) {
+      this._setupAutoRefresh();
+    }
+  }
+
+  private async _fetch(path: string, init: RequestInit = {}): Promise<Response> {
+    const session = this.sessionManager.getSession();
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      apikey: this.key,
+      ...(init.headers as Record<string, string> ?? {}),
+    };
+
+    if (session?.access_token) {
+      headers['Authorization'] = `Bearer ${session.access_token}`;
+    } else {
+      headers['Authorization'] = `Bearer ${this.key}`;
+    }
+
+    return fetch(`${this.url}${path}`, { ...init, headers });
+  }
+
+  private _setupAutoRefresh() {
+    if (typeof setInterval === 'undefined') return;
+
+    setInterval(async () => {
+      const session = this.sessionManager.getSession();
+      if (!session) return;
+
+      const now = Math.floor(Date.now() / 1000);
+      const expiresAt = session.expires_at ?? 0;
+
+      // Refresh 60 seconds before expiry
+      if (expiresAt - now < 60) {
+        await this.refreshSession({ refresh_token: session.refresh_token });
+      }
+    }, 30000);
+  }
+
+  async getSession(): Promise<{ data: { session: Session | null }; error: null }> {
+    return { data: { session: this.sessionManager.getSession() }, error: null };
+  }
+
+  async setSession(params: { access_token: string; refresh_token: string }): Promise<{ data: { session: Session | null; user: UserData | null }; error: Error | null }> {
+    try {
+      const res = await this._fetch('/setsession', {
+        method: 'POST',
+        body: JSON.stringify(params),
+      });
+      if (!res.ok) {
+        const data = await res.json();
+        return { data: { session: null, user: null }, error: new Error(data.message ?? 'setSession failed') };
+      }
+      const data = await res.json();
+      const session: Session = { ...data, expires_at: data.expires_at ?? Math.floor(Date.now() / 1000) + (data.expires_in ?? 3600) };
+      this.sessionManager.setSession(session);
+      this.sessionManager.notify('SIGNED_IN', session);
+      return { data: { session, user: data.user }, error: null };
+    } catch (e: unknown) {
+      return { data: { session: null, user: null }, error: e as Error };
+    }
+  }
+
+  async signInWithPassword(credentials: { email: string; password: string }): Promise<{ data: { user: UserData | null; session: Session | null }; error: Error | null }> {
+    try {
+      const res = await this._fetch('/token?grant_type=password', {
+        method: 'POST',
+        body: JSON.stringify(credentials),
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: { user: null, session: null }, error: new Error(data.error_description ?? data.message) };
+
+      const session: Session = { ...data, expires_at: Math.floor(Date.now() / 1000) + data.expires_in };
+      this.sessionManager.setSession(session);
+      this.sessionManager.notify('SIGNED_IN', session);
+      return { data: { user: data.user, session }, error: null };
+    } catch (e: unknown) {
+      return { data: { user: null, session: null }, error: e as Error };
+    }
+  }
+
+  async signUp(credentials: { email: string; password: string; phone?: string; options?: { data?: Record<string, unknown>; emailRedirectTo?: string } }): Promise<{ data: { user: UserData | null; session: Session | null }; error: Error | null }> {
+    try {
+      const body: Record<string, unknown> = {
+        email: credentials.email,
+        password: credentials.password,
+        phone: credentials.phone,
+        data: credentials.options?.data,
+      };
+      const res = await this._fetch('/signup', {
+        method: 'POST',
+        body: JSON.stringify(body),
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: { user: null, session: null }, error: new Error(data.error_description ?? data.message) };
+
+      const session: Session = { ...data, expires_at: Math.floor(Date.now() / 1000) + data.expires_in };
+      this.sessionManager.setSession(session);
+      this.sessionManager.notify('SIGNED_IN', session);
+      return { data: { user: data.user, session }, error: null };
+    } catch (e: unknown) {
+      return { data: { user: null, session: null }, error: e as Error };
+    }
+  }
+
+  async signOut(options?: { scope?: 'global' | 'local' | 'others' }): Promise<{ error: Error | null }> {
+    try {
+      await this._fetch('/logout', { method: 'POST', body: JSON.stringify({ scope: options?.scope }) });
+      this.sessionManager.setSession(null);
+      this.sessionManager.notify('SIGNED_OUT', null);
+      return { error: null };
+    } catch (e: unknown) {
+      return { error: e as Error };
+    }
+  }
+
+  signInWithOAuth(params: { provider: string; options?: { redirectTo?: string; scopes?: string } }): { data: { provider: string; url: string }; error: null } {
+    const redirectTo = params.options?.redirectTo ?? (typeof window !== 'undefined' ? window.location.origin : '');
+    // apikey travels as a query param (not a header) because this is a top-level
+    // browser navigation - it lets the server know which project's OAuth config to use.
+    const url = `${this.url}/authorize?provider=${params.provider}&redirect_to=${encodeURIComponent(redirectTo)}&apikey=${encodeURIComponent(this.key)}`;
+
+    if (typeof window !== 'undefined') {
+      window.location.href = url;
+    }
+
+    return { data: { provider: params.provider, url }, error: null };
+  }
+
+  async getUser(jwt?: string): Promise<{ data: { user: UserData | null }; error: Error | null }> {
+    try {
+      const headers: Record<string, string> = {};
+      if (jwt) headers['Authorization'] = `Bearer ${jwt}`;
+
+      const res = await fetch(`${this.url}/user`, {
+        headers: {
+          'Content-Type': 'application/json',
+          apikey: this.key,
+          Authorization: jwt ? `Bearer ${jwt}` : `Bearer ${this.sessionManager.getSession()?.access_token ?? this.key}`,
+        },
+      });
+      if (!res.ok) {
+        const data = await res.json();
+        return { data: { user: null }, error: new Error(data.message) };
+      }
+      const user = await res.json();
+      return { data: { user }, error: null };
+    } catch (e: unknown) {
+      return { data: { user: null }, error: e as Error };
+    }
+  }
+
+  async updateUser(attributes: { email?: string; password?: string; phone?: string; data?: Record<string, unknown> }): Promise<{ data: { user: UserData | null }; error: Error | null }> {
+    try {
+      const body = { email: attributes.email, password: attributes.password, phone: attributes.phone, data: attributes.data };
+      const res = await this._fetch('/user', { method: 'PUT', body: JSON.stringify(body) });
+      const data = await res.json();
+      if (!res.ok) return { data: { user: null }, error: new Error(data.message) };
+      return { data: { user: data }, error: null };
+    } catch (e: unknown) {
+      return { data: { user: null }, error: e as Error };
+    }
+  }
+
+  async resetPasswordForEmail(email: string, options?: { redirectTo?: string }): Promise<{ data: object; error: Error | null }> {
+    try {
+      await this._fetch('/recover', {
+        method: 'POST',
+        body: JSON.stringify({ email, options }),
+      });
+      return { data: {}, error: null };
+    } catch (e: unknown) {
+      return { data: {}, error: e as Error };
+    }
+  }
+
+  async refreshSession(params?: { refresh_token?: string }): Promise<{ data: { session: Session | null; user: UserData | null }; error: Error | null }> {
+    try {
+      const refreshToken = params?.refresh_token ?? this.sessionManager.getSession()?.refresh_token;
+      if (!refreshToken) return { data: { session: null, user: null }, error: new Error('No refresh token') };
+
+      const res = await this._fetch('/token?grant_type=refresh_token', {
+        method: 'POST',
+        body: JSON.stringify({ refresh_token: refreshToken }),
+      });
+      const data = await res.json();
+      if (!res.ok) {
+        this.sessionManager.setSession(null);
+        return { data: { session: null, user: null }, error: new Error(data.message) };
+      }
+
+      const session: Session = { ...data, expires_at: Math.floor(Date.now() / 1000) + data.expires_in };
+      this.sessionManager.setSession(session);
+      this.sessionManager.notify('TOKEN_REFRESHED', session);
+      return { data: { session, user: data.user }, error: null };
+    } catch (e: unknown) {
+      return { data: { session: null, user: null }, error: e as Error };
+    }
+  }
+
+  onAuthStateChange(callback: AuthListener) {
+    return this.sessionManager.subscribe(callback);
+  }
+
+  private _buildAdminClient(): SvarabaseAuthAdminClient {
+    const adminUrl = `${this.url}/admin`;
+    const key = this.key;
+
+    const adminFetch = (path: string, init: RequestInit = {}) =>
+      fetch(`${adminUrl}${path}`, {
+        ...init,
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${key}`,
+          apikey: key,
+          ...(init.headers as Record<string, string> ?? {}),
+        },
+      });
+
+    return {
+      async createUser(attrs) {
+        try {
+          const res = await adminFetch('/users', { method: 'POST', body: JSON.stringify(attrs) });
+          const data = await res.json();
+          if (!res.ok) return { data: { user: null }, error: new Error(data.message) };
+          return { data: { user: data }, error: null };
+        } catch (e: unknown) { return { data: { user: null }, error: e as Error }; }
+      },
+
+      async updateUserById(uid, attrs) {
+        try {
+          const res = await adminFetch(`/users/${uid}`, { method: 'PUT', body: JSON.stringify(attrs) });
+          const data = await res.json();
+          if (!res.ok) return { data: { user: null }, error: new Error(data.message) };
+          return { data: { user: data }, error: null };
+        } catch (e: unknown) { return { data: { user: null }, error: e as Error }; }
+      },
+
+      async deleteUser(id, options) {
+        try {
+          const qs = options?.shouldSoftDelete === false ? '?is_soft_delete=false' : '';
+          await adminFetch(`/users/${id}${qs}`, { method: 'DELETE' });
+          return { data: {}, error: null };
+        } catch (e: unknown) { return { data: {}, error: e as Error }; }
+      },
+
+      async listUsers(params) {
+        try {
+          const qs = params ? `?page=${params.page ?? 1}&per_page=${params.perPage ?? 50}` : '';
+          const res = await adminFetch(`/users${qs}`);
+          const data = await res.json();
+          if (!res.ok) return { data: { users: [] }, error: new Error(data.message) };
+          return { data: { users: data.users }, error: null };
+        } catch (e: unknown) { return { data: { users: [] }, error: e as Error }; }
+      },
+
+      async generateLink(params) {
+        try {
+          const res = await adminFetch('/generate_link', { method: 'POST', body: JSON.stringify(params) });
+          const data = await res.json();
+          if (!res.ok) return { data: null, error: new Error(data.message) };
+          return { data, error: null };
+        } catch (e: unknown) { return { data: null, error: e as Error }; }
+      },
+    };
+  }
+}

package/src/auth/session.ts

@@ -0,0 +1,94 @@
+export interface Session {
+  access_token: string;
+  refresh_token: string;
+  token_type: string;
+  expires_in: number;
+  expires_at: number;
+  user: UserData;
+}
+
+export interface UserData {
+  id: string;
+  aud: string;
+  role: string;
+  email: string;
+  email_confirmed_at?: string;
+  phone?: string;
+  last_sign_in_at?: string;
+  app_metadata: Record<string, unknown>;
+  user_metadata: Record<string, unknown>;
+  identities?: unknown[];
+  created_at: string;
+  updated_at: string;
+}
+
+export type AuthChangeEvent =
+  | 'SIGNED_IN'
+  | 'SIGNED_OUT'
+  | 'TOKEN_REFRESHED'
+  | 'USER_UPDATED'
+  | 'PASSWORD_RECOVERY';
+
+export type AuthListener = (event: AuthChangeEvent, session: Session | null) => void;
+
+export class SessionManager {
+  private storageKey: string;
+  private useLocalStorage: boolean;
+  private memorySession: Session | null = null;
+  private listeners: AuthListener[] = [];
+
+  constructor(storageKey: string, persistSession = true) {
+    this.storageKey = storageKey;
+    this.useLocalStorage = persistSession && (() => {
+      try {
+        if (typeof localStorage === 'undefined') return false;
+        localStorage.getItem('__svarabase_test__');
+        return true;
+      } catch {
+        return false;
+      }
+    })();
+  }
+
+  getSession(): Session | null {
+    if (this.useLocalStorage) {
+      const raw = localStorage.getItem(this.storageKey);
+      if (!raw) return null;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+    return this.memorySession;
+  }
+
+  setSession(session: Session | null): void {
+    if (this.useLocalStorage) {
+      if (session) {
+        localStorage.setItem(this.storageKey, JSON.stringify(session));
+      } else {
+        localStorage.removeItem(this.storageKey);
+      }
+    } else {
+      this.memorySession = session;
+    }
+  }
+
+  notify(event: AuthChangeEvent, session: Session | null): void {
+    this.listeners.forEach(l => l(event, session));
+  }
+
+  subscribe(listener: AuthListener): { data: { subscription: { unsubscribe: () => void } } } {
+    this.listeners.push(listener);
+    return {
+      data: {
+        subscription: {
+          unsubscribe: () => {
+            this.listeners = this.listeners.filter(l => l !== listener);
+          },
+        },
+      },
+    };
+  }
+}

package/src/client.ts

@@ -0,0 +1,66 @@
+import { SvarabaseAuthClient } from './auth';
+import { SvarabaseQueryBuilder, TableQuery } from './db';
+import { SvarabaseStorageClient } from './storage';
+import { SvarabaseRealtimeClient } from './realtime';
+
+export interface SvarabaseClientOptions {
+  auth?: {
+    autoRefreshToken?: boolean;
+    persistSession?: boolean;
+    storageKey?: string;
+  };
+  global?: {
+    headers?: Record<string, string>;
+  };
+  db?: {
+    schema?: string;
+  };
+}
+
+export class SvarabaseClient {
+  protected url: string;
+  protected key: string;
+
+  readonly auth: SvarabaseAuthClient;
+  readonly storage: SvarabaseStorageClient;
+  readonly realtime: SvarabaseRealtimeClient;
+
+  protected _queryBuilder: SvarabaseQueryBuilder;
+
+  constructor(url: string, key: string, options?: SvarabaseClientOptions) {
+    this.url = url.replace(/\/$/, '');
+    this.key = key;
+
+    const getAuthHeader = () => {
+      const session = this.auth['sessionManager']?.getSession?.();
+      if (session?.access_token) return `Bearer ${session.access_token}`;
+      return `Bearer ${this.key}`;
+    };
+
+    this.auth = new SvarabaseAuthClient(this.url, this.key, {
+      autoRefreshToken: options?.auth?.autoRefreshToken,
+      persistSession: options?.auth?.persistSession,
+      storageKey: options?.auth?.storageKey,
+    });
+
+    this._queryBuilder = new SvarabaseQueryBuilder(this.url, this.key, getAuthHeader);
+    this.storage = new SvarabaseStorageClient(this.url, this.key, getAuthHeader);
+    this.realtime = new SvarabaseRealtimeClient();
+  }
+
+  from<T = Record<string, unknown>>(table: string): TableQuery<T> {
+    return this._queryBuilder.from<T>(table);
+  }
+
+  rpc<T = unknown>(functionName: string, params?: Record<string, unknown>, options?: { count?: 'exact'; head?: boolean }) {
+    return this._queryBuilder.rpc<T>(functionName, params ?? {}, options);
+  }
+
+  channel(id: string) {
+    return this.realtime.channel(id);
+  }
+
+  removeChannel(channel: ReturnType<SvarabaseRealtimeClient['channel']>) {
+    return this.realtime.removeChannel(channel);
+  }
+}