Skip to content

Speakr is a personal, self-hosted web application designed for transcribing audio recordings

Python
10.2 KB
Raw Blame
/**
 * API Tokens Management Composable
 * Handles API token operations for user authentication
 */

const { ref, computed } = Vue;

// Parse a backend INSTANT timestamp (naive UTC) — append 'Z' so it's read as
// UTC and rendered in the viewer's timezone instead of being mis-parsed as local.
const parseServerInstant = (s) => {
    if (s == null) return new Date(NaN);
    if (typeof s === 'string' && /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/.test(s) && !/(?:Z|[+-]\d{2}:?\d{2})$/.test(s)) {
        s = s.replace(' ', 'T') + 'Z';
    }
    return new Date(s);
};

// i18n.js may not have loaded yet; fall back to the English text.
const t = (key, params, fallback) => (window.i18n ? window.i18n.t(key, params || {}) : fallback);

export function useTokens({ showToast, setGlobalError }) {
    // State
    const tokens = ref([]);
    const isLoadingTokens = ref(false);
    const showCreateTokenModal = ref(false);
    const showTokenSecretModal = ref(false);
    const newTokenSecret = ref('');
    const newTokenData = ref(null);
    const tokenForm = ref({
        name: '',
        expires_in_days: 0  // 0 = no expiration
    });

    // Computed
    const hasTokens = computed(() => tokens.value.length > 0);

    const activeTokens = computed(() => {
        return tokens.value.filter(token => !token.revoked && !isTokenExpired(token));
    });

    const expiredOrRevokedTokens = computed(() => {
        return tokens.value.filter(token => token.revoked || isTokenExpired(token));
    });

    // Helper methods
    const isTokenExpired = (token) => {
        if (!token.expires_at) return false;
        const expiryDate = parseServerInstant(token.expires_at);
        return expiryDate < new Date();
    };

    const formatTokenDate = (dateString) => {
        if (!dateString) return t('adminDashboard.never', {}, 'Never');
        const date = parseServerInstant(dateString);
        return date.toLocaleDateString(window.i18n?.getIntlLocale?.()) + ' ' + date.toLocaleTimeString(window.i18n?.getIntlLocale?.());
    };

    const getTokenStatus = (token) => {
        if (token.revoked) return 'revoked';
        if (isTokenExpired(token)) return 'expired';
        return 'active';
    };

    const getTokenStatusClass = (token) => {
        const status = getTokenStatus(token);
        const baseClasses = 'px-2 py-1 text-xs font-semibold rounded';

        switch (status) {
            case 'active':
                return `${baseClasses} bg-green-100 text-green-800`;
            case 'expired':
                return `${baseClasses} bg-yellow-100 text-yellow-800`;
            case 'revoked':
                return `${baseClasses} bg-red-100 text-red-800`;
            default:
                return `${baseClasses} bg-gray-100 text-gray-800`;
        }
    };

    // API methods
    const loadTokens = async () => {
        isLoadingTokens.value = true;
        try {
            const response = await fetch('/api/tokens', {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json'
                }
            });

            if (!response.ok) {
                throw new Error(t('apiTokens.loadFailed', {}, 'Failed to load tokens'));
            }

            const data = await response.json();
            tokens.value = data.tokens || [];
        } catch (error) {
            console.error('Error loading tokens:', error);
            setGlobalError(t('apiTokens.loadFailedWithError', { error: error.message }, 'Failed to load API tokens: ' + error.message));
        } finally {
            isLoadingTokens.value = false;
        }
    };

    const createToken = async () => {
        if (!tokenForm.value.name || tokenForm.value.name.trim() === '') {
            showToast(t('apiTokens.enterName', {}, 'Please enter a token name'), 'error');
            return;
        }

        try {
            const csrfToken = document.querySelector('meta[name="csrf-token"]')?.getAttribute('content');

            const response = await fetch('/api/tokens', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRFToken': csrfToken
                },
                body: JSON.stringify({
                    name: tokenForm.value.name,
                    expires_in_days: parseInt(tokenForm.value.expires_in_days) || 0
                })
            });

            if (!response.ok) {
                const errorData = await response.json();
                throw new Error(errorData.error || t('apiTokens.createFailed', {}, 'Failed to create token'));
            }

            const data = await response.json();

            // Store the plaintext token to show to user (only shown once)
            newTokenSecret.value = data.token;
            newTokenData.value = {
                id: data.id,
                name: data.name,
                created_at: data.created_at,
                expires_at: data.expires_at
            };

            // Add to tokens list (without the plaintext token)
            tokens.value.unshift({
                id: data.id,
                name: data.name,
                created_at: data.created_at,
                last_used_at: data.last_used_at,
                expires_at: data.expires_at,
                revoked: data.revoked
            });

            // Reset form
            tokenForm.value = {
                name: '',
                expires_in_days: 0
            };

            // Close create modal and show secret modal
            showCreateTokenModal.value = false;
            showTokenSecretModal.value = true;

            showToast(t('apiTokens.createdSuccess', {}, 'API token created successfully'), 'success');
        } catch (error) {
            console.error('Error creating token:', error);
            showToast(t('apiTokens.createFailedWithError', { error: error.message }, 'Failed to create token: ' + error.message), 'error');
        }
    };

    const revokeToken = async (tokenId, tokenName) => {
        if (!confirm(t('apiTokens.revokeConfirm', { name: tokenName }, `Are you sure you want to revoke the token "${tokenName}"? This action cannot be undone and any applications using this token will lose access.`))) {
            return;
        }

        try {
            const csrfToken = document.querySelector('meta[name="csrf-token"]')?.getAttribute('content');

            const response = await fetch(`/api/tokens/${tokenId}`, {
                method: 'DELETE',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRFToken': csrfToken
                }
            });

            if (!response.ok) {
                const errorData = await response.json();
                throw new Error(errorData.error || t('apiTokens.revokeFailed', {}, 'Failed to revoke token'));
            }

            // Remove from local list
            tokens.value = tokens.value.filter(tok => tok.id !== tokenId);

            showToast(t('apiTokens.revokedSuccess', {}, 'Token revoked successfully'), 'success');
        } catch (error) {
            console.error('Error revoking token:', error);
            showToast(t('apiTokens.revokeFailedWithError', { error: error.message }, 'Failed to revoke token: ' + error.message), 'error');
        }
    };

    const updateTokenName = async (tokenId, newName) => {
        if (!newName || newName.trim() === '') {
            showToast(t('apiTokens.nameEmpty', {}, 'Token name cannot be empty'), 'error');
            return;
        }

        try {
            const csrfToken = document.querySelector('meta[name="csrf-token"]')?.getAttribute('content');

            const response = await fetch(`/api/tokens/${tokenId}`, {
                method: 'PATCH',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRFToken': csrfToken
                },
                body: JSON.stringify({ name: newName })
            });

            if (!response.ok) {
                const errorData = await response.json();
                throw new Error(errorData.error || t('apiTokens.updateFailed', {}, 'Failed to update token'));
            }

            const data = await response.json();

            // Update local token
            const token = tokens.value.find(tok => tok.id === tokenId);
            if (token) {
                token.name = data.name;
            }

            showToast(t('apiTokens.nameUpdated', {}, 'Token name updated'), 'success');
        } catch (error) {
            console.error('Error updating token:', error);
            showToast(t('apiTokens.updateFailedWithError', { error: error.message }, 'Failed to update token: ' + error.message), 'error');
        }
    };

    const copyTokenToClipboard = async (token) => {
        try {
            await navigator.clipboard.writeText(token);
            showToast(t('apiTokens.copied', {}, 'Token copied to clipboard'), 'success');
        } catch (error) {
            console.error('Error copying token:', error);
            showToast(t('apiTokens.copyFailed', {}, 'Failed to copy token to clipboard'), 'error');
        }
    };

    const openCreateTokenModal = () => {
        tokenForm.value = {
            name: '',
            expires_in_days: 0
        };
        showCreateTokenModal.value = true;
    };

    const closeCreateTokenModal = () => {
        showCreateTokenModal.value = false;
        tokenForm.value = {
            name: '',
            expires_in_days: 0
        };
    };

    const closeTokenSecretModal = () => {
        showTokenSecretModal.value = false;
        newTokenSecret.value = '';
        newTokenData.value = null;
    };

    return {
        // State
        tokens,
        isLoadingTokens,
        showCreateTokenModal,
        showTokenSecretModal,
        newTokenSecret,
        newTokenData,
        tokenForm,

        // Computed
        hasTokens,
        activeTokens,
        expiredOrRevokedTokens,

        // Methods
        isTokenExpired,
        formatTokenDate,
        getTokenStatus,
        getTokenStatusClass,
        loadTokens,
        createToken,
        revokeToken,
        updateTokenName,
        copyTokenToClipboard,
        openCreateTokenModal,
        closeCreateTokenModal,
        closeTokenSecretModal
    };
}