@luxdb/sdk 1.2.1 → 1.4.1

package/dist/esm/auth.js

@@ -0,0 +1,500 @@
+import { err, ok, toLuxError } from './utils.js';
+export class LuxAuthClient {
+    constructor(options = {}) {
+        this.currentSession = null;
+        this.loadedSession = false;
+        this.refreshTimer = null;
+        this.listeners = new Set();
+        this.httpUrl = options.httpUrl?.replace(/\/+$/, '');
+        this.apiKey = options.apiKey;
+        this.authToken = options.authToken;
+        this.fetchImpl = resolveFetch(options.fetch);
+        this.persistSession = options.persistSession ?? false;
+        this.autoRefreshToken = options.autoRefreshToken ?? this.persistSession;
+        this.storage = options.storage === undefined ? defaultBrowserStorage() : options.storage;
+        this.storageKey = options.storageKey ?? 'lux.auth.session';
+        this.refreshMarginSeconds = options.refreshMarginSeconds ?? 60;
+        if (this.authToken) {
+            this.currentSession = null;
+        }
+    }
+    async getSession() {
+        try {
+            return ok({ session: await this.getSessionValue() });
+        }
+        catch (error) {
+            return err('LUX_AUTH_SESSION_ERROR', 'Failed to get auth session', toLuxError(error));
+        }
+    }
+    async getSessionValue() {
+        await this.loadStoredSession();
+        if (this.currentSession && isExpired(this.currentSession, this.refreshMarginSeconds)) {
+            if (this.autoRefreshToken && this.currentSession.refresh_token) {
+                const refreshed = await this.refreshSession(this.currentSession.refresh_token);
+                return refreshed.data?.session ?? null;
+            }
+            await this.clearSessionValue();
+            return null;
+        }
+        return this.currentSession;
+    }
+    async getAccessToken() {
+        const session = await this.getSessionValue();
+        return session?.access_token ?? this.authToken;
+    }
+    async setSession(session) {
+        try {
+            return ok({ session: await this.setSessionValue(session) });
+        }
+        catch (error) {
+            return err('LUX_AUTH_SESSION_ERROR', 'Failed to set auth session', toLuxError(error));
+        }
+    }
+    async setSessionValue(session) {
+        if (typeof session === 'string') {
+            this.authToken = session;
+            this.currentSession = null;
+            return null;
+        }
+        if (!session) {
+            await this.clearSessionValue();
+            return null;
+        }
+        await this.saveSession(normalizeSession(session), 'SESSION_UPDATED');
+        return this.currentSession;
+    }
+    async clearSession() {
+        try {
+            await this.clearSessionValue();
+            return ok(null);
+        }
+        catch (error) {
+            return err('LUX_AUTH_SESSION_ERROR', 'Failed to clear auth session', toLuxError(error));
+        }
+    }
+    async clearSessionValue() {
+        this.authToken = undefined;
+        this.currentSession = null;
+        this.loadedSession = true;
+        this.clearRefreshTimer();
+        if (this.persistSession && this.storage) {
+            await this.storage.removeItem(this.storageKey);
+        }
+        this.emit('SIGNED_OUT', null);
+    }
+    onAuthStateChange(callback) {
+        this.listeners.add(callback);
+        void this.getSessionValue().then((session) => callback('INITIAL_SESSION', session));
+        return {
+            unsubscribe: () => {
+                this.listeners.delete(callback);
+            },
+        };
+    }
+    async signUp(options) {
+        try {
+            const session = await this.requestRaw('/auth/v1/signup', {
+                method: 'POST',
+                body: JSON.stringify({
+                    email: options.email,
+                    password: options.password,
+                    data: options.data,
+                }),
+                apiKey: true,
+            });
+            await this.saveSession(normalizeSession(session), 'SIGNED_IN');
+            return ok({ session: this.currentSession, user: this.currentSession.user });
+        }
+        catch (error) {
+            return err('LUX_AUTH_SIGNUP_ERROR', 'Failed to sign up', toLuxError(error));
+        }
+    }
+    async signInWithPassword(options) {
+        try {
+            const session = await this.requestRaw('/auth/v1/token', {
+                method: 'POST',
+                body: JSON.stringify({
+                    grant_type: 'password',
+                    email: options.email,
+                    password: options.password,
+                }),
+                apiKey: true,
+            });
+            await this.saveSession(normalizeSession(session), 'SIGNED_IN');
+            return ok({ session: this.currentSession, user: this.currentSession.user });
+        }
+        catch (error) {
+            return err('LUX_AUTH_SIGNIN_ERROR', 'Failed to sign in', toLuxError(error));
+        }
+    }
+    async signInWithOAuth(options) {
+        try {
+            if (!this.httpUrl) {
+                throw new Error('Lux auth requires httpUrl');
+            }
+            const redirectTo = options.redirectTo ?? browserLocation();
+            const url = new URL(`${this.httpUrl}/auth/v1/authorize`);
+            url.searchParams.set('provider', options.provider);
+            if (redirectTo)
+                url.searchParams.set('redirect_to', redirectTo);
+            const target = url.toString();
+            if (!options.skipRedirect && typeof globalThis !== 'undefined') {
+                const location = globalThis.location;
+                if (location?.assign)
+                    location.assign(target);
+            }
+            return ok({ url: target });
+        }
+        catch (error) {
+            return err('LUX_AUTH_OAUTH_ERROR', 'Failed to start OAuth sign in', toLuxError(error));
+        }
+    }
+    async consumeOAuthRedirect(url = browserLocation()) {
+        try {
+            if (!url)
+                return ok({ session: null, user: null });
+            const parsed = new URL(url);
+            const params = new URLSearchParams(parsed.hash.replace(/^#/, ''));
+            const accessToken = params.get('access_token');
+            const refreshToken = params.get('refresh_token');
+            if (!accessToken || !refreshToken)
+                return ok({ session: null, user: null });
+            const session = normalizeSession({
+                access_token: accessToken,
+                refresh_token: refreshToken,
+                expires_in: Number(params.get('expires_in') || 0),
+                token_type: 'bearer',
+                user: { id: '', email: '' },
+            });
+            if (this.httpUrl) {
+                const user = await this.getUser(accessToken);
+                if (user.error)
+                    return user;
+                if (!user.data?.user) {
+                    return err('LUX_AUTH_USER_ERROR', 'OAuth redirect token did not resolve to a user');
+                }
+                session.user = user.data.user;
+            }
+            await this.saveSession(session, 'SIGNED_IN');
+            return ok({ session: this.currentSession, user: this.currentSession?.user ?? null });
+        }
+        catch (error) {
+            return err('LUX_AUTH_OAUTH_ERROR', 'Failed to consume OAuth redirect', toLuxError(error));
+        }
+    }
+    async refreshSession(refreshToken) {
+        try {
+            const session = await this.requestRaw('/auth/v1/token', {
+                method: 'POST',
+                body: JSON.stringify({
+                    grant_type: 'refresh_token',
+                    refresh_token: refreshToken,
+                }),
+                apiKey: true,
+            });
+            await this.saveSession(normalizeSession(session), 'TOKEN_REFRESHED');
+            return ok({ session: this.currentSession, user: this.currentSession.user });
+        }
+        catch (error) {
+            return err('LUX_AUTH_REFRESH_ERROR', 'Failed to refresh auth session', toLuxError(error));
+        }
+    }
+    async getUser(session) {
+        if (!session) {
+            await this.getSessionValue();
+        }
+        try {
+            return ok(await this.requestRaw('/auth/v1/user', {
+                method: 'GET',
+                token: this.tokenFrom(session),
+            }));
+        }
+        catch (error) {
+            return err('LUX_AUTH_USER_ERROR', 'Failed to get auth user', toLuxError(error));
+        }
+    }
+    async logout(sessionOrRefreshToken) {
+        if (!sessionOrRefreshToken) {
+            sessionOrRefreshToken = await this.getSessionValue() ?? undefined;
+        }
+        const token = typeof sessionOrRefreshToken === 'string'
+            ? sessionOrRefreshToken
+            : sessionOrRefreshToken?.access_token;
+        const refreshToken = typeof sessionOrRefreshToken === 'string'
+            ? undefined
+            : sessionOrRefreshToken?.refresh_token;
+        try {
+            await this.requestRaw('/auth/v1/logout', {
+                method: 'POST',
+                token,
+                body: JSON.stringify(refreshToken ? { refresh_token: refreshToken } : {}),
+            });
+            await this.clearSessionValue();
+            return ok(null);
+        }
+        catch (error) {
+            return err('LUX_AUTH_LOGOUT_ERROR', 'Failed to log out', toLuxError(error));
+        }
+    }
+    async signOut() {
+        return this.logout();
+    }
+    async listUsers() {
+        try {
+            const result = await this.requestRaw('/auth/v1/admin/users', {
+                method: 'GET',
+                secret: true,
+            });
+            return ok(result.users);
+        }
+        catch (error) {
+            return err('LUX_AUTH_ADMIN_ERROR', 'Failed to list auth users', toLuxError(error));
+        }
+    }
+    async grantCapability(userId, capability) {
+        try {
+            const result = await this.requestRaw('/auth/v1/admin/grants', {
+                method: 'POST',
+                secret: true,
+                body: JSON.stringify({ user_id: userId, capability }),
+            });
+            return ok(result.grant);
+        }
+        catch (error) {
+            return err('LUX_AUTH_ADMIN_ERROR', 'Failed to grant capability', toLuxError(error));
+        }
+    }
+    async listUserGrants(userId) {
+        try {
+            const result = await this.requestRaw(`/auth/v1/admin/users/${encodeURIComponent(userId)}/grants`, {
+                method: 'GET',
+                secret: true,
+            });
+            return ok(result.grants);
+        }
+        catch (error) {
+            return err('LUX_AUTH_ADMIN_ERROR', 'Failed to list user grants', toLuxError(error));
+        }
+    }
+    async revokeGrant(grantId) {
+        try {
+            await this.requestRaw(`/auth/v1/admin/grants/${encodeURIComponent(grantId)}`, {
+                method: 'DELETE',
+                secret: true,
+            });
+            return ok(null);
+        }
+        catch (error) {
+            return err('LUX_AUTH_ADMIN_ERROR', 'Failed to revoke grant', toLuxError(error));
+        }
+    }
+    async listApiKeys() {
+        try {
+            const result = await this.requestRaw('/auth/v1/admin/keys', {
+                method: 'GET',
+                secret: true,
+            });
+            return ok(result.keys);
+        }
+        catch (error) {
+            return err('LUX_AUTH_ADMIN_ERROR', 'Failed to list API keys', toLuxError(error));
+        }
+    }
+    async listProviders() {
+        try {
+            const result = await this.requestRaw('/auth/v1/admin/providers', {
+                method: 'GET',
+                secret: true,
+            });
+            return ok(result.providers);
+        }
+        catch (error) {
+            return err('LUX_AUTH_ADMIN_ERROR', 'Failed to list auth providers', toLuxError(error));
+        }
+    }
+    async upsertProvider(options) {
+        try {
+            const result = await this.requestRaw(`/auth/v1/admin/providers/${encodeURIComponent(options.provider)}`, {
+                method: 'PUT',
+                secret: true,
+                body: JSON.stringify(options),
+            });
+            return ok(result.provider);
+        }
+        catch (error) {
+            return err('LUX_AUTH_ADMIN_ERROR', 'Failed to update auth provider', toLuxError(error));
+        }
+    }
+    async createApiKey(options) {
+        try {
+            return ok(await this.requestRaw('/auth/v1/admin/keys', {
+                method: 'POST',
+                secret: true,
+                body: JSON.stringify(options),
+            }));
+        }
+        catch (error) {
+            return err('LUX_AUTH_ADMIN_ERROR', 'Failed to create API key', toLuxError(error));
+        }
+    }
+    async revokeApiKey(keyId) {
+        try {
+            await this.requestRaw(`/auth/v1/admin/keys/${encodeURIComponent(keyId)}`, {
+                method: 'DELETE',
+                secret: true,
+            });
+            return ok(null);
+        }
+        catch (error) {
+            return err('LUX_AUTH_ADMIN_ERROR', 'Failed to revoke API key', toLuxError(error));
+        }
+    }
+    async get(path, session) {
+        return this.requestResult(path, { method: 'GET', token: this.tokenFrom(session) });
+    }
+    async post(path, body, session) {
+        return this.requestResult(path, {
+            method: 'POST',
+            token: this.tokenFrom(session),
+            body: body == null ? undefined : JSON.stringify(body),
+        });
+    }
+    async put(path, body, session) {
+        return this.requestResult(path, {
+            method: 'PUT',
+            token: this.tokenFrom(session),
+            body: body == null ? undefined : JSON.stringify(body),
+        });
+    }
+    async delete(path, session) {
+        return this.requestResult(path, { method: 'DELETE', token: this.tokenFrom(session) });
+    }
+    tokenFrom(session) {
+        return typeof session === 'string' ? session : session?.access_token ?? this.authToken;
+    }
+    async loadStoredSession() {
+        if (this.loadedSession)
+            return;
+        this.loadedSession = true;
+        if (!this.persistSession || !this.storage)
+            return;
+        const raw = await this.storage.getItem(this.storageKey);
+        if (!raw)
+            return;
+        try {
+            const session = normalizeSession(JSON.parse(raw));
+            this.currentSession = session;
+            this.authToken = session.access_token;
+            this.scheduleRefresh(session);
+        }
+        catch {
+            await this.storage.removeItem(this.storageKey);
+        }
+    }
+    async saveSession(session, event) {
+        this.currentSession = session;
+        this.authToken = session.access_token;
+        this.loadedSession = true;
+        if (this.persistSession && this.storage) {
+            await this.storage.setItem(this.storageKey, JSON.stringify(session));
+        }
+        this.scheduleRefresh(session);
+        this.emit(event, session);
+    }
+    scheduleRefresh(session) {
+        this.clearRefreshTimer();
+        if (!this.autoRefreshToken || !session.refresh_token || !session.expires_at)
+            return;
+        const delayMs = Math.max(0, (session.expires_at - this.refreshMarginSeconds) * 1000 - Date.now());
+        this.refreshTimer = setTimeout(() => {
+            void this.refreshSession(session.refresh_token).catch(() => {
+                void this.clearSessionValue();
+            });
+        }, delayMs);
+    }
+    clearRefreshTimer() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+    }
+    emit(event, session) {
+        for (const listener of this.listeners) {
+            listener(event, session);
+        }
+    }
+    async requestResult(path, init) {
+        try {
+            return ok(await this.requestRaw(path, init));
+        }
+        catch (error) {
+            return err('LUX_AUTH_REQUEST_ERROR', 'Lux auth request failed', toLuxError(error));
+        }
+    }
+    async requestRaw(path, init) {
+        if (!this.httpUrl) {
+            throw new Error('Lux auth requires httpUrl');
+        }
+        const headers = {
+            Accept: 'application/json',
+        };
+        if (init.body != null) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const token = init.token ?? this.authToken;
+        if (token) {
+            headers.Authorization = `Bearer ${token}`;
+        }
+        if ((init.apiKey || init.secret) && this.apiKey) {
+            headers.apikey = this.apiKey;
+        }
+        const response = await this.fetchImpl(`${this.httpUrl}${path}`, {
+            method: init.method,
+            headers,
+            body: init.body,
+        });
+        const text = await response.text();
+        const payload = text ? JSON.parse(text) : {};
+        if (!response.ok) {
+            const message = payload?.error || `Lux auth request failed with HTTP ${response.status}`;
+            throw new Error(message);
+        }
+        return payload;
+    }
+}
+function normalizeSession(session) {
+    return {
+        ...session,
+        expires_at: session.expires_at ?? Math.floor(Date.now() / 1000) + Number(session.expires_in || 0),
+    };
+}
+function isExpired(session, marginSeconds = 0) {
+    return Boolean(session.expires_at && session.expires_at <= Math.floor(Date.now() / 1000) + marginSeconds);
+}
+function defaultBrowserStorage() {
+    if (typeof globalThis === 'undefined')
+        return null;
+    const storage = globalThis.localStorage;
+    if (!storage)
+        return null;
+    return {
+        getItem: (key) => storage.getItem(key),
+        setItem: (key, value) => storage.setItem(key, value),
+        removeItem: (key) => storage.removeItem(key),
+    };
+}
+function resolveFetch(fetchImpl) {
+    const candidate = fetchImpl ?? globalThis.fetch;
+    if (!candidate) {
+        throw new Error('Lux auth requires a fetch implementation');
+    }
+    if (typeof globalThis !== 'undefined' && candidate === globalThis.fetch) {
+        return candidate.bind(globalThis);
+    }
+    return candidate;
+}
+function browserLocation() {
+    if (typeof globalThis === 'undefined')
+        return '';
+    return String(globalThis.location?.href || '');
+}

package/dist/esm/browser.js

@@ -0,0 +1,11 @@
+import { createClient } from './project.js';
+export function createBrowserClient(url, key, options = {}) {
+    return createClient(url, key, {
+        ...options,
+        auth: {
+            persistSession: true,
+            autoRefreshToken: true,
+            ...(options.auth ?? {}),
+        },
+    });
+}