@svarabase/js 1.0.0

package/dist/esm/auth/index.js

@@ -0,0 +1,277 @@
+import { SessionManager } from './session';
+export class SvarabaseAuthClient {
+    constructor(url, key, options) {
+        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();
+        }
+    }
+    async _fetch(path, init = {}) {
+        const session = this.sessionManager.getSession();
+        const headers = {
+            'Content-Type': 'application/json',
+            apikey: this.key,
+            ...(init.headers ?? {}),
+        };
+        if (session?.access_token) {
+            headers['Authorization'] = `Bearer ${session.access_token}`;
+        }
+        else {
+            headers['Authorization'] = `Bearer ${this.key}`;
+        }
+        return fetch(`${this.url}${path}`, { ...init, headers });
+    }
+    _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() {
+        return { data: { session: this.sessionManager.getSession() }, error: null };
+    }
+    async setSession(params) {
+        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 = { ...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) {
+            return { data: { session: null, user: null }, error: e };
+        }
+    }
+    async signInWithPassword(credentials) {
+        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 = { ...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) {
+            return { data: { user: null, session: null }, error: e };
+        }
+    }
+    async signUp(credentials) {
+        try {
+            const body = {
+                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 = { ...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) {
+            return { data: { user: null, session: null }, error: e };
+        }
+    }
+    async signOut(options) {
+        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) {
+            return { error: e };
+        }
+    }
+    signInWithOAuth(params) {
+        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) {
+        try {
+            const headers = {};
+            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) {
+            return { data: { user: null }, error: e };
+        }
+    }
+    async updateUser(attributes) {
+        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) {
+            return { data: { user: null }, error: e };
+        }
+    }
+    async resetPasswordForEmail(email, options) {
+        try {
+            await this._fetch('/recover', {
+                method: 'POST',
+                body: JSON.stringify({ email, options }),
+            });
+            return { data: {}, error: null };
+        }
+        catch (e) {
+            return { data: {}, error: e };
+        }
+    }
+    async refreshSession(params) {
+        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 = { ...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) {
+            return { data: { session: null, user: null }, error: e };
+        }
+    }
+    onAuthStateChange(callback) {
+        return this.sessionManager.subscribe(callback);
+    }
+    _buildAdminClient() {
+        const adminUrl = `${this.url}/admin`;
+        const key = this.key;
+        const adminFetch = (path, init = {}) => fetch(`${adminUrl}${path}`, {
+            ...init,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${key}`,
+                apikey: key,
+                ...(init.headers ?? {}),
+            },
+        });
+        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) {
+                    return { data: { user: null }, error: e };
+                }
+            },
+            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) {
+                    return { data: { user: null }, error: e };
+                }
+            },
+            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) {
+                    return { data: {}, error: e };
+                }
+            },
+            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) {
+                    return { data: { users: [] }, error: e };
+                }
+            },
+            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) {
+                    return { data: null, error: e };
+                }
+            },
+        };
+    }
+}

package/dist/esm/auth/session.js

@@ -0,0 +1,60 @@
+export class SessionManager {
+    constructor(storageKey, persistSession = true) {
+        this.memorySession = null;
+        this.listeners = [];
+        this.storageKey = storageKey;
+        this.useLocalStorage = persistSession && (() => {
+            try {
+                if (typeof localStorage === 'undefined')
+                    return false;
+                localStorage.getItem('__svarabase_test__');
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })();
+    }
+    getSession() {
+        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) {
+        if (this.useLocalStorage) {
+            if (session) {
+                localStorage.setItem(this.storageKey, JSON.stringify(session));
+            }
+            else {
+                localStorage.removeItem(this.storageKey);
+            }
+        }
+        else {
+            this.memorySession = session;
+        }
+    }
+    notify(event, session) {
+        this.listeners.forEach(l => l(event, session));
+    }
+    subscribe(listener) {
+        this.listeners.push(listener);
+        return {
+            data: {
+                subscription: {
+                    unsubscribe: () => {
+                        this.listeners = this.listeners.filter(l => l !== listener);
+                    },
+                },
+            },
+        };
+    }
+}

package/dist/esm/client.js

@@ -0,0 +1,36 @@
+import { SvarabaseAuthClient } from './auth';
+import { SvarabaseQueryBuilder } from './db';
+import { SvarabaseStorageClient } from './storage';
+import { SvarabaseRealtimeClient } from './realtime';
+export class SvarabaseClient {
+    constructor(url, key, options) {
+        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(table) {
+        return this._queryBuilder.from(table);
+    }
+    rpc(functionName, params, options) {
+        return this._queryBuilder.rpc(functionName, params ?? {}, options);
+    }
+    channel(id) {
+        return this.realtime.channel(id);
+    }
+    removeChannel(channel) {
+        return this.realtime.removeChannel(channel);
+    }
+}

package/dist/esm/db/filterBuilder.js

@@ -0,0 +1,222 @@
+export class FilterBuilder {
+    constructor(url, key, getAuthHeader, table, method = 'GET', body, isUpsert = false, onConflict) {
+        this.url = url;
+        this.key = key;
+        this.getAuthHeader = getAuthHeader;
+        this.state = {
+            table,
+            selectCols: '*',
+            filters: [],
+            orderByStr: null,
+            limitVal: null,
+            offsetVal: null,
+            countMode: null,
+            isHead: false,
+            isSingle: false,
+            isMaybeSingle: false,
+            method,
+            body,
+            isUpsert,
+            onConflict,
+        };
+    }
+    select(cols, options) {
+        this.state.selectCols = cols || '*';
+        if (options?.count)
+            this.state.countMode = options.count;
+        if (options?.head)
+            this.state.isHead = true;
+        return this;
+    }
+    eq(column, value) {
+        this.state.filters.push({ key: column, value: `eq.${value}` });
+        return this;
+    }
+    neq(column, value) {
+        this.state.filters.push({ key: column, value: `neq.${value}` });
+        return this;
+    }
+    gt(column, value) {
+        this.state.filters.push({ key: column, value: `gt.${value}` });
+        return this;
+    }
+    gte(column, value) {
+        this.state.filters.push({ key: column, value: `gte.${value}` });
+        return this;
+    }
+    lt(column, value) {
+        this.state.filters.push({ key: column, value: `lt.${value}` });
+        return this;
+    }
+    lte(column, value) {
+        this.state.filters.push({ key: column, value: `lte.${value}` });
+        return this;
+    }
+    like(column, pattern) {
+        this.state.filters.push({ key: column, value: `like.${pattern}` });
+        return this;
+    }
+    ilike(column, pattern) {
+        this.state.filters.push({ key: column, value: `ilike.${pattern}` });
+        return this;
+    }
+    is(column, value) {
+        this.state.filters.push({ key: column, value: `is.${value}` });
+        return this;
+    }
+    in(column, values) {
+        this.state.filters.push({ key: column, value: `in.(${values.join(',')})` });
+        return this;
+    }
+    contains(column, value) {
+        this.state.filters.push({ key: column, value: `cs.${JSON.stringify(value)}` });
+        return this;
+    }
+    not(column, operator, value) {
+        this.state.filters.push({ key: column, value: `not.${operator}.${value}` });
+        return this;
+    }
+    or(filters, options) {
+        const key = options?.foreignTable ? `${options.foreignTable}.or` : 'or';
+        this.state.filters.push({ key, value: `(${filters})` });
+        return this;
+    }
+    order(column, options) {
+        const dir = options?.ascending === false ? 'desc' : 'asc';
+        const nulls = options?.nullsFirst ? '.nullsfirst' : '';
+        this.state.orderByStr = (this.state.orderByStr ? this.state.orderByStr + ',' : '') + `${column}.${dir}${nulls}`;
+        return this;
+    }
+    limit(count) {
+        this.state.limitVal = count;
+        return this;
+    }
+    range(from, to) {
+        this.state.offsetVal = from;
+        this.state.limitVal = to - from + 1;
+        return this;
+    }
+    single() {
+        this.state.isSingle = true;
+        return this;
+    }
+    maybeSingle() {
+        this.state.isMaybeSingle = true;
+        return this;
+    }
+    then(onfulfilled, onrejected) {
+        return this._execute().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this._execute().catch(onrejected);
+    }
+    buildUrl() {
+        const params = new URLSearchParams();
+        if (this.state.method === 'GET' || this.state.method === 'DELETE') {
+            if (this.state.selectCols && this.state.selectCols !== '*') {
+                params.set('select', this.state.selectCols);
+            }
+            else if (this.state.selectCols) {
+                params.set('select', this.state.selectCols);
+            }
+            for (const { key, value } of this.state.filters) {
+                params.set(key, value);
+            }
+            if (this.state.orderByStr)
+                params.set('order', this.state.orderByStr);
+            if (this.state.limitVal != null)
+                params.set('limit', String(this.state.limitVal));
+            if (this.state.offsetVal != null)
+                params.set('offset', String(this.state.offsetVal));
+        }
+        else {
+            // For POST/PATCH, filters go as query params too
+            for (const { key, value } of this.state.filters) {
+                params.set(key, value);
+            }
+            if (this.state.isUpsert && this.state.onConflict) {
+                params.set('on_conflict', this.state.onConflict);
+            }
+        }
+        const qs = params.toString();
+        return `${this.url}/rest/v1/${this.state.table}${qs ? '?' + qs : ''}`;
+    }
+    buildHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+            apikey: this.key,
+            Authorization: this.getAuthHeader(),
+        };
+        const prefer = [];
+        if (this.state.countMode)
+            prefer.push(`count=${this.state.countMode}`);
+        if (this.state.isUpsert)
+            prefer.push('resolution=merge-duplicates');
+        if (prefer.length > 0)
+            headers['Prefer'] = prefer.join(',');
+        if (this.state.isHead)
+            headers['method'] = 'HEAD';
+        return headers;
+    }
+    async _execute() {
+        const url = this.buildUrl();
+        const headers = this.buildHeaders();
+        const init = {
+            method: this.state.method,
+            headers,
+        };
+        if (this.state.body !== undefined && (this.state.method === 'POST' || this.state.method === 'PATCH')) {
+            init.body = JSON.stringify(this.state.body);
+        }
+        // Use HEAD for count-only
+        if (this.state.isHead) {
+            init.method = 'HEAD';
+        }
+        const res = await fetch(url, init);
+        const contentRange = res.headers.get('Content-Range');
+        const count = contentRange ? parseInt(contentRange.split('/')[1]) : null;
+        if (this.state.isHead) {
+            return { data: null, error: null, count, status: res.status, statusText: res.statusText };
+        }
+        if (!res.ok) {
+            const errData = await res.json().catch(() => ({}));
+            return {
+                data: null,
+                error: {
+                    message: (errData.message ?? errData.error_description ?? 'Query failed'),
+                    code: String(res.status),
+                    details: (errData.details ?? ''),
+                    hint: (errData.hint ?? ''),
+                },
+                count: null,
+                status: res.status,
+                statusText: res.statusText,
+            };
+        }
+        const raw = await res.json();
+        if (this.state.isSingle) {
+            if (!raw || (Array.isArray(raw) && raw.length === 0)) {
+                return {
+                    data: null,
+                    error: { message: 'JSON object requested, multiple (or no) rows returned', code: 'PGRST116', details: '', hint: '' },
+                    count,
+                    status: 406,
+                    statusText: 'Not Acceptable',
+                };
+            }
+            const single = Array.isArray(raw) ? raw[0] : raw;
+            return { data: single, error: null, count, status: res.status, statusText: res.statusText };
+        }
+        if (this.state.isMaybeSingle) {
+            const single = Array.isArray(raw) ? (raw[0] ?? null) : raw;
+            return { data: single, error: null, count, status: res.status, statusText: res.statusText };
+        }
+        return {
+            data: (Array.isArray(raw) ? raw : [raw]),
+            error: null,
+            count,
+            status: res.status,
+            statusText: res.statusText,
+        };
+    }
+}

package/dist/esm/db/index.js

@@ -0,0 +1,61 @@
+import { FilterBuilder } from './filterBuilder';
+export class SvarabaseQueryBuilder {
+    constructor(url, key, getAuthHeader) {
+        this.url = url;
+        this.key = key;
+        this.getAuthHeader = getAuthHeader;
+    }
+    from(table) {
+        return new TableQuery(this.url, this.key, this.getAuthHeader, table);
+    }
+    async rpc(functionName, params = {}, options) {
+        try {
+            const res = await fetch(`${this.url}/rest/v1/rpc/${functionName}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    apikey: this.key,
+                    Authorization: this.getAuthHeader(),
+                    ...(options?.count ? { Prefer: `count=${options.count}` } : {}),
+                },
+                body: JSON.stringify(params),
+            });
+            const contentRange = res.headers.get('Content-Range');
+            const count = contentRange ? parseInt(contentRange.split('/')[1]) : null;
+            if (!res.ok) {
+                const errData = await res.json().catch(() => ({}));
+                return { data: null, error: new Error((errData.message ?? 'RPC failed')), count };
+            }
+            const data = await res.json();
+            return { data, error: null, count };
+        }
+        catch (e) {
+            return { data: null, error: e };
+        }
+    }
+}
+export class TableQuery {
+    constructor(url, key, getAuthHeader, table) {
+        this.url = url;
+        this.key = key;
+        this.getAuthHeader = getAuthHeader;
+        this.table = table;
+    }
+    select(cols = '*', options) {
+        const fb = new FilterBuilder(this.url, this.key, this.getAuthHeader, this.table, 'GET');
+        return fb.select(cols, options);
+    }
+    insert(values, options) {
+        return new FilterBuilder(this.url, this.key, this.getAuthHeader, this.table, 'POST', values);
+    }
+    upsert(values, options) {
+        return new FilterBuilder(this.url, this.key, this.getAuthHeader, this.table, 'POST', values, true, options?.onConflict);
+    }
+    update(values, options) {
+        return new FilterBuilder(this.url, this.key, this.getAuthHeader, this.table, 'PATCH', values);
+    }
+    delete(options) {
+        return new FilterBuilder(this.url, this.key, this.getAuthHeader, this.table, 'DELETE');
+    }
+}
+export { FilterBuilder };

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+export { SvarabaseClient } from './client';
+export { SvarabaseAuthClient } from './auth';
+export { SvarabaseQueryBuilder } from './db';
+export { SvarabaseStorageClient } from './storage';
+export { SvarabaseRealtimeClient } from './realtime';
+import { SvarabaseClient } from './client';
+// Drop-in replacement for @supabase/supabase-js createClient
+export function createClient(supabaseUrl, supabaseKey, options) {
+    return new SvarabaseClient(supabaseUrl, supabaseKey, options);
+}
+export default createClient;

package/dist/esm/realtime/index.js

@@ -0,0 +1,23 @@
+// Realtime stub - Yesvara uses Socket.IO instead of Supabase Realtime
+// This stub provides API compatibility without actual websocket functionality
+export class RealtimeChannel {
+    constructor(channelId) {
+        this.channelId = channelId;
+    }
+    on(_type, _filter, _callback) {
+        return this;
+    }
+    subscribe(_callback) {
+        return this;
+    }
+    unsubscribe() {
+        return Promise.resolve('ok');
+    }
+}
+export class SvarabaseRealtimeClient {
+    channel(channelId) {
+        return new RealtimeChannel(channelId);
+    }
+    removeChannel(_channel) { }
+    removeAllChannels() { }
+}