- Add session-aware login, logout and protected navigation. - Send cookie credentials for API and run-event requests with localized UI stories.
131 lines
4.1 KiB
TypeScript
131 lines
4.1 KiB
TypeScript
import { DEFAULT_LOG_DATA_LIMITS, type LogDataLimits } from '../ui/LogOutput/logText';
|
|
|
|
/** Public client configuration served by the server at /manifest.json. */
|
|
export interface Manifest {
|
|
name: string;
|
|
/** Server version; can differ from the client build's __APP_VERSION__ until the page is reloaded. */
|
|
version: string;
|
|
runLogs: {
|
|
dataLimits: LogDataLimits;
|
|
};
|
|
auth: {
|
|
enabled: boolean;
|
|
};
|
|
}
|
|
|
|
export const DEFAULT_MANIFEST: Manifest = {
|
|
name: 'liqa',
|
|
version: __APP_VERSION__,
|
|
runLogs: { dataLimits: DEFAULT_LOG_DATA_LIMITS },
|
|
auth: { enabled: false },
|
|
};
|
|
|
|
const STORAGE_KEY = 'liqa-manifest';
|
|
/** A tab coming back into view refetches the manifest if it is older than this. */
|
|
const REFRESH_AFTER_MS = 5 * 60 * 1000;
|
|
|
|
// Served next to the API's /api/v1 (so "/manifest.json" by default, or on
|
|
// VITE_API_URL's origin when the client talks to another server)
|
|
const MANIFEST_URL = new URL(
|
|
'../../manifest.json',
|
|
new URL(
|
|
`${(import.meta.env.VITE_API_URL ?? '/api/v1').replace(/\/$/, '')}/`,
|
|
window.location.href,
|
|
),
|
|
).toString();
|
|
|
|
/** Fills fields missing from `raw` (e.g. a manifest cached by an older version) with defaults. */
|
|
function normalize(raw: unknown): Manifest | null {
|
|
if (typeof raw !== 'object' || raw === null) return null;
|
|
const m = raw as Partial<Manifest>;
|
|
const limits: Partial<LogDataLimits> = m.runLogs?.dataLimits ?? {};
|
|
const num = (v: unknown, fallback: number) => (typeof v === 'number' && v >= 0 ? v : fallback);
|
|
return {
|
|
name: typeof m.name === 'string' ? m.name : DEFAULT_MANIFEST.name,
|
|
version: typeof m.version === 'string' ? m.version : DEFAULT_MANIFEST.version,
|
|
auth: { enabled: m.auth?.enabled === true },
|
|
runLogs: {
|
|
dataLimits: {
|
|
bytes: num(limits.bytes, DEFAULT_LOG_DATA_LIMITS.bytes),
|
|
lines: num(limits.lines, DEFAULT_LOG_DATA_LIMITS.lines),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
// Storage can be unavailable (private mode, blocked site data): the manifest
|
|
// then just comes from the network on every page load
|
|
function readCache(): Manifest | null {
|
|
try {
|
|
const stored = localStorage.getItem(STORAGE_KEY);
|
|
return stored ? normalize(JSON.parse(stored)) : null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function writeCache(manifest: Manifest) {
|
|
try {
|
|
localStorage.setItem(STORAGE_KEY, JSON.stringify(manifest));
|
|
} catch {
|
|
// ignore, see readCache
|
|
}
|
|
}
|
|
|
|
let current: Manifest = readCache() ?? DEFAULT_MANIFEST;
|
|
let fetchedAt = 0;
|
|
let inFlight: Promise<void> | null = null;
|
|
const listeners = new Set<() => void>();
|
|
|
|
/**
|
|
* Fetches the manifest and notifies subscribers if it changed. Failures are
|
|
* silent: the cached (or default) manifest stays in use.
|
|
*/
|
|
export function refreshManifest(): Promise<void> {
|
|
inFlight ??= fetch(MANIFEST_URL, {
|
|
headers: { Accept: 'application/json' },
|
|
credentials: 'include',
|
|
})
|
|
.then((res) => (res.ok ? res.json() : null))
|
|
.then((raw: unknown) => {
|
|
const next = normalize(raw);
|
|
if (!next) return;
|
|
fetchedAt = Date.now();
|
|
writeCache(next);
|
|
if (JSON.stringify(next) !== JSON.stringify(current)) {
|
|
current = next;
|
|
listeners.forEach((l) => l());
|
|
}
|
|
})
|
|
.catch(() => undefined)
|
|
.finally(() => {
|
|
inFlight = null;
|
|
});
|
|
return inFlight;
|
|
}
|
|
|
|
function onVisibilityChange() {
|
|
if (document.visibilityState === 'visible' && Date.now() - fetchedAt > REFRESH_AFTER_MS) {
|
|
void refreshManifest();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stale-while-revalidate: subscribers get the localStorage copy right away,
|
|
* and the manifest is refetched once per page load (the server answers 304
|
|
* while it is unchanged) and when the tab becomes visible again after a while.
|
|
*/
|
|
export function subscribeManifest(listener: () => void): () => void {
|
|
if (listeners.size === 0) document.addEventListener('visibilitychange', onVisibilityChange);
|
|
listeners.add(listener);
|
|
if (fetchedAt === 0) void refreshManifest();
|
|
return () => {
|
|
listeners.delete(listener);
|
|
if (listeners.size === 0) document.removeEventListener('visibilitychange', onVisibilityChange);
|
|
};
|
|
}
|
|
|
|
export function getManifest(): Manifest {
|
|
return current;
|
|
}
|