import { SheetFailure, activateSpecies, createSheetWorkingCopy, createSpecies, downloadSheetDrawing, getOfficialSheetAdmin, listCatalogGrants, listCatalogSpecies, listOfficialSheetsAdmin, listOwnCatalogGrants, listSheetVersions, lookupCatalogAccount, renameSpecies, updateInactiveSpecies, type FaunosteoClient, } from '../src' /** * Call shapes, answer parsers and closed failure kinds of the V1-2.5 sheet * access layer. The argument names are checked by the compiler against the * generated types; the RPC bodies by the sheet pgTAP files under supabase/tests; the * same functions run against real PostgREST, GoTrue and Storage in * tests/sandbox/sheets-admin.sandbox.ts. */ type Answer = { data?: unknown; error?: unknown; status?: number } function stubClient(answers: { rpc?: Answer; select?: Answer; download?: Answer } = {}) { const rpcCalls: Array<[string, Record | undefined]> = [] const query: Record = {} const downloads: Array<[string, string]> = [] const settle = (a: Answer = {}) => ({ data: a.data ?? null, error: a.error ?? null, status: a.status ?? (a.error ? 400 : 200), }) const chain = { select: (cols: string) => ((query.select = cols), chain), eq: (col: string, value: unknown) => ((query[`eq:${col}`] = value), chain), in: (col: string, values: unknown) => ((query[`in:${col}`] = values), chain), order: (col: string, opts: unknown) => ((query[`order:${col}`] = opts), chain), then: (resolve: (value: unknown) => unknown) => resolve(settle(answers.select)), } const client = { from: (table: string) => ((query.table = table), chain), rpc: async (name: string, args?: Record) => { rpcCalls.push([name, args]) return settle(answers.rpc) }, storage: { from: (bucket: string) => ({ download: async (path: string) => { downloads.push([bucket, path]) return { data: answers.download?.data ?? null, error: answers.download?.error ?? null } }, }), }, } as unknown as FaunosteoClient return { client, rpcCalls, query, downloads } } async function kindOf(promise: Promise) { try { await promise return 'no failure' } catch (error) { return error instanceof SheetFailure ? error.kind : `other: ${String(error)}` } } const SHEET = '22222222-2222-4222-8222-222222222222' const VERSION = '33333333-3333-4333-8333-333333333333' const SHA = 'a'.repeat(64) const person = { user_id: SHEET, display_name: 'Marie' } const summary = { sheet_id: SHEET, species_id: 'equine', slug: 'cheval', status: 'active', archived_at: null, created_at: '2026-11-02T10:00:00Z', updated_at: '2026-11-02T10:00:00Z', name: { fr: 'Cheval', en: 'Horse' }, historical: true, working_copy: false, working_copy_active: false, latest_version: { version_id: VERSION, version_number: 2, status: 'draft', revision: 3 }, current_version: { version_id: VERSION, version_number: 1, published_at: '2026-11-01T10:00:00Z' }, draft_version: { version_id: VERSION, version_number: 2, revision: 3 }, version_statuses: ['draft', 'published'], open_rounds: 0, latest_round: null, } const overview = { ...summary, working_copy_source: null, draft_last_save: { revision: 3, saved_at: '2026-11-02T11:00:00Z', saved_by: person }, versions: [{ version_id: VERSION, version_number: 1, status: 'published', revision: 1, change_note: null, created_at: '2026-11-01T09:00:00Z', published_at: '2026-11-01T10:00:00Z', deprecated_at: null, source_version_number: null, authors: [person], }], rounds: [{ review_id: VERSION, version_id: VERSION, version_number: 1, round: 1, revision: 1, status: 'approved', submitted_by: person, submitted_at: '2026-11-01T09:30:00Z', verified_at: '2026-11-01T09:31:00Z', failure_outcome: null, failure_code: null, decided_by: person, decided_at: '2026-11-01T09:40:00Z', withdrawn_at: null, }], } const grant = { id: VERSION, user_id: SHEET, display_name: 'Marie', email: 'marie@example.org', kind: 'sheet_editor', reason: 'r', verification_note: 'n', granted_by: SHEET, granted_by_name: 'Owner', granted_at: '2026-11-01T09:00:00Z', expires_at: null, revoked_at: null, revoked_by: null, revocation_reason: null, state: 'active', effective: true, } describe('sheet admin wrappers: argument mapping', () => { it('names the RPC arguments as the migrations do', async () => { const { client, rpcCalls } = stubClient({ rpc: { data: 'ok' } }) await createSpecies(client, { id: 'feline', name_fr: 'Chat', name_en: 'Cat' }) await updateInactiveSpecies(client, { id: 'feline', name_fr: 'Chat', name_en: 'Cat', sort_order: 5 }) await activateSpecies(client, 'feline') await renameSpecies(client, { id: 'feline', name_fr: 'Félin', name_en: 'Feline' }) await createSheetWorkingCopy(client, VERSION, 'cheval-v2') expect(rpcCalls).toEqual([ ['create_species', { id: 'feline', name_fr: 'Chat', name_en: 'Cat' }], ['update_inactive_species', { id: 'feline', name_fr: 'Chat', name_en: 'Cat', sort_order: 5 }], ['activate_species', { id: 'feline' }], ['rename_species', { id: 'feline', name_fr: 'Félin', name_en: 'Feline' }], ['create_sheet_working_copy', { source_version_id: VERSION, slug: 'cheval-v2' }], ]) }) it('reads the published and deprecated versions of one sheet, newest first', async () => { const rows = [{ id: VERSION, version_number: 1, status: 'published', published_at: 'x', deprecated_at: null }] const { client, query } = stubClient({ select: { data: rows } }) expect(await listSheetVersions(client, SHEET)).toEqual(rows) expect(query).toEqual({ table: 'anatomical_sheet_versions', select: 'id, version_number, status, published_at, deprecated_at', [`eq:sheet_id`]: SHEET, [`in:status`]: ['published', 'deprecated'], [`order:version_number`]: { ascending: false }, }) }) it("reads the caller's own grant rows for the navigation hint", async () => { const rows = [{ kind: 'catalog_reader', expires_at: null, revoked_at: null }] const { client, query } = stubClient({ select: { data: rows } }) expect(await listOwnCatalogGrants(client, SHEET)).toEqual(rows) expect(query).toEqual({ table: 'anatomical_catalog_grants', select: 'kind:grant_kind, expires_at, revoked_at', [`eq:user_id`]: SHEET, }) }) it('answers a malformed id as unknown without a request', async () => { const { client, rpcCalls, query } = stubClient() expect(await kindOf(getOfficialSheetAdmin(client, 'nope'))).toBe('not_found') expect(await kindOf(listSheetVersions(client, `${SHEET}'`))).toBe('not_found') expect(rpcCalls).toEqual([]) expect(query).toEqual({}) }) }) describe('sheet admin wrappers: answers', () => { it('parses the admin list and the overview', async () => { expect(await listOfficialSheetsAdmin(stubClient({ rpc: { data: [summary] } }).client)).toEqual([summary]) const { client, rpcCalls } = stubClient({ rpc: { data: overview } }) expect(await getOfficialSheetAdmin(client, SHEET)).toEqual(overview) expect(rpcCalls).toEqual([['get_official_sheet_admin', { sheet_id: SHEET }]]) }) it('accepts a draft nobody saved: draft_last_save is null', async () => { const { client } = stubClient({ rpc: { data: { ...overview, draft_last_save: null } } }) expect((await getOfficialSheetAdmin(client, SHEET)).draft_last_save).toBeNull() }) it('parses grants, the account lookup and the species', async () => { expect(await listCatalogGrants(stubClient({ rpc: { data: [grant] } }).client)).toEqual([grant]) const account = { user_id: SHEET, display_name: 'Marie', active: true, email_confirmed: true, verified_totp: false, platform_roles: ['owner'], } const lookup = stubClient({ rpc: { data: account } }) expect(await lookupCatalogAccount(lookup.client, 'marie@example.org')).toEqual(account) expect(lookup.rpcCalls).toEqual([['lookup_catalog_account', { email: 'marie@example.org' }]]) const species = [{ id: 'equine', name_fr: 'Cheval', name_en: 'Horse', sort_order: 10, active: true }] expect(await listCatalogSpecies(stubClient({ rpc: { data: species } }).client)).toEqual(species) }) it('refuses an answer outside the contract as unavailable', async () => { const answer = (data: unknown) => stubClient({ rpc: { data } }).client expect(await kindOf(listOfficialSheetsAdmin(answer({ sheets: [] })))).toBe('unavailable') expect(await kindOf(listOfficialSheetsAdmin(answer([{ ...summary, status: 'gone' }])))).toBe('unavailable') expect(await kindOf(getOfficialSheetAdmin(answer(summary), SHEET))).toBe('unavailable') expect(await kindOf(listCatalogGrants(answer([{ ...grant, state: 'paused' }])))).toBe('unavailable') expect(await kindOf(lookupCatalogAccount(answer(null), 'a@b.c'))).toBe('unavailable') expect(await kindOf(listCatalogSpecies(answer([{ id: 'x' }])))).toBe('unavailable') }) it('folds the server refusals into their kinds', async () => { const refused = (message: string, code = '42501') => stubClient({ rpc: { error: { code, message }, status: 403 } }).client expect(await kindOf(listOfficialSheetsAdmin(refused('rights.mfa')))).toBe('rights.mfa') expect(await kindOf(getOfficialSheetAdmin(refused('not_found'), SHEET))).toBe('not_found') expect(await kindOf(lookupCatalogAccount(refused('rights.owner'), 'a@b.c'))).toBe('rights.owner') expect(await kindOf(createSpecies(refused('species.exists', 'P0001'), { id: 'x', name_fr: 'X', name_en: 'X' }))) .toBe('species.exists') expect(await kindOf(createSheetWorkingCopy(refused('working_copy.exists', 'P0001'), VERSION, 's'))) .toBe('working_copy.exists') const expired = stubClient({ select: { error: { code: 'PGRST301', message: 'JWT expired' }, status: 401 } }) expect(await kindOf(listSheetVersions(expired.client, SHEET))).toBe('session_expired') }) }) describe('downloadSheetDrawing', () => { it('downloads .svg from the sheet bucket and answers its bytes', async () => { const bytes = new TextEncoder().encode('') const { client, downloads } = stubClient({ download: { data: new Blob([bytes]) } }) expect(await downloadSheetDrawing(client, SHA)).toEqual(bytes) expect(downloads).toEqual([['anatomical-sheet-assets', `${SHA}.svg`]]) }) it('refuses a malformed hash before any request', async () => { const { client, downloads } = stubClient() for (const sha of ['', 'A'.repeat(64), 'a'.repeat(63), `${'a'.repeat(64)}/x`, '../x']) expect(await kindOf(downloadSheetDrawing(client, sha))).toBe('invalid_input') expect(downloads).toEqual([]) }) it('folds Storage refusals: a missing object and a refused one are the same not_found', async () => { const failing = (error: unknown) => stubClient({ download: { error } }).client expect(await kindOf(downloadSheetDrawing(failing({ name: 'StorageApiError', status: 400, code: 'NoSuchKey' }), SHA))) .toBe('not_found') expect(await kindOf(downloadSheetDrawing(failing({ name: 'StorageApiError', status: 404 }), SHA))).toBe('not_found') expect(await kindOf(downloadSheetDrawing(failing({ name: 'StorageApiError', status: 400, code: 'InvalidJWT' }), SHA))) .toBe('session_expired') expect(await kindOf(downloadSheetDrawing(failing({ name: 'StorageUnknownError' }), SHA))).toBe('network') expect(await kindOf(downloadSheetDrawing(failing({ name: 'StorageApiError', status: 500 }), SHA))).toBe('unavailable') }) })