aurabase-js 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "aurabase-js",
+  "version": "0.1.0",
+  "description": "AuraBase client library - Supabase-style SDK for AuraBase",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "aurabase",
+    "database",
+    "rest",
+    "client",
+    "supabase-like"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  }
+}

package/src/AuraBaseClient.ts

@@ -0,0 +1,271 @@
+import { AuraBaseClientOptions } from './types';
+import { QueryBuilder } from './QueryBuilder';
+import { AuthClient } from './Auth';
+
+export class AuraBaseClient {
+  private url: string;
+  private anonKey: string;
+  private accessToken: string | null = null;
+  private customHeaders: Record<string, string>;
+  public auth: AuthClient;
+
+  constructor(options: AuraBaseClientOptions) {
+    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: string | null): void {
+    this.accessToken = token;
+  }
+
+  /**
+   * Get the current access token
+   */
+  getAccessToken(): string | null {
+    return this.accessToken;
+  }
+
+  /**
+   * Query a table
+   * @example
+   * const { data, error } = await client.from('todos').select('*')
+   */
+  from<T = unknown>(tableName: string): QueryBuilder<T> {
+    return new QueryBuilder<T>(
+      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<T = unknown>(
+    functionName: string,
+    params?: Record<string, unknown>
+  ): Promise<{ data: T | null; error: { message: string } | null }> {
+    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: T | null = null;
+      let error: { message: string } | null = 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: string) => new StorageBucket(this.url, this.anonKey, bucket, this.accessToken),
+    };
+  }
+}
+
+/**
+ * Storage bucket operations
+ */
+class StorageBucket {
+  private url: string;
+  private anonKey: string;
+  private bucket: string;
+  private accessToken: string | null;
+
+  constructor(url: string, anonKey: string, bucket: string, accessToken: string | null) {
+    this.url = url;
+    this.anonKey = anonKey;
+    this.bucket = bucket;
+    this.accessToken = accessToken;
+  }
+
+  private getHeaders(): Record<string, string> {
+    const token = this.accessToken || this.anonKey;
+    return {
+      'apikey': this.anonKey,
+      'Authorization': `Bearer ${token}`,
+    };
+  }
+
+  /**
+   * Upload a file
+   */
+  async upload(
+    path: string,
+    file: File | Blob,
+    options?: { contentType?: string; upsert?: boolean }
+  ): Promise<{ data: { path: string } | null; error: { message: string } | null }> {
+    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: string): Promise<{ data: Blob | null; error: { message: string } | null }> {
+    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: string): string {
+    return `${this.url}/storage/v1/object/public/${this.bucket}/${path}`;
+  }
+
+  /**
+   * Delete a file
+   */
+  async remove(paths: string[]): Promise<{ error: { message: string } | null }> {
+    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?: string): Promise<{
+    data: Array<{ name: string; id: string; created_at: string }> | null;
+    error: { message: string } | null;
+  }> {
+    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' },
+      };
+    }
+  }
+}

package/src/Auth.ts

@@ -0,0 +1,329 @@
+import {
+  AuthSession,
+  User,
+  AuthError,
+  SignInWithPasswordCredentials,
+  SignUpCredentials,
+  UpdateUserAttributes,
+  AuthListener,
+  AuthChangeEvent,
+  Subscription,
+} from './types';
+import { AuraBaseApiError } from './errors';
+
+export class AuthClient {
+  private url: string;
+  private anonKey: string;
+  private listeners: Map<string, AuthListener[]> = new Map();
+  private currentSession: AuthSession | null = null;
+  private storageKey: string = 'aurabase_session';
+
+  constructor(url: string, anonKey: string) {
+    this.url = url;
+    this.anonKey = anonKey;
+    this.loadSession();
+  }
+
+  private loadSession(): void {
+    if (typeof window === 'undefined') return;
+
+    try {
+      const stored = localStorage.getItem(this.storageKey);
+      if (stored) {
+        this.currentSession = JSON.parse(stored);
+      }
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  private saveSession(session: AuthSession | null): void {
+    this.currentSession = session;
+
+    if (typeof window === 'undefined') return;
+
+    if (session) {
+      localStorage.setItem(this.storageKey, JSON.stringify(session));
+    } else {
+      localStorage.removeItem(this.storageKey);
+    }
+  }
+
+  private getHeaders(): Record<string, string> {
+    return {
+      'Content-Type': 'application/json',
+      'apikey': this.anonKey,
+    };
+  }
+
+  private emitEvent(event: AuthChangeEvent, session: AuthSession | null): void {
+    const listeners = this.listeners.get(event) || [];
+    listeners.forEach((listener) => listener(event, session));
+
+    // Also emit to '*' listeners
+    const allListeners = this.listeners.get('*') || [];
+    allListeners.forEach((listener) => listener(event, session));
+  }
+
+  /**
+   * Sign in with email and password
+   */
+  async signInWithPassword(credentials: SignInWithPasswordCredentials): Promise<{
+    data: { user: User; session: AuthSession } | null;
+    error: AuthError | null;
+  }> {
+    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: { msg: string }) => e.msg).join(', ')
+            : data.error || 'Login failed';
+
+        return {
+          data: null,
+          error: { error: errorMsg },
+        };
+      }
+
+      const session: AuthSession = {
+        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: SignUpCredentials): Promise<{
+    data: { user: User } | null;
+    error: AuthError | null;
+  }> {
+    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(): Promise<{ error: AuthError | null }> {
+    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(): { data: { session: AuthSession | null } } {
+    return { data: { session: this.currentSession } };
+  }
+
+  /**
+   * Get current user
+   */
+  async getUser(): Promise<{ data: { user: User | null }; error: AuthError | null }> {
+    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: UpdateUserAttributes): Promise<{
+    data: { user: User } | null;
+    error: AuthError | null;
+  }> {
+    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: string): Promise<{ error: AuthError | null }> {
+    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: (event: AuthChangeEvent, session: AuthSession | null) => void
+  ): { data: { subscription: Subscription } } {
+    const addListener = (event: AuthChangeEvent) => {
+      if (!this.listeners.has(event)) {
+        this.listeners.set(event, []);
+      }
+      this.listeners.get(event)!.push(callback);
+    };
+
+    // Subscribe to all events
+    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);
+              }
+            });
+          },
+        },
+      },
+    };
+  }
+}