Speakr is a personal, self-hosted web application designed for transcribing audio recordings
Python
/**
* 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
};
}