backendService.ts

import axios, { type AxiosInstance, type AxiosRequestConfig, type AxiosResponse } from 'axios';
import { z, type ZodSchema } from 'zod';

import { UserFacingError } from '../components/ErrorReportInstruction.tsx';
import { apiKeyMetadataSchema, generatedApiKeySchema } from '../types/ApiKey.ts';
import {
    collectionSchema,
    collectionSummarySchema,
    type CollectionRequest,
    type CollectionUpdate,
} from '../types/Collection.ts';
import { type ProblemDetail, problemDetailSchema } from '../types/ProblemDetail.ts';
import { publicUserSchema } from '../types/PublicUser.ts';
import {
    type SubscriptionPutRequest,
    type SubscriptionRequest,
    subscriptionResponseSchema,
    triggerEvaluationResponseSchema,
} from '../types/Subscription.ts';

const X_REQUEST_ID_HEADER = 'x-request-id';

type EndpointParameters<Response> = {
    url: string;
    requestParams?: Record<string, string | boolean | undefined>;
    schema: ZodSchema<Response>;
};

type EndpointParametersWithBody<Request, Response> = EndpointParameters<Response> & { data: Request };

class ApiService {
    private readonly axiosInstance: AxiosInstance;

    constructor(baseURL: string) {
        this.axiosInstance = axios.create({ baseURL });
    }

    public async get<Response>({ url, requestParams, schema }: EndpointParameters<Response>): Promise<Response> {
        return this.handleRequest({ url, method: 'get', params: requestParams }, schema);
    }

    public async post<Request, Response>({
        url,
        data,
        requestParams,
        schema,
    }: EndpointParametersWithBody<Request, Response>): Promise<Response> {
        return this.handleRequest({ url, method: 'post', params: requestParams, data }, schema);
    }

    public async put<Request, Response>({
        url,
        data,
        requestParams,
        schema,
    }: EndpointParametersWithBody<Request, Response>): Promise<Response> {
        return this.handleRequest({ url, method: 'put', params: requestParams, data }, schema);
    }

    public async delete<Response>({ url, requestParams, schema }: EndpointParameters<Response>): Promise<Response> {
        return this.handleRequest({ url, method: 'delete', params: requestParams }, schema);
    }

    private async handleRequest<Request, Response>(request: AxiosRequestConfig<Request>, schema: ZodSchema<Response>) {
        try {
            const response = await this.axiosInstance.request(request);
            return schema.parse(response.data);
        } catch (error) {
            if (axios.isAxiosError(error)) {
                if (error.response) {
                    this.handleErrors(error.response);
                }

                if (error.code === axiosNotFoundError) {
                    throw new BackendNotAvailable(error.config?.baseURL ?? '');
                }
            }
            throw error;
        }
    }

    private handleErrors(response: AxiosResponse) {
        if (response.status >= 300 || response.status < 200) {
            const backendError = problemDetailSchema.safeParse(response.data);
            if (backendError.success) {
                throw new BackendError(
                    backendError.data.detail ?? '(no detail)',
                    response.status,
                    backendError.data,
                    response.config.url ?? '',
                    response.headers[X_REQUEST_ID_HEADER],
                );
            }

            throw new UnknownBackendError(response.statusText, response.status, response.config.url ?? '');
        }
    }
}

const axiosNotFoundError = 'ENOTFOUND';

export class BackendError extends UserFacingError {
    constructor(
        message: string,
        public readonly status: number,
        public readonly problemDetail: ProblemDetail,
        public readonly requestedData: string,
        public readonly requestId: string | undefined,
    ) {
        super(message);
        this.name = 'BackendError';
    }
}

export class UnknownBackendError extends Error {
    constructor(
        message: string,
        public readonly status: number,
        public readonly requestedData: string,
    ) {
        super(message);
        this.name = 'UnknownBackendError';
    }
}

export class BackendNotAvailable extends UserFacingError {
    constructor(url: string) {
        super(`Backend not available under ${url}`);
        this.name = 'BackendNotAvailable';
    }
}

