marcel/familienarchiv
1
0
Fork 0
Code Issues 126 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat(dashboard): add isReader flag + reader branch to page load

Browse Source 
Read-only users (no WRITE_ALL or ANNOTATE_ALL) now receive lean reader
data (stats, top-4 persons, 5 recent docs, 3 recent stories, and drafts
when BLOG_WRITE) instead of the contributor transcription queues.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Marcel
2026-05-07 19:04:04 +02:00
parent cb39a84cce
commit 9043a2def0
2 changed files with 247 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
frontend/src/routes/+page.server.ts
View File

@@ -9,8 +9,13 @@ type DashboardResumeDTO = components['schemas']['DashboardResumeDTO'];
type DashboardPulseDTO = components['schemas']['DashboardPulseDTO'];
type ActivityFeedItemDTO = components['schemas']['ActivityFeedItemDTO'];
type IncompleteDocumentDTO = components['schemas']['IncompleteDocumentDTO'];
type PersonSummaryDTO = components['schemas']['PersonSummaryDTO'];
type Document = components['schemas']['Document'];
type Geschichte = components['schemas']['Geschichte'];
export async function load({ fetch }) {
export async function load({ fetch, parent }) {
const { canWrite, canAnnotate, canBlogWrite } = await parent();
const isReader = !canWrite && !canAnnotate;
const api = createApiClient(fetch);
try {
@@ -20,6 +25,73 @@ export async function load({ fetch }) {
throw redirect(302, '/login');
}
if (isReader) {
const readerFetches: Promise<unknown>[] = [
api.GET('/api/stats'),
api.GET('/api/persons', { params: { query: { size: 4, sort: 'documentCount' } } }),
api.GET('/api/documents', {
params: { query: { sort: 'UPDATED_AT', dir: 'DESC', size: 5 } }
}),
api.GET('/api/geschichten', { params: { query: { status: 'PUBLISHED', limit: 3 } } })
];
if (canBlogWrite) {
readerFetches.push(
api.GET('/api/geschichten', { params: { query: { status: 'DRAFT', limit: 10 } } })
);
}
const [statsRes, topPersonsRes, recentDocsRes, recentStoriesRes, draftsRes] =
await Promise.allSettled(readerFetches);
let readerStats: StatsDTO | null = null;
let topPersons: PersonSummaryDTO[] = [];
let recentDocs: Document[] = [];
let recentStories: Geschichte[] = [];
let drafts: Geschichte[] = [];
if (
statsRes?.status === 'fulfilled' &&
(statsRes.value as { response: Response }).response.ok
) {
readerStats = ((statsRes.value as { data: unknown }).data as StatsDTO) ?? null;
}
if (
topPersonsRes?.status === 'fulfilled' &&
(topPersonsRes.value as { response: Response }).response.ok
) {
topPersons = ((topPersonsRes.value as { data: unknown }).data as PersonSummaryDTO[]) ?? [];
}
if (
recentDocsRes?.status === 'fulfilled' &&
(recentDocsRes.value as { response: Response }).response.ok
) {
recentDocs = ((recentDocsRes.value as { data: unknown }).data as Document[]) ?? [];
}
if (
recentStoriesRes?.status === 'fulfilled' &&
(recentStoriesRes.value as { response: Response }).response.ok
) {
recentStories = ((recentStoriesRes.value as { data: unknown }).data as Geschichte[]) ?? [];
}
if (
draftsRes?.status === 'fulfilled' &&
(draftsRes.value as { response: Response }).response.ok
) {
drafts = ((draftsRes.value as { data: unknown }).data as Geschichte[]) ?? [];
}
return {
isReader: true as const,
canBlogWrite,
readerStats,
topPersons,
recentDocs,
recentStories,
drafts,
error: null as string | null
};
}
const [
statsResult,
resumeResult,
@@ -87,6 +159,7 @@ export async function load({ fetch }) {
}
return {
isReader: false as const,
stats,
resumeDoc,
pulse,
@@ -103,6 +176,7 @@ export async function load({ fetch }) {
if ((e as { status?: number }).status) throw e;
console.error('Error loading data:', e);
return {
isReader,
stats: null,
resumeDoc: null,
pulse: null,
@@ -113,6 +187,11 @@ export async function load({ fetch }) {
weeklyStats: null,
incompleteDocs: [] as IncompleteDocumentDTO[],
incompleteTotal: 0,
readerStats: null,
topPersons: [] as PersonSummaryDTO[],
recentDocs: [] as Document[],
recentStories: [] as Geschichte[],
drafts: [] as Geschichte[],
error: 'Daten konnten nicht geladen werden.' as string | null
};
}

177
frontend/src/routes/page.server.spec.ts
View File

@@ -19,6 +19,10 @@ function makeUrl(params: Record<string, string | string[]> = {}) {
return url;
}
function contributorParent() {
return vi.fn().mockResolvedValue({ canWrite: true, canAnnotate: false, canBlogWrite: false });
}
// ─── always-dashboard behaviour ───────────────────────────────────────────────
it('never calls /api/documents/search regardless of URL params', async () => {
@@ -29,8 +33,9 @@ it('never calls /api/documents/search regardless of URL params', async () => {
await load({
url: makeUrl({ q: 'Urlaub', from: '2020-01-01' }),
fetch: vi.fn() as unknown as typeof fetch
});
fetch: vi.fn() as unknown as typeof fetch,
parent: contributorParent()
} as Parameters<typeof load>[0]);
const calledEndpoints = mockGet.mock.calls.map((c: unknown[]) => c[0]);
expect(calledEndpoints).not.toContain('/api/documents/search');
@@ -42,7 +47,11 @@ it('always fetches dashboard data regardless of URL params', async () => {
typeof createApiClient
>);
await load({ url: makeUrl({ q: 'Urlaub' }), fetch: vi.fn() as unknown as typeof fetch });
await load({
url: makeUrl({ q: 'Urlaub' }),
fetch: vi.fn() as unknown as typeof fetch,
parent: contributorParent()
} as Parameters<typeof load>[0]);
const calledEndpoints = mockGet.mock.calls.map((c: unknown[]) => c[0]);
expect(calledEndpoints).toContain('/api/stats');
@@ -99,7 +108,11 @@ describe('home page load — dashboard', () => {
typeof createApiClient
>);
const result = await load({ url: makeUrl(), fetch: vi.fn() as unknown as typeof fetch });
const result = await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: contributorParent()
} as Parameters<typeof load>[0]);
expect(result.stats).toEqual({ totalDocuments: 42, totalPersons: 7 });
expect(result.resumeDoc).not.toBeNull();
@@ -132,7 +145,11 @@ describe('home page load — dashboard', () => {
typeof createApiClient
>);
const result = await load({ url: makeUrl(), fetch: vi.fn() as unknown as typeof fetch });
const result = await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: contributorParent()
} as Parameters<typeof load>[0]);
expect(result.stats?.totalDocuments).toBe(248);
expect(result.stats?.totalPersons).toBe(34);
@@ -149,7 +166,11 @@ describe('home page load — dashboard', () => {
typeof createApiClient
>);
const result = await load({ url: makeUrl(), fetch: vi.fn() as unknown as typeof fetch });
const result = await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: contributorParent()
} as Parameters<typeof load>[0]);
expect(result.stats).toBeNull();
});
@@ -166,7 +187,11 @@ describe('home page load — dashboard', () => {
typeof createApiClient
>);
const result = await load({ url: makeUrl(), fetch: vi.fn() as unknown as typeof fetch });
const result = await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: contributorParent()
} as Parameters<typeof load>[0]);
expect(result.resumeDoc).toBeNull();
});
@@ -186,7 +211,11 @@ describe('home page load — dashboard', () => {
typeof createApiClient
>);
const result = await load({ url: makeUrl(), fetch: vi.fn() as unknown as typeof fetch });
const result = await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: contributorParent()
} as Parameters<typeof load>[0]);
expect(result.activityFeed).toEqual([]);
});
@@ -201,7 +230,11 @@ describe('home page load — auth redirect', () => {
} as ReturnType<typeof createApiClient>);
await expect(
load({ url: makeUrl(), fetch: vi.fn() as unknown as typeof fetch })
load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: contributorParent()
} as Parameters<typeof load>[0])
).rejects.toMatchObject({ location: '/login' });
});
});
@@ -214,8 +247,132 @@ describe('home page load — network error fallback', () => {
GET: vi.fn().mockRejectedValue(new Error('Network failure'))
} as ReturnType<typeof createApiClient>);
const result = await load({ url: makeUrl(), fetch: vi.fn() as unknown as typeof fetch });
const result = await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: contributorParent()
} as Parameters<typeof load>[0]);
expect(result.error).toBe('Daten konnten nicht geladen werden.');
});
});
// ─── reader branch ─────────────────────────────────────────────────────────────
describe('home page load — reader branch (isReader = !canWrite && !canAnnotate)', () => {
it('does not call /api/transcription/* endpoints for a read-only user', async () => {
const mockGet = vi.fn().mockResolvedValue({ response: { ok: true, status: 200 }, data: null });
vi.mocked(createApiClient).mockReturnValue({ GET: mockGet } as ReturnType<
typeof createApiClient
>);
await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: vi
.fn()
.mockResolvedValue({ canWrite: false, canAnnotate: false, canBlogWrite: false })
} as Parameters<typeof load>[0]);
const calledEndpoints = mockGet.mock.calls.map((c: unknown[]) => c[0] as string);
const transcriptionCalls = calledEndpoints.filter((ep: string) =>
ep.startsWith('/api/transcription')
);
expect(transcriptionCalls).toHaveLength(0);
});
it('calls /api/stats, /api/persons, /api/documents, /api/geschichten for a read-only user', async () => {
const mockGet = vi.fn().mockResolvedValue({ response: { ok: true, status: 200 }, data: null });
vi.mocked(createApiClient).mockReturnValue({ GET: mockGet } as ReturnType<
typeof createApiClient
>);
await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: vi
.fn()
.mockResolvedValue({ canWrite: false, canAnnotate: false, canBlogWrite: false })
} as Parameters<typeof load>[0]);
const calledEndpoints = mockGet.mock.calls.map((c: unknown[]) => c[0] as string);
expect(calledEndpoints).toContain('/api/stats');
expect(calledEndpoints).toContain('/api/persons');
expect(calledEndpoints).toContain('/api/documents');
expect(calledEndpoints).toContain('/api/geschichten');
});
it('does not call /api/geschichten with status=DRAFT when canBlogWrite is false', async () => {
const mockGet = vi.fn().mockResolvedValue({ response: { ok: true, status: 200 }, data: null });
vi.mocked(createApiClient).mockReturnValue({ GET: mockGet } as ReturnType<
typeof createApiClient
>);
await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: vi
.fn()
.mockResolvedValue({ canWrite: false, canAnnotate: false, canBlogWrite: false })
} as Parameters<typeof load>[0]);
const draftCalls = mockGet.mock.calls.filter(
(c: unknown[]) =>
c[0] === '/api/geschichten' &&
(c[1] as { params?: { query?: { status?: string } } })?.params?.query?.status === 'DRAFT'
);
expect(draftCalls).toHaveLength(0);
});
it('calls /api/geschichten with status=DRAFT when canBlogWrite is true', async () => {
const mockGet = vi.fn().mockResolvedValue({ response: { ok: true, status: 200 }, data: null });
vi.mocked(createApiClient).mockReturnValue({ GET: mockGet } as ReturnType<
typeof createApiClient
>);
await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: vi.fn().mockResolvedValue({ canWrite: false, canAnnotate: false, canBlogWrite: true })
} as Parameters<typeof load>[0]);
const draftCalls = mockGet.mock.calls.filter(
(c: unknown[]) =>
c[0] === '/api/geschichten' &&
(c[1] as { params?: { query?: { status?: string } } })?.params?.query?.status === 'DRAFT'
);
expect(draftCalls).toHaveLength(1);
});
it('returns isReader: true for read-only user', async () => {
const mockGet = vi.fn().mockResolvedValue({ response: { ok: true, status: 200 }, data: null });
vi.mocked(createApiClient).mockReturnValue({ GET: mockGet } as ReturnType<
typeof createApiClient
>);
const result = await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: vi
.fn()
.mockResolvedValue({ canWrite: false, canAnnotate: false, canBlogWrite: false })
} as Parameters<typeof load>[0]);
expect(result.isReader).toBe(true);
});
it('returns isReader: false for contributor with WRITE_ALL', async () => {
const mockGet = vi.fn().mockResolvedValue({ response: { ok: true, status: 200 }, data: null });
vi.mocked(createApiClient).mockReturnValue({ GET: mockGet } as ReturnType<
typeof createApiClient
>);
const result = await load({
url: makeUrl(),
fetch: vi.fn() as unknown as typeof fetch,
parent: vi.fn().mockResolvedValue({ canWrite: true, canAnnotate: false, canBlogWrite: false })
} as Parameters<typeof load>[0]);
expect(result.isReader).toBe(false);
});
});