No commit message

unknown-target

@@ -0,0 +1,100 @@
+import { Zodios } from '@zodios/core';
+import { ZodiosHooks, type ZodiosHooksInstance } from '@zodios/react';
+import { isAxiosError } from 'axios';
+
+import { backendApi } from './backendApi.ts';
+import { lapisApi } from './lapisApi.ts';
+import { seqSetCitationApi } from './seqSetCitationApi.ts';
+import { problemDetail } from '../types/backend.ts';
+import type { SequenceRequest } from '../types/lapis.ts';
+import type { ClientConfig } from '../types/runtimeConfig.ts';
+import { fastaEntries } from '../utils/parseFasta.ts';
+import { isAlignedSequence, isUnalignedSequence, type SequenceType } from '../utils/sequenceTypeHelpers.ts';
+
+export function backendClientHooks(clientConfig: ClientConfig) {
+    const zodiosHooks = new ZodiosHooks('loculus', new Zodios(clientConfig.backendUrl, backendApi));
+    return {
+        zodiosHooks,
+        utilityHooks: {
+            useGetProcessedSequencesCount(token: string) {
+                return zodiosHooks.useGetProcessedSequencesCount({
+                    headers: { Authorization: `Bearer ${token}` },
+                });
+            },
+        },
+    };
+}
+
+export function lapisClientHooks(lapisUrl: string) {
+    const zodiosHooks = new ZodiosHooks('lapis', new Zodios(lapisUrl, lapisApi, { transform: false }));
+    return {
+        zodiosHooks,
+        utilityHooks: {
+            useGetSequence(accessionVersion: string, sequenceType: SequenceType, isMultiSegmented: boolean) {
+                const { data, error, isLoading } = getSequenceHook(
+                    zodiosHooks,
+                    {
+                        accessionVersion,
+                        dataFormat: 'FASTA',
+                    },
+                    sequenceType,
+                    isMultiSegmented,
+                );
+
+                if (data === undefined) {
+                    if (isAxiosError(error)) {
+                        const maybeProblemDetail = error.response?.data.error ?? error.response?.data;
+
+                        const problemDetailParseResult = problemDetail.safeParse(maybeProblemDetail);
+
+                        if (problemDetailParseResult.success) {
+                            return { data: null, error: problemDetailParseResult.data, isLoading };
+                        }
+                    }
+
+                    return { data, error, isLoading };
+                }
+
+                const parseResult = fastaEntries.safeParse(data);
+
+                if (parseResult.success) {
+                    return {
+                        data: parseResult.data.length > 0 ? parseResult.data[0] : null,
+                        error,
+                        isLoading,
+                    };
+                }
+                return {
+                    data: undefined,
+                    error: parseResult.error,
+                    isLoading,
+                };
+            },
+        },
+    };
+}
+
+function getSequenceHook(
+    hooks: ZodiosHooksInstance<typeof lapisApi>,
+    request: SequenceRequest,
+    sequenceType: SequenceType,
+    isMultiSegmented: boolean,
+) {
+    if (isUnalignedSequence(sequenceType)) {
+        return isMultiSegmented
+            ? hooks.useUnalignedNucleotideSequencesMultiSegment(request, { params: { segment: sequenceType.name } })
+            : hooks.useUnalignedNucleotideSequences(request);
+    }
+
+    if (isAlignedSequence(sequenceType)) {
+        return isMultiSegmented
+            ? hooks.useAlignedNucleotideSequencesMultiSegment(request, { params: { segment: sequenceType.name } })
+            : hooks.useAlignedNucleotideSequences(request);
+    }
+
+    return hooks.useAlignedAminoAcidSequences(request, { params: { gene: sequenceType.name } });
+}
+
+export function seqSetCitationClientHooks(clientConfig: ClientConfig) {
+    return new ZodiosHooks('loculus', new Zodios(clientConfig.backendUrl, seqSetCitationApi));
+}

website/src/services/backendApi.ts

@@ -250,6 +250,15 @@ const infoEndpoint = makeEndpoint({
     response: info,
 });
 
+const getProcessedSequencesCountEndpoint = makeEndpoint({
+    method: 'get',
+    path: '/debug/processed-sequences-count',
+    alias: 'getProcessedSequencesCount',
+    parameters: [authorizationHeader],
+    response: z.record(z.string(), z.number()),
+    errors: [notAuthorizedError],
+});
+
 export const backendApi = makeApi([
     submitEndpoint,
     reviseEndpoint,
@@ -264,4 +273,5 @@ export const backendApi = makeApi([
     getDataUseTermsHistoryEndpoint,
     setDataUseTerms,
     infoEndpoint,
+    getProcessedSequencesCountEndpoint,
 ]);

website/src/services/backendClient.ts

@@ -24,4 +24,10 @@ export class BackendClient extends ZodiosWrapperClient<typeof backendApi> {
             () => false,
         );
     }
+
+    public getProcessedSequencesCount(token: string) {
+        return this.call('getProcessedSequencesCount', {
+            headers: createAuthorizationHeader(token),
+        });
+    }
 }

website/src/services/serviceHooks.ts

@@ -12,7 +12,17 @@ import { fastaEntries } from '../utils/parseFasta.ts';
 import { isAlignedSequence, isUnalignedSequence, type SequenceType } from '../utils/sequenceTypeHelpers.ts';
 
 export function backendClientHooks(clientConfig: ClientConfig) {
-    return new ZodiosHooks('loculus', new Zodios(clientConfig.backendUrl, backendApi));
+    const zodiosHooks = new ZodiosHooks('loculus', new Zodios(clientConfig.backendUrl, backendApi));
+    return {
+        zodiosHooks,
+        utilityHooks: {
+            useGetProcessedSequencesCount(token: string) {
+                return zodiosHooks.useGetProcessedSequencesCount({
+                    headers: { Authorization: `Bearer ${token}` },
+                });
+            },
+        },
+    };
 }
 
 export function lapisClientHooks(lapisUrl: string) {

website/src/services/zodiosWrapperClient.ts

@@ -99,4 +99,8 @@ export class ZodiosWrapperClient<Api extends ZodiosEndpointDefinitions> {
             instance: method,
         };
     }
+
+    public async getProcessedSequencesCount(): Promise<Result<Record<string, number>, ProblemDetail>> {
+        return this.call('getProcessedSequencesCount');
+    }
 }