refactor(website): parse table data more strictly

website/src/components/SequenceDetailsPage/SequenceDataUI.tsx

@@ -4,9 +4,8 @@ import DataTable from './DataTable';
 import { RevokeButton } from './RevokeButton';
 import { SequencesContainer } from './SequencesContainer';
 import { getDataTableData } from './getDataTableData';
-import { type TableDataEntry } from './types';
+import { type TableData } from './types';
 import { routes } from '../../routes/routes';
-import { DATA_USE_TERMS_FIELD } from '../../settings.ts';
 import { type DataUseTermsHistoryEntry, type Group, type RestrictedDataUseTerms } from '../../types/backend';
 import { type Schema } from '../../types/config';
 import { type ReferenceGenomesSequenceNames } from '../../types/referencesGenomes';
@@ -16,7 +15,7 @@ import ErrorBox from '../common/ErrorBox';
 import MdiEye from '~icons/mdi/eye';
 
 interface Props {
-    tableData: TableDataEntry[];
+    tableData: TableData;
     organism: string;
     accessionVersion: string;
     dataUseTermsHistory: DataUseTermsHistoryEntry[];
@@ -40,23 +39,19 @@ export const SequenceDataUI: FC<Props> = ({
     accessToken,
     referenceGenomeSequenceNames,
 }: Props) => {
-    const groupId = tableData.find((entry) => entry.name === 'groupId')!.value as number;
-
+    const { groupId, isRestricted } = tableData;
     const isMyGroup = myGroups.some((group) => group.groupId === groupId);
 
-    dataUseTermsHistory.sort((a, b) => (a.changeDate > b.changeDate ? -1 : 1));
-    const currentDataUseTerms = dataUseTermsHistory[0].dataUseTerms;
-
-    const dataUseTerms = tableData.find((entry) => entry.name === DATA_USE_TERMS_FIELD);
-    const isRestricted = dataUseTerms?.value.toString().toUpperCase() === 'RESTRICTED';
+    const dataUseTermsHistoryDescending = dataUseTermsHistory.sort((a, b) => (a.changeDate > b.changeDate ? -1 : 1));
+    const latestDataUseTermsChange = dataUseTermsHistoryDescending[0].dataUseTerms;
 
     const genes = referenceGenomeSequenceNames.genes;
     const nucleotideSegmentNames = referenceGenomeSequenceNames.nucleotideSequences;
     const reference = referenceGenomeSequenceNames.insdcAccessionFull;
 
     const loadSequencesAutomatically = schema.loadSequencesAutomatically === true;
 
-    const dataTableData = getDataTableData(tableData);
+    const dataTableData = getDataTableData(tableData.entries);
 
     return (
         <>
@@ -69,7 +64,11 @@ export const SequenceDataUI: FC<Props> = ({
                     </a>
                 </ErrorBox>
             )}
-            <DataTable dataTableData={dataTableData} dataUseTermsHistory={dataUseTermsHistory} reference={reference} />
+            <DataTable
+                dataTableData={dataTableData}
+                dataUseTermsHistory={dataUseTermsHistoryDescending}
+                reference={reference}
+            />
             <div className='mt-10'>
                 <SequencesContainer
                     organism={organism}
@@ -94,7 +93,7 @@ export const SequenceDataUI: FC<Props> = ({
                             clientConfig={clientConfig}
                             accessToken={accessToken}
                             accessionVersion={[accessionVersion.split('.')[0]]}
-                            dataUseTerms={currentDataUseTerms as RestrictedDataUseTerms}
+                            dataUseTerms={latestDataUseTermsChange as RestrictedDataUseTerms}
                         />
                     )}
 

website/src/components/SequenceDetailsPage/types.ts

@@ -1,11 +1,41 @@
+import { z } from 'zod';
+
+import { DATA_USE_TERMS_FIELD, GROUP_ID_FIELD } from '../../settings.ts';
+import { DataUseTermsTypeSchema, restrictedDataUseTermsType, type DataUseTermsType } from '../../types/backend.ts';
 import type { CustomDisplay, MetadataType } from '../../types/config.ts';
+
+export type TableDataEntryValue = string | number | boolean;
+export type TableDataEntryType = { kind: 'metadata'; metadataType: MetadataType } | { kind: 'mutation' };
+
 export type TableDataEntry = {
     label: string;
     name: string;
-    value: string | number | boolean;
+    value: TableDataEntryValue;
     header: string;
     customDisplay?: CustomDisplay;
     type: TableDataEntryType;
 };
 
-export type TableDataEntryType = { kind: 'metadata'; metadataType: MetadataType } | { kind: 'mutation' };
+export class TableData {
+    public readonly entries: TableDataEntry[];
+
+    constructor(tableData: TableDataEntry[]) {
+        this.entries = tableData;
+    }
+
+    public get dataUseTerms(): DataUseTermsType {
+        return DataUseTermsTypeSchema.parse(this.getEntryByName(DATA_USE_TERMS_FIELD));
+    }
+
+    public get isRestricted(): boolean {
+        return this.dataUseTerms === restrictedDataUseTermsType;
+    }
+
+    public get groupId(): number {
+        return z.number().parse(this.getEntryByName(GROUP_ID_FIELD));
+    }
+
+    public getEntryByName(entryName: string): TableDataEntryValue | undefined {
+        return this.entries.find((entry) => entry.name === entryName)?.value;
+    }
+}

website/src/types/backend.ts

@@ -90,6 +90,8 @@ export const dataUseTermsTypes = [restrictedDataUseTermsType, openDataUseTermsTy
 
 export type DataUseTermsType = typeof openDataUseTermsType | typeof restrictedDataUseTermsType;
 
+export const DataUseTermsTypeSchema = z.enum(dataUseTermsTypes);
+
 export const restrictedDataUseTerms = z.object({
     type: z.literal(restrictedDataUseTermsType),
     restrictedUntil: z.string(),
@@ -115,6 +117,11 @@ export const dataUseTermsHistoryEntry = z.object({
 
 export type DataUseTermsHistoryEntry = z.infer<typeof dataUseTermsHistoryEntry>;
 
+export const dataUseTermsHistory = z.array(dataUseTermsHistoryEntry);
+
+export type DataUseTermsHistory = z.infer<typeof dataUseTermsHistory>;
+
+// Instead try to add it as a method on dataUseTermsHistory
 export const sequenceEntryStatus = accessionVersion.merge(
     z.object({
         status: sequenceEntryStatusNames,