vasabase-js 0.0.1

package/dist/index.js

@@ -0,0 +1,1089 @@
+export function createClient(url, key, options) {
+    return new VasabaseClient(url, key, options);
+}
+export class PostgrestError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.name = 'PostgrestError';
+        this.code = code;
+        this.details = details;
+    }
+}
+export class AuthError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.name = 'AuthError';
+        this.code = code;
+        this.details = details;
+    }
+}
+export class FunctionsError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = 'FunctionsError';
+        this.code = code;
+    }
+}
+export class VasabaseClient {
+    constructor(url, key, options) {
+        this.url = url;
+        this.key = key;
+        this.projectRef = options?.projectRef || '';
+        this.auth = new AuthClient(`${url}/auth/v1`, key, this.projectRef);
+        const getAuthHeaders = () => {
+            const h = { apikey: this.key };
+            const tok = this.auth.currentSession?.access_token;
+            if (tok)
+                h['Authorization'] = `Bearer ${tok}`;
+            return h;
+        };
+        this.rest = new PostgrestClient(`${url}/rest/v1`, key, this.projectRef, getAuthHeaders);
+        this.storage = new StorageClient(`${url}/storage/v1`, key, this.projectRef, getAuthHeaders);
+        this.realtime = new RealtimeClient(url, key, this.projectRef);
+        this.functions = new FunctionsClient(`${url}/functions/v1`, key, this.projectRef, getAuthHeaders);
+    }
+    from(table) {
+        return this.rest.from(table);
+    }
+}
+class PostgrestClient {
+    constructor(url, key, projectRef, getAuthHeaders) {
+        this.url = url;
+        this.key = key;
+        this.projectRef = projectRef;
+        this.getAuthHeaders = getAuthHeaders;
+    }
+    from(table) {
+        return new PostgrestQueryBuilder(this.url, this.key, this.projectRef, this.getAuthHeaders, table);
+    }
+}
+class PostgrestQueryBuilder {
+    constructor(url, key, projectRef, getAuthHeaders, table, method = 'GET', query = {}, body = null, headers = {}, notPrefix = '') {
+        this.url = url;
+        this.key = key;
+        this.projectRef = projectRef;
+        this.getAuthHeaders = getAuthHeaders;
+        this.table = table;
+        this.method = method;
+        this.query = { ...query };
+        this.body = body;
+        this.headers = { ...headers };
+        this._notPrefix = notPrefix;
+    }
+    clone(overrides = {}) {
+        return new PostgrestQueryBuilder(this.url, this.key, this.projectRef, this.getAuthHeaders, this.table, overrides.method ?? this.method, overrides.query ?? { ...this.query }, overrides.body !== undefined ? overrides.body : this.body, overrides.headers ?? { ...this.headers }, overrides.notPrefix ?? this._notPrefix);
+    }
+    select(columns = '*') {
+        const q = { ...this.query, select: columns };
+        // If we're on a mutation method (POST/PATCH/DELETE), don't flip to GET;
+        // the execute() method will handle setting Prefer=return=representation
+        if (this.method === 'GET') {
+            return this.clone({ query: q });
+        }
+        return this.clone({ query: q });
+    }
+    insert(data) {
+        return this.clone({
+            method: 'POST',
+            body: data,
+            headers: { ...this.headers, Prefer: 'return=minimal' },
+        });
+    }
+    upsert(data, onConflict) {
+        const q = { ...this.query };
+        if (onConflict)
+            q['on_conflict'] = onConflict;
+        return this.clone({
+            method: 'POST',
+            body: data,
+            query: q,
+            headers: { ...this.headers, Prefer: 'return=minimal,resolution=merge-duplicates' },
+        });
+    }
+    update(data) {
+        return this.clone({
+            method: 'PATCH',
+            body: data,
+            headers: { ...this.headers, Prefer: 'return=minimal' },
+        });
+    }
+    delete() {
+        return this.clone({
+            method: 'DELETE',
+            headers: { ...this.headers, Prefer: 'return=minimal' },
+        });
+    }
+    eq(column, value) {
+        const q = { ...this.query, [column]: `${this._notPrefix}eq.${value}` };
+        return this.clone({ query: q });
+    }
+    neq(column, value) {
+        const q = { ...this.query, [column]: `${this._notPrefix}neq.${value}` };
+        return this.clone({ query: q });
+    }
+    gt(column, value) {
+        const q = { ...this.query, [column]: `${this._notPrefix}gt.${value}` };
+        return this.clone({ query: q });
+    }
+    gte(column, value) {
+        const q = { ...this.query, [column]: `${this._notPrefix}gte.${value}` };
+        return this.clone({ query: q });
+    }
+    lt(column, value) {
+        const q = { ...this.query, [column]: `${this._notPrefix}lt.${value}` };
+        return this.clone({ query: q });
+    }
+    lte(column, value) {
+        const q = { ...this.query, [column]: `${this._notPrefix}lte.${value}` };
+        return this.clone({ query: q });
+    }
+    like(column, pattern) {
+        const q = { ...this.query, [column]: `${this._notPrefix}like.${pattern}` };
+        return this.clone({ query: q });
+    }
+    ilike(column, pattern) {
+        const q = { ...this.query, [column]: `${this._notPrefix}ilike.${pattern}` };
+        return this.clone({ query: q });
+    }
+    is_(column, value) {
+        let suffix;
+        if (value === null)
+            suffix = 'null';
+        else if (value === true)
+            suffix = 'true';
+        else
+            suffix = 'false';
+        const q = { ...this.query, [column]: `${this._notPrefix}is.${suffix}` };
+        return this.clone({ query: q });
+    }
+    isNull(column) {
+        const q = { ...this.query, [column]: `${this._notPrefix}is.null` };
+        return this.clone({ query: q });
+    }
+    in_(column, values) {
+        const q = { ...this.query, [column]: `${this._notPrefix}in.(${values.join(',')})` };
+        return this.clone({ query: q });
+    }
+    contains(column, value) {
+        const q = { ...this.query, [column]: `${this._notPrefix}cs.${JSON.stringify(value)}` };
+        return this.clone({ query: q });
+    }
+    containedBy(column, value) {
+        const q = { ...this.query, [column]: `${this._notPrefix}cd.${JSON.stringify(value)}` };
+        return this.clone({ query: q });
+    }
+    match(column, query) {
+        const q = { ...this.query, [column]: `${this._notPrefix}match.${JSON.stringify(query)}` };
+        return this.clone({ query: q });
+    }
+    imatch(column, query) {
+        const q = { ...this.query, [column]: `${this._notPrefix}imatch.${JSON.stringify(query)}` };
+        return this.clone({ query: q });
+    }
+    or(filter) {
+        const existing = this.query['or'] || '';
+        const newOr = existing ? `(${existing}),${filter}` : filter;
+        const q = { ...this.query, or: newOr };
+        return this.clone({ query: q });
+    }
+    and(filter) {
+        const existing = this.query['and'] || '';
+        const newAnd = existing ? `(${existing}),${filter}` : filter;
+        const q = { ...this.query, and: newAnd };
+        return this.clone({ query: q });
+    }
+    not_() {
+        return this.clone({ notPrefix: 'not.' });
+    }
+    order(column, ascending = true) {
+        const q = { ...this.query, order: `${column}.${ascending ? 'asc' : 'desc'}` };
+        return this.clone({ query: q });
+    }
+    limit(n) {
+        const q = { ...this.query, limit: String(n) };
+        return this.clone({ query: q });
+    }
+    offset(n) {
+        const q = { ...this.query, offset: String(n) };
+        return this.clone({ query: q });
+    }
+    range(from, to) {
+        const h = { ...this.headers, Range: `${from}-${to}` };
+        return this.clone({ headers: h });
+    }
+    single() {
+        const h = { ...this.headers, Accept: 'application/vnd.pgrst.object+json' };
+        return this.clone({ headers: h });
+    }
+    maybeSingle() {
+        const h = { ...this.headers, Accept: 'application/vnd.pgrst.object+json' };
+        // maybeSingle converts 406 to null, handled in execute
+        return this.clone({ headers: h });
+    }
+    then(onFulfilled, onRejected) {
+        return this.execute().then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.execute().catch(onRejected);
+    }
+    async execute() {
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(this.query)) {
+            params.set(k, v);
+        }
+        // Handle select on mutations -> Prefer return=representation
+        let headers = {
+            'apikey': this.key,
+            ...this.getAuthHeaders(),
+            ...this.headers,
+        };
+        if ((this.method === 'POST' || this.method === 'PATCH' || this.method === 'DELETE') && this.query['select']) {
+            const existingPrefer = this.headers['Prefer'] || '';
+            const hasResolution = existingPrefer.includes('resolution=merge-duplicates');
+            headers['Prefer'] = hasResolution
+                ? 'return=representation,resolution=merge-duplicates'
+                : 'return=representation';
+        }
+        if (this.projectRef) {
+            headers['x-project-ref'] = this.projectRef;
+        }
+        if (this.method !== 'GET' && this.method !== 'DELETE' && this.body !== null) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const url = `${this.url}/${this.table}?${params.toString()}`;
+        const fetchOpts = {
+            method: this.method,
+            headers,
+        };
+        if (this.method !== 'GET' && this.method !== 'DELETE' && this.body !== null) {
+            fetchOpts.body = JSON.stringify(this.body);
+        }
+        try {
+            const res = await fetch(url, fetchOpts);
+            // maybeSingle: if 406 Not Acceptable, return null data
+            if (this.headers['Accept'] === 'application/vnd.pgrst.object+json' &&
+                !Object.keys(this.headers).some(k => k === 'Prefer' && this.headers[k] === 'return=representation') &&
+                res.status === 406) {
+                return { data: null, error: null };
+            }
+            const text = await res.text();
+            let data = null;
+            try {
+                data = text ? JSON.parse(text) : null;
+            }
+            catch {
+                data = text;
+            }
+            if (!res.ok) {
+                const errMsg = typeof data?.message === 'string' ? data.message : 'Postgrest request failed';
+                const errCode = data?.code;
+                const errDetails = data?.details;
+                return { data: null, error: new PostgrestError(errMsg, errCode, errDetails) };
+            }
+            return { data, error: null };
+        }
+        catch (e) {
+            return { data: null, error: new PostgrestError(e.message || 'Network error') };
+        }
+    }
+}
+class AuthClient {
+    constructor(url, key, projectRef) {
+        this.currentSession = null;
+        this.currentUser = null;
+        this.listeners = [];
+        this.url = url;
+        this.key = key;
+        this.projectRef = projectRef;
+    }
+    onAuthStateChange(cb) {
+        this.listeners.push(cb);
+        return () => {
+            this.listeners = this.listeners.filter(l => l !== cb);
+        };
+    }
+    emit(event, session) {
+        this.currentSession = session;
+        this.currentUser = session?.user ?? null;
+        for (const cb of this.listeners) {
+            try {
+                cb(event, session);
+            }
+            catch { /* swallow */ }
+        }
+    }
+    getHeaders(token) {
+        const h = {
+            'Content-Type': 'application/json',
+            'apikey': this.key,
+        };
+        if (this.projectRef)
+            h['x-project-ref'] = this.projectRef;
+        if (token)
+            h['Authorization'] = `Bearer ${token}`;
+        return h;
+    }
+    async initialize() {
+        if (typeof localStorage === 'undefined')
+            return;
+        const stored = localStorage.getItem('vasabase_auth_token');
+        if (!stored)
+            return;
+        try {
+            const session = JSON.parse(stored);
+            this.emit('SIGNED_IN', session);
+        }
+        catch {
+            localStorage.removeItem('vasabase_auth_token');
+        }
+    }
+    persist(session) {
+        if (typeof localStorage === 'undefined')
+            return;
+        if (session) {
+            localStorage.setItem('vasabase_auth_token', JSON.stringify(session));
+        }
+        else {
+            localStorage.removeItem('vasabase_auth_token');
+        }
+    }
+    async signUp(body) {
+        const res = await fetch(`${this.url}/signup`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'Signup failed', data?.code, data?.details) };
+        }
+        const session = data;
+        this.persist(session);
+        this.emit('SIGNED_IN', session);
+        return { data: session, error: null };
+    }
+    async signInWithPassword(body) {
+        const res = await fetch(`${this.url}/token?grant_type=password`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'Sign-in failed', data?.code, data?.details) };
+        }
+        const session = data;
+        this.persist(session);
+        this.emit('SIGNED_IN', session);
+        return { data: session, error: null };
+    }
+    signInWithOAuth(options) {
+        const params = new URLSearchParams();
+        params.set('provider', options.provider);
+        if (options.redirectTo)
+            params.set('redirect_to', options.redirectTo);
+        if (options.codeChallenge)
+            params.set('code_challenge', options.codeChallenge);
+        return `${this.url}/authorize?${params.toString()}`;
+    }
+    async signInWithOtp(body) {
+        const res = await fetch(`${this.url}/otp`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { error: new AuthError(data?.message || 'OTP send failed', data?.code, data?.details) };
+        }
+        return { error: null };
+    }
+    async signInWithIdToken(body) {
+        const res = await fetch(`${this.url}/token?grant_type=id_token`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({ provider: body.provider, id_token: body.idToken }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'ID token sign-in failed', data?.code, data?.details) };
+        }
+        const session = data;
+        this.persist(session);
+        this.emit('SIGNED_IN', session);
+        return { data: session, error: null };
+    }
+    async signInAnonymously() {
+        const res = await fetch(`${this.url}/signup`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({}),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'Anonymous sign-in failed', data?.code, data?.details) };
+        }
+        const session = data;
+        this.persist(session);
+        this.emit('SIGNED_IN', session);
+        return { data: session, error: null };
+    }
+    async reauthenticate(body) {
+        const res = await fetch(`${this.url}/token?grant_type=password`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'Reauthentication failed', data?.code, data?.details) };
+        }
+        const session = data;
+        this.persist(session);
+        this.emit('TOKEN_REFRESHED', session);
+        return { data: session, error: null };
+    }
+    async signOut() {
+        const token = this.currentSession?.access_token;
+        const res = await fetch(`${this.url}/logout`, {
+            method: 'POST',
+            headers: this.getHeaders(token),
+        });
+        this.persist(null);
+        this.emit('SIGNED_OUT', null);
+        if (!res.ok) {
+            const data = await res.json().catch(() => null);
+            return { error: new AuthError(data?.message || 'Sign-out failed', data?.code, data?.details) };
+        }
+        return { error: null };
+    }
+    setAuth(token) {
+        const payload = parseJwt(token);
+        const session = {
+            access_token: token,
+            expires_in: payload.exp ? payload.exp - Math.floor(Date.now() / 1000) : 3600,
+            user: {
+                id: payload.sub || '',
+                email: payload.email || '',
+                user_metadata: payload.user_metadata,
+            },
+        };
+        this.persist(session);
+        this.emit('SIGNED_IN', session);
+    }
+    setSession(session) {
+        this.persist(session);
+        this.emit('SIGNED_IN', session);
+    }
+    async refreshSession() {
+        const refreshToken = this.currentSession?.refresh_token;
+        if (!refreshToken) {
+            return { data: null, error: new AuthError('No refresh token available') };
+        }
+        const res = await fetch(`${this.url}/token?grant_type=refresh_token`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({ refresh_token: refreshToken }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'Refresh failed', data?.code, data?.details) };
+        }
+        const session = data;
+        this.persist(session);
+        this.emit('TOKEN_REFRESHED', session);
+        return { data: session, error: null };
+    }
+    async updateUser(attributes, options) {
+        const token = this.currentSession?.access_token;
+        const body = { ...attributes };
+        if (options?.emailRedirectTo)
+            body['email_redirect_to'] = options.emailRedirectTo;
+        const res = await fetch(`${this.url}/user`, {
+            method: 'PUT',
+            headers: this.getHeaders(token),
+            body: JSON.stringify(body),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'Update user failed', data?.code, data?.details) };
+        }
+        if (this.currentSession) {
+            this.currentSession.user = data;
+            this.currentUser = data;
+            this.persist(this.currentSession);
+        }
+        this.emit('USER_UPDATED', this.currentSession);
+        return { data: data, error: null };
+    }
+    async resetPasswordForEmail(email, options) {
+        const body = { email };
+        if (options?.redirectTo)
+            body['redirect_to'] = options.redirectTo;
+        const res = await fetch(`${this.url}/recover`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { error: new AuthError(data?.message || 'Password reset failed', data?.code, data?.details) };
+        }
+        return { error: null };
+    }
+    async enroll(body) {
+        const token = this.currentSession?.access_token;
+        const res = await fetch(`${this.url}/factors`, {
+            method: 'POST',
+            headers: this.getHeaders(token),
+            body: JSON.stringify({ friendly_name: body.friendlyName }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'MFA enroll failed', data?.code, data?.details) };
+        }
+        return { data: data, error: null };
+    }
+    async verifyFactor(body) {
+        const token = this.currentSession?.access_token;
+        const res = await fetch(`${this.url}/factors/${body.factorId}/verify`, {
+            method: 'POST',
+            headers: this.getHeaders(token),
+            body: JSON.stringify({ code: body.code, challenge_id: body.challengeId }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'MFA verify failed', data?.code, data?.details) };
+        }
+        return { data, error: null };
+    }
+    async createChallenge(body) {
+        const token = this.currentSession?.access_token;
+        const res = await fetch(`${this.url}/factors/${body.factorId}/challenge`, {
+            method: 'POST',
+            headers: this.getHeaders(token),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'MFA challenge failed', data?.code, data?.details) };
+        }
+        return { data, error: null };
+    }
+    async verifyChallenge(body) {
+        const token = this.currentSession?.access_token;
+        const res = await fetch(`${this.url}/verify`, {
+            method: 'POST',
+            headers: this.getHeaders(token),
+            body: JSON.stringify({ challenge_id: body.challengeId, code: body.code }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'MFA verify challenge failed', data?.code, data?.details) };
+        }
+        return { data, error: null };
+    }
+    async unenroll(body) {
+        const token = this.currentSession?.access_token;
+        const res = await fetch(`${this.url}/factors/${body.factorId}`, {
+            method: 'DELETE',
+            headers: this.getHeaders(token),
+        });
+        if (!res.ok) {
+            const data = await res.json().catch(() => null);
+            return { error: new AuthError(data?.message || 'MFA unenroll failed', data?.code, data?.details) };
+        }
+        return { error: null };
+    }
+    async listFactors() {
+        const token = this.currentSession?.access_token;
+        const res = await fetch(`${this.url}/factors`, {
+            method: 'GET',
+            headers: this.getHeaders(token),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new AuthError(data?.message || 'MFA list factors failed', data?.code, data?.details) };
+        }
+        return { data: data, error: null };
+    }
+}
+function parseJwt(token) {
+    try {
+        const base64Url = token.split('.')[1];
+        const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+        const jsonPayload = decodeURIComponent(atob(base64)
+            .split('')
+            .map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+            .join(''));
+        return JSON.parse(jsonPayload);
+    }
+    catch {
+        return {};
+    }
+}
+class StorageClient {
+    constructor(url, key, projectRef, getAuthHeaders) {
+        this.url = url;
+        this.key = key;
+        this.projectRef = projectRef;
+        this.getAuthHeaders = getAuthHeaders;
+    }
+    from(bucketId) {
+        return new StorageFileApi(this.url, this.key, this.projectRef, this.getAuthHeaders, bucketId);
+    }
+    async createBucket(id, options) {
+        const headers = {
+            'Content-Type': 'application/json',
+            'apikey': this.key,
+            ...this.getAuthHeaders(),
+        };
+        if (this.projectRef)
+            headers['x-project-ref'] = this.projectRef;
+        const res = await fetch(`${this.url}/bucket`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ id, ...options }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new PostgrestError(data?.message || 'Create bucket failed') };
+        }
+        return { data, error: null };
+    }
+    async deleteBucket(id) {
+        const headers = {
+            'apikey': this.key,
+            ...this.getAuthHeaders(),
+        };
+        if (this.projectRef)
+            headers['x-project-ref'] = this.projectRef;
+        const res = await fetch(`${this.url}/bucket/${id}`, {
+            method: 'DELETE',
+            headers,
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new PostgrestError(data?.message || 'Delete bucket failed') };
+        }
+        return { data, error: null };
+    }
+    async listBuckets() {
+        const headers = {
+            'apikey': this.key,
+            ...this.getAuthHeaders(),
+        };
+        if (this.projectRef)
+            headers['x-project-ref'] = this.projectRef;
+        const res = await fetch(`${this.url}/bucket`, { headers });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new PostgrestError(data?.message || 'List buckets failed') };
+        }
+        return { data, error: null };
+    }
+}
+class StorageFileApi {
+    constructor(url, key, projectRef, getAuthHeaders, bucketId) {
+        this.url = url;
+        this.key = key;
+        this.projectRef = projectRef;
+        this.getAuthHeaders = getAuthHeaders;
+        this.bucketId = bucketId;
+    }
+    getHeaders() {
+        const h = {
+            apikey: this.key,
+            ...this.getAuthHeaders(),
+        };
+        if (this.projectRef)
+            h['x-project-ref'] = this.projectRef;
+        return h;
+    }
+    async upload(path, file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        const headers = this.getHeaders();
+        // Let browser set Content-Type for FormData
+        delete headers['Content-Type'];
+        const res = await fetch(`${this.url}/object/${this.bucketId}/${path}`, { method: 'POST', headers, body: formData });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new PostgrestError(data?.message || 'Upload failed') };
+        }
+        return { data, error: null };
+    }
+    async download(path) {
+        const res = await fetch(`${this.url}/object/${this.bucketId}/${path}`, { headers: this.getHeaders() });
+        if (!res.ok) {
+            const errData = await res.json().catch(() => ({}));
+            return { data: null, error: new PostgrestError(errData.message || 'Download failed') };
+        }
+        const blob = await res.blob();
+        return { data: blob, error: null };
+    }
+    async remove(paths) {
+        const headers = { ...this.getHeaders(), 'Content-Type': 'application/json' };
+        const res = await fetch(`${this.url}/object/${this.bucketId}`, {
+            method: 'DELETE',
+            headers,
+            body: JSON.stringify({ prefixes: paths }),
+        });
+        if (!res.ok) {
+            const errData = await res.json().catch(() => ({}));
+            return { error: new PostgrestError(errData.message || 'Remove failed') };
+        }
+        return { error: null };
+    }
+    async move(fromPath, toPath) {
+        const headers = { ...this.getHeaders(), 'Content-Type': 'application/json' };
+        const res = await fetch(`${this.url}/object/move`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                bucketId: this.bucketId,
+                sourceKey: fromPath,
+                destinationKey: toPath,
+            }),
+        });
+        if (!res.ok) {
+            const errData = await res.json().catch(() => ({}));
+            return { error: new PostgrestError(errData.message || 'Move failed') };
+        }
+        return { error: null };
+    }
+    async copy(fromPath, toPath) {
+        const headers = { ...this.getHeaders(), 'Content-Type': 'application/json' };
+        const res = await fetch(`${this.url}/object/copy`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                bucketId: this.bucketId,
+                sourceKey: fromPath,
+                destinationKey: toPath,
+            }),
+        });
+        if (!res.ok) {
+            const errData = await res.json().catch(() => ({}));
+            return { error: new PostgrestError(errData.message || 'Copy failed') };
+        }
+        return { error: null };
+    }
+    async createSignedUrl(path, expiresIn = 3600) {
+        const headers = { ...this.getHeaders(), 'Content-Type': 'application/json' };
+        const res = await fetch(`${this.url}/object/sign/${this.bucketId}/${path}`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ expiresIn }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            return { data: null, error: new PostgrestError(data?.message || 'Create signed URL failed') };
+        }
+        return { data: data?.signedURL || data?.signedUrl || data?.url || null, error: null };
+    }
+    getPublicUrl(path, download) {
+        let url = `${this.url}/object/public/${this.bucketId}/${path}`;
+        if (download)
+            url += '?download';
+        return url;
+    }
+}
+class RealtimeClient {
+    constructor(url, key, projectRef) {
+        this.ws = null;
+        this.channels = new Map();
+        this.reconnectTimer = null;
+        this.connected = false;
+        this.url = url;
+        this.key = key;
+        this.projectRef = projectRef;
+    }
+    connect() {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN)
+            return;
+        const wsUrl = this.url.replace(/^http/, 'ws') +
+            `/realtime/v1?apikey=${encodeURIComponent(this.key)}` +
+            (this.projectRef ? `&project_ref=${encodeURIComponent(this.projectRef)}` : '');
+        this.ws = new WebSocket(wsUrl);
+        this.ws.onopen = () => {
+            this.connected = true;
+            // Re-subscribe channels
+            for (const ch of this.channels.values()) {
+                if (ch.subscribed)
+                    ch.resubscribe();
+            }
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const msg = JSON.parse(event.data);
+                const topic = msg.topic || '';
+                if (topic.startsWith('realtime:')) {
+                    const channelName = topic.replace('realtime:', '');
+                    const ch = this.channels.get(channelName);
+                    if (ch)
+                        ch.handleMessage(msg);
+                }
+            }
+            catch { /* ignore */ }
+        };
+        this.ws.onclose = () => {
+            this.connected = false;
+            // Auto-reconnect
+            this.reconnectTimer = setTimeout(() => this.connect(), 5000);
+        };
+        this.ws.onerror = () => {
+            this.ws?.close();
+        };
+    }
+    disconnect() {
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        for (const ch of this.channels.values()) {
+            ch.unsubscribe();
+        }
+        this.channels.clear();
+        this.ws?.close();
+        this.ws = null;
+        this.connected = false;
+    }
+    on(table) {
+        return {
+            subscribe: (cb) => {
+                const sub = new RealtimeSubscription(this, table, '*', cb);
+                sub.subscribe();
+                return sub;
+            },
+        };
+    }
+    channel(table, filter) {
+        const channelName = filter
+            ? `${table}:${filter.event}:${filter.schema || 'public'}:${filter.filter || ''}`
+            : `${table}:*`;
+        const existing = this.channels.get(channelName);
+        if (existing)
+            return existing;
+        const ch = new RealtimeChannel(this, channelName, table, filter);
+        this.channels.set(channelName, ch);
+        return ch;
+    }
+    send(payload) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(payload));
+        }
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    removeChannel(name) {
+        this.channels.delete(name);
+    }
+}
+class RealtimeChannel {
+    constructor(client, name, table, filter) {
+        this._subscribed = false;
+        this.cdcCallbacks = [];
+        this.presenceCallbacks = [];
+        this.broadcastCallbacks = [];
+        this.presenceState = {};
+        this.client = client;
+        this.name = name;
+        this.table = table;
+        this.filter = filter;
+    }
+    get subscribed() {
+        return this._subscribed;
+    }
+    subscribe() {
+        if (this._subscribed)
+            return this;
+        this._subscribed = true;
+        if (this.client.isConnected) {
+            this.resubscribe();
+        }
+        else {
+            this.client.connect();
+        }
+        return this;
+    }
+    resubscribe() {
+        // Send CDC subscription
+        if (this.cdcCallbacks.length > 0 || !this.filter) {
+            const event = this.filter?.event || '*';
+            const schema = this.filter?.schema || 'public';
+            const payload = {
+                event: 'phx_join',
+                topic: `realtime:${this.name}`,
+                payload: {
+                    access_token: '',
+                    config: {
+                        broadcast: { self: false },
+                        presence: { key: '' },
+                        postgres_changes: [{
+                                event,
+                                schema,
+                                table: this.table,
+                                filter: this.filter?.filter || null,
+                            }],
+                    },
+                },
+                ref: this.name,
+            };
+            this.client.send(payload);
+        }
+    }
+    unsubscribe() {
+        this._subscribed = false;
+        if (this.client.isConnected) {
+            this.client.send({
+                event: 'phx_leave',
+                topic: `realtime:${this.name}`,
+                ref: this.name,
+            });
+        }
+        this.cdcCallbacks = [];
+        this.presenceCallbacks = [];
+        this.broadcastCallbacks = [];
+        this.client.removeChannel(this.name);
+    }
+    on(event, cb) {
+        this.cdcCallbacks.push(cb);
+        const sub = new RealtimeSubscription(this.client, this.table, event, cb);
+        if (this._subscribed) {
+            sub._setActive(true);
+        }
+        return sub;
+    }
+    onPresence(cb) {
+        this.presenceCallbacks.push(cb);
+        return () => {
+            this.presenceCallbacks = this.presenceCallbacks.filter(c => c !== cb);
+        };
+    }
+    onBroadcast(eventOrCb, cb) {
+        const callback = typeof eventOrCb === 'function' ? eventOrCb : cb;
+        this.broadcastCallbacks.push(callback);
+        return () => {
+            this.broadcastCallbacks = this.broadcastCallbacks.filter(c => c !== callback);
+        };
+    }
+    broadcast(event, payload) {
+        this.client.send({
+            event: 'broadcast',
+            topic: `realtime:${this.name}`,
+            payload: { event, payload: payload || {} },
+            ref: this.name,
+        });
+    }
+    track(userState) {
+        this.presenceState = userState;
+        this.client.send({
+            event: 'presence',
+            topic: `realtime:${this.name}`,
+            payload: userState,
+            ref: this.name,
+        });
+    }
+    get stream() {
+        return {
+            on: (event, cb) => {
+                this.broadcastCallbacks.push(cb);
+                return () => {
+                    this.broadcastCallbacks = this.broadcastCallbacks.filter(c => c !== cb);
+                };
+            },
+        };
+    }
+    handleMessage(msg) {
+        const event = msg.event;
+        if (event === 'postgres_changes' || event === 'cdc') {
+            const payload = msg.payload;
+            for (const cb of this.cdcCallbacks) {
+                try {
+                    cb(payload);
+                }
+                catch { /* swallow */ }
+            }
+        }
+        else if (event === 'presence_state' || event === 'presence_diff') {
+            for (const cb of this.presenceCallbacks) {
+                try {
+                    cb(msg.payload);
+                }
+                catch { /* swallow */ }
+            }
+        }
+        else if (event === 'broadcast') {
+            for (const cb of this.broadcastCallbacks) {
+                try {
+                    cb(msg.payload);
+                }
+                catch { /* swallow */ }
+            }
+        }
+    }
+}
+class RealtimeSubscription {
+    constructor(client, table, event, callback) {
+        this._active = false;
+        this.client = client;
+        this.table = table;
+        this.event = event;
+        this.callback = callback;
+    }
+    _setActive(active) {
+        this._active = active;
+    }
+    subscribe() {
+        const ch = this.client.channel(this.table, {
+            event: this.event,
+        });
+        ch.on(this.event, this.callback);
+        ch.subscribe();
+        this._active = true;
+    }
+    unsubscribe() {
+        this._active = false;
+    }
+}
+class FunctionsClient {
+    constructor(url, key, projectRef, getAuthHeaders) {
+        this.url = url;
+        this.key = key;
+        this.projectRef = projectRef;
+        this.getAuthHeaders = getAuthHeaders;
+    }
+    async invoke(functionName, options) {
+        const headers = {
+            'apikey': this.key,
+            ...this.getAuthHeaders(),
+        };
+        if (this.projectRef)
+            headers['x-project-ref'] = this.projectRef;
+        const fetchOpts = { method: 'POST', headers };
+        if (options?.body !== undefined) {
+            headers['Content-Type'] = 'application/json';
+            fetchOpts.body = JSON.stringify(options.body);
+        }
+        try {
+            const res = await fetch(`${this.url}/${functionName}`, fetchOpts);
+            const text = await res.text();
+            let data = null;
+            try {
+                data = text ? JSON.parse(text) : null;
+            }
+            catch {
+                data = text;
+            }
+            if (!res.ok) {
+                return {
+                    data: null,
+                    error: new FunctionsError(typeof data?.message === 'string' ? data.message : 'Function invocation failed', res.status),
+                };
+            }
+            return { data, error: null };
+        }
+        catch (e) {
+            return { data: null, error: new FunctionsError(e.message || 'Network error') };
+        }
+    }
+}