Forge UI App Truncating Error Message

[Jason Cookman]

Hi,

We are writing a JIRA Forge app and are noticing the error messages thrown from the backend are truncated. Is there a way to allow it to send the full message to the front end?

Currently this is what our backend code looks like,

// backend 
timeDelete = async ({payload, context}) => {
        const response = await api.fetch(
           // api details here
        );

        if(response.status < 200 || response.status > 299) {
            console.error(await response.clone().text());

            let errorMessage = "Error attempting to delete record";

            try {
                errorMessage += ":\n"
                errorMessage += (await response.json()).errorMessage;
            } catch (err){
                console.error("Issue retrieving error message from body. " + err.message);
                errorMessage += "Issue retrieving error message from body. " + err.message
                    + ". Please reach out to support if needed."
            }

            throw new Error(errorMessage);
        }

        return await response.json();
    }

and this is what the request from the frontend looks like

const deleteRecord = async (workLogId) => {
    try {
        await invoke("timeDelete", payload); // throws error
        await workLogCallout.deleteWorkLog(workLogId);
        if (typeof deleteSuccessFunction !== "undefined") {
            deleteSuccessFunction();
        }
    } catch (err) {
        console.error(err);
        setToastInformation({
            heading: "An error occurred",
            appearance: "error",
            message: err.message
        });
    }
}

//error shown in console 
Issue retrieving error message from body. Unexpected token 'r', "refresh ... (truncated)

[Akash Singh · Accepted solution]

@Jason Cookman, Welcome to the Atlassian Community!

It looks like your backend code is directly throwing an error, expecting the frontend to catch and display the error message. However, since your backend runs in a serverless environment, this approach isn't ideal.

Instead, you should return a structured response containing a status code and the error message inside the statusText or response body. Currently, Forge automatically truncates error messages after a certain length, which can lead to incomplete or unclear error handling.

To ensure proper error propagation, you can use a structured response function like the one below:

badResponse Function Implementation

const badResponse = (statusCode, message) => ({
  statusCode,
  body: JSON.stringify({ error: message }),
});

 Example usage in your scenario,

try {
 // Your backend logic that might fail
 throw new Error("Something went wrong!");
} catch (error) {
 return badResponse(500, error.message);
}

This ensures that the frontend receives a proper response, making error handling more predictable and manageable. 

Also, I highly recommend posting any Forge development-related questions in the Atlassian Developers Community. You'll find like-minded developers there who can provide faster and more relevant assistance for issues like this.

[Jason Cookman]

Thanks for the answer and for the link to the developer community! That solved it!