viewer/src/routes/bridge.ts

import Row from "./Row";
import { statusMessage } from "./store";

const baseURL = "https://dylanebert-research-tracker-backend.hf.space";
// const baseURL = "http://localhost:8000";

export const fetchRows = async (): Promise<Row[] | null> => {
    statusMessage.set(`<span>Fetching data from https://dylanebert-research-tracker-backend.hf.space/data</span>`);
    try {
        const response = await fetch(baseURL + "/data", {
            method: "GET",
            headers: {
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
                "Cache-Control": "no-cache",
            },
        });
        const rows = await response.json();
        statusMessage.reset();
        return rows;
    } catch (e) {
        console.error(e);
        statusMessage.set(
            `<span style="color: red;">Error: Failed to fetch data from https://dylanebert-research-tracker-backend.hf.space/data</span>`
        );
        return null;
    }
};

export const addEntry = async (selection: Record<string | number, any>): Promise<Row | null> => {
    if (!("Name" in selection)) return null;
    const value = selection["Name"] as string;
    let row: Row | null = new Row();
    const field = await inferFieldType(row, value);
    if (!field) return null;
    if (field === "Name") {
        row.Name = value;
    } else if (field === "Paper") {
        row.Paper = value;
    } else if (field === "Code") {
        row.Code = value;
    } else if (field === "Space") {
        row.Space = value;
    } else if (field === "Model") {
        row.Model = value;
    } else if (field === "Dataset") {
        row.Dataset = value;
    } else if (field === "Project") {
        row.Project = value;
    } else {
        statusMessage.set(`<span style="color: red;">Error: Failed to infer field type for <b>${value}</b></span>`);
        return null;
    }
    row = await inferFields(row);
    if (!row) {
        return null;
    }
    const response = await fetch(baseURL + "/add-entry", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
        },
        body: JSON.stringify(row),
    });
    const data = await response.json();
    if (data.error || !data.success) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to add entry</span>`);
        }
        return null;
    }
    statusMessage.append(`<br><span style="color: green;">Added entry for "${row.Name}"</span>`);

    return row;
};

export const editEntry = async (row: Row): Promise<Row | null> => {
    row.Orgs = Array.isArray(row.Orgs) ? row.Orgs : (row.Orgs as any).split(",").map((org: string) => org.trim());
    row.Authors = Array.isArray(row.Authors)
        ? row.Authors
        : (row.Authors as any).split(",").map((author: string) => author.trim());
    row.Tags = Array.isArray(row.Tags) ? row.Tags : (row.Tags as any).split(",").map((tag: string) => tag.trim());
    const response = await fetch(baseURL + "/edit-entry", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
        },
        body: JSON.stringify(row),
    });
    const data = await response.json();
    if (data.error || !data.success) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to edit entry</span>`);
        }
        return null;
    }
    statusMessage.append(`<br><span style="color: green;">Edited entry for "${row.Name}"</span>`);
    return row;
};