export class BackendService extends ApiService {
    public async getSubscriptions() {
        const url = `/subscriptions`;
        return this.get({ url, schema: z.array(subscriptionResponseSchema) });
    }

    public async getEvaluateTrigger({ subscriptionId }: { subscriptionId: string }) {
        const url = `/subscriptions/evaluateTrigger`;
        return this.get({
            url,
            requestParams: { id: subscriptionId },
            schema: triggerEvaluationResponseSchema,
        });
    }

    public async postSubscription({ subscription }: { subscription: SubscriptionRequest }) {
        const url = `/subscriptions`;
        return this.post({ url, data: subscription, schema: subscriptionResponseSchema });
    }

    public async putSubscription({
        subscription,
        subscriptionId,
    }: {
        subscription: SubscriptionPutRequest;
        subscriptionId: string;
    }) {
        const url = `/subscriptions/${subscriptionId}`;
        return this.put({
            url,
            data: subscription,
            schema: subscriptionResponseSchema,
        });
    }

    public async deleteSubscription({ subscriptionId }: { subscriptionId: string }) {
        const url = `/subscriptions/${subscriptionId}`;
        return this.delete({
            url,
            schema: z.literal('').refine((_input): _input is never => true),
        });
    }

    public async getMe() {
        return this.get({ url: '/users/me', schema: publicUserSchema });
    }

    public async getUser({ id }: { id: number }) {
        return this.get({ url: `/users/${id}`, schema: publicUserSchema });
    }

    public async getCollectionSummaries({
        organism,
        userId,
        excludeSystemCollections,
    }: { organism?: string; userId?: number; excludeSystemCollections?: boolean } = {}) {
        const requestParams: Record<string, string> = {};
        if (organism !== undefined) requestParams.organism = organism;
        if (userId !== undefined) requestParams.userId = String(userId);
        if (excludeSystemCollections !== undefined)
            requestParams.excludeSystemCollections = String(excludeSystemCollections);
        return this.get({
            url: '/collections',
            requestParams: Object.keys(requestParams).length > 0 ? requestParams : undefined,
            schema: z.array(collectionSummarySchema),
        });
    }

    public async getCollections({ organism }: { organism?: string } = {}) {
        const requestParams: Record<string, string> = { includeVariants: 'true' };
        if (organism !== undefined) requestParams.organism = organism;
        return this.get({ url: '/collections', requestParams, schema: z.array(collectionSchema) });
    }

    public async getCollection({ id }: { id: string }) {
        return this.get({ url: `/collections/${id}`, schema: collectionSchema });
    }

    public async postCollection({ collection }: { collection: CollectionRequest }) {
        return this.post({
            url: '/collections',
            data: collection,
            schema: collectionSchema,
        });
    }

    public async putCollection({ id, collection }: { id: string; collection: CollectionUpdate }) {
        return this.put({
            url: `/collections/${id}`,
            data: collection,
            schema: collectionSchema,
        });
    }

    public async deleteCollection({ id }: { id: string }) {
        return this.delete({
            url: `/collections/${id}`,
            schema: z.literal('').refine((_input): _input is never => true),
        });
    }

    /** Returns metadata for the current API key, or throws a 404 BackendError if none exists. */
    public async getApiKey() {
        return this.get({ url: '/api-keys', schema: apiKeyMetadataSchema });
    }

    /** Generates a new API key and returns it. The raw key is shown once and cannot be retrieved again. Throws 409 if a key already exists. */
    public async generateApiKey() {
        return this.post({ url: '/api-keys', data: undefined, schema: generatedApiKeySchema });
    }

    /** Revokes the current API key. Throws 404 if no key exists. */
    public async revokeApiKey() {
        return this.delete({
            url: '/api-keys',
            schema: z.literal('').refine((_input): _input is never => true),
        });
    }
}

let backendServiceForClientside: BackendService | null = null;

export function getBackendServiceForClientside(): BackendService {
    backendServiceForClientside =
        backendServiceForClientside ?? new BackendService(`${new URL(window.location.href).origin}/api`);
    return backendServiceForClientside;
}