export const deleteEntry = async (row: Row): Promise<Row | null> => {
    row.Orgs = Array.isArray(row.Orgs) ? row.Orgs : (row.Orgs as any).split(",").map((org: string) => org.trim());
    row.Authors = Array.isArray(row.Authors)
        ? row.Authors
        : (row.Authors as any).split(",").map((author: string) => author.trim());
    row.Tags = Array.isArray(row.Tags) ? row.Tags : (row.Tags as any).split(",").map((tag: string) => tag.trim());
    const response = await fetch(baseURL + "/delete-entry", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
        },
        body: JSON.stringify(row),
    });
    const data = await response.json();
    if (data.error || !data.success) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to delete entry</span>`);
        }
        return null;
    }
    statusMessage.append(`<br><span style="color: green;">Deleted entry for "${row.Name}"</span>`);
    return row;
};

export const inferFields = async (row: Row): Promise<Row | null> => {
    const key = row.Name || row.Paper || row.Code || row.Space || row.Model || row.Dataset || row.Project;
    statusMessage.set(`<span>Inferring fields for <b>${key}</b></span>`);
    const paper = row.Paper || (await inferPaper(row));
    const code = row.Code || (await inferCode(row));
    const name = row.Name || (await inferName(row));
    if (!name) {
        return null;
    }
    row.Name = name;
    const authors = row.Authors.length == 0 ? await inferAuthors(row) : row.Authors;
    const orgs = row.Orgs.length == 0 ? await inferOrgs(row) : row.Orgs;
    const date = row.Date || (await inferDate(row));
    const model = row.Model || (await inferModel(row));
    const dataset = row.Dataset || (await inferDataset(row));
    if (paper) {
        row.Paper = paper;
    }
    if (code) {
        row.Code = code;
    }
    if (authors) {
        row.Authors = Array.isArray(authors) ? authors : authors.split(",").map((author: string) => author.trim());
    }
    if (orgs) {
        row.Orgs = Array.isArray(orgs) ? orgs : orgs.split(",").map((org: string) => org.trim());
    }
    if (date) {
        row.Date = date;
    }
    if (model) {
        row.Model = model;
    }
    if (dataset) {
        row.Dataset = dataset;
    }
    statusMessage.append(`<br><span style="color: green;">Finished inferring fields for <b>${row.Name}</b></span>`);
    return row;
};

const inferFieldType = async (row: Row, value: string): Promise<string | null> => {
    let data;
    try {
        const response = await fetch(baseURL + "/infer-field", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
            },
            body: JSON.stringify({ value }),
        });
        data = await response.json();
    } catch (e) {
        statusMessage.append(
            `<br><span style="color: red;">Error: Failed to infer field type for <b>${value}</b></span>`
        );
        return null;
    }
    if (data.error || !data.field || !(data.field in row)) {
        statusMessage.set(`<span style="color: red;">Error: Failed to infer field type for <b>${value}</b></span>`);
        return null;
    }
    statusMessage.set(`<span style="color: green;">Inferred field type: ${data.field}</span>`);
    return data.field;
};

const inferPaper = async (row: Row) => {
    statusMessage.append(`<br><span>Inferring paper...</span>`);
    let data;
    try {
        const response = await fetch(baseURL + "/infer-paper", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
            },
            body: JSON.stringify(row),
        });
        data = await response.json();
    } catch (e) {
        statusMessage.remove("<br><span>Inferring paper...</span>");
        statusMessage.append(`<br><span style="color: red;">Error: Failed to infer paper</span>`);
        return null;
    }
    statusMessage.remove("<br><span>Inferring paper...</span>");
    if (data.error || !data.paper) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else if (data.message) {
            statusMessage.append(`<br><span>${data.message}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to infer paper</span>`);
        }
        return null;
    }
    const link = `<a href="${data.paper}" target="_blank">${data.paper}</a>`;
    statusMessage.append(`<br><span style="color: green;">Inferred paper: ${link}</span>`);
    return data.paper;
};

const inferCode = async (row: Row) => {
    statusMessage.append(`<br><span>Inferring code...</span>`);
    let data;
    try {
        const response = await fetch(baseURL + "/infer-code", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
            },
            body: JSON.stringify(row),
        });
        data = await response.json();
    } catch (e) {
        statusMessage.remove("<br><span>Inferring code...</span>");
        statusMessage.append(`<br><span style="color: red;">Error: Failed to infer code</span>`);
        return null;
    }
    statusMessage.remove("<br><span>Inferring code...</span>");
    if (data.error || !data.code) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else if (data.message) {
            statusMessage.append(`<br><span>${data.message}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to infer code</span>`);
        }
        return null;
    }
    const link = `<a href="${data.code}" target="_blank">${data.code}</a>`;
    statusMessage.append(`<br><span style="color: green;">Inferred code: ${link}</span>`);
    return data.code;
};

const inferName = async (row: Row) => {
    statusMessage.append(`<br><span>Inferring name...</span>`);
    let data;
    try {
        const response = await fetch(baseURL + "/infer-name", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
            },
            body: JSON.stringify(row),
        });
        data = await response.json();
    } catch (e) {
        statusMessage.remove("<br><span>Inferring name...</span>");
        statusMessage.append(`<br><span style="color: red;">Error: Failed to infer name</span>`);
        return null;
    }
    statusMessage.remove("<br><span>Inferring name...</span>");
    if (data.error || !data.name) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else if (data.message) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.message}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to infer name</span>`);
        }
        return null;
    }
    statusMessage.append(`<br><span style="color: green;">Inferred name: <b>${data.name}</b></span>`);
    return data.name;
};

const inferAuthors = async (row: Row) => {
    statusMessage.append(`<br><span>Inferring authors...</span>`);
    let data;
    try {
        const response = await fetch(baseURL + "/infer-authors", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
            },
            body: JSON.stringify(row),
        });
        data = await response.json();
    } catch (e) {
        statusMessage.remove("<br><span>Inferring authors...</span>");
        statusMessage.append(`<br><span style="color: red;">Error: Failed to infer authors</span>`);
        return null;
    }
    statusMessage.remove("<br><span>Inferring authors...</span>");
    if (data.error || !data.authors) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else if (data.message) {
            statusMessage.append(`<br><span>${data.message}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to infer authors</span>`);
        }
        return null;
    }
    statusMessage.append(`<br><span style="color: green;">Inferred authors: ${data.authors}</span>`);
    return data.authors;
};

const inferOrgs = async (row: Row) => {
    statusMessage.append(`<br><span>Inferring orgs...</span>`);
    let data;
    try {
        const response = await fetch(baseURL + "/infer-orgs", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
            },
            body: JSON.stringify(row),
        });
        data = await response.json();
    } catch (e) {
        statusMessage.remove("<br><span>Inferring orgs...</span>");
        statusMessage.append(`<br><span style="color: red;">Error: Failed to infer orgs</span>`);
        return null;
    }
    statusMessage.remove("<br><span>Inferring orgs...</span>");
    if (data.error || !data.orgs) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else if (data.message) {
            statusMessage.append(`<br><span>${data.message}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to infer orgs</span>`);
        }
        return null;
    }
    statusMessage.append(`<br><span style="color: green;">Inferred orgs: ${data.orgs}</span>`);
    return data.orgs;
};

const inferDate = async (row: Row) => {
    statusMessage.append(`<br><span>Inferring date...</span>`);
    let data;
    try {
        const response = await fetch(baseURL + "/infer-date", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
            },
            body: JSON.stringify(row),
        });
        data = await response.json();
    } catch (e) {
        statusMessage.remove("<br><span>Inferring date...</span>");
        statusMessage.append(`<br><span style="color: red;">Error: Failed to infer date</span>`);
        return null;
    }
    statusMessage.remove("<br><span>Inferring date...</span>");
    if (data.error || !data.date) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else if (data.message) {
            statusMessage.append(`<br><span>${data.message}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to infer date</span>`);
        }
        return null;
    }
    statusMessage.append(`<br><span style="color: green;">Inferred date: ${data.date}</span>`);
    return data.date;
};

const inferModel = async (row: Row) => {
    statusMessage.append(`<br><span>Inferring model...</span>`);
    let data;
    try {
        const response = await fetch(baseURL + "/infer-model", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
            },
            body: JSON.stringify(row),
        });
        data = await response.json();
    } catch (e) {
        statusMessage.remove("<br><span>Inferring model...</span>");
        statusMessage.append(`<br><span style="color: red;">Error: Failed to infer model</span>`);
        return null;
    }
    statusMessage.remove("<br><span>Inferring model...</span>");
    if (data.error || !data.model) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else if (data.message) {
            statusMessage.append(`<br><span>${data.message}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to infer model</span>`);
        }
        return null;
    }
    statusMessage.append(`<br><span style="color: green;">Inferred model: ${data.model}</span>`);
    return data.model;
};

const inferDataset = async (row: Row) => {
    statusMessage.append(`<br><span>Inferring dataset...</span>`);
    let data;
    try {
        const response = await fetch(baseURL + "/infer-dataset", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN,
            },
            body: JSON.stringify(row),
        });
        data = await response.json();
    } catch (e) {
        statusMessage.remove("<br><span>Inferring dataset...</span>");
        statusMessage.append(`<br><span style="color: red;">Error: Failed to infer dataset</span>`);
        return null;
    }
    statusMessage.remove("<br><span>Inferring dataset...</span>");
    if (data.error || !data.dataset) {
        if (data.error) {
            statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`);
        } else if (data.message) {
            statusMessage.append(`<br><span>${data.message}</span>`);
        } else {
            statusMessage.append(`<br><span style="color: red;">Error: Failed to infer dataset</span>`);
        }
        return null;
    }
    statusMessage.append(`<br><span style="color: green;">Inferred dataset: ${data.dataset}</span>`);
    return data.dataset;
};