Is there a way for me to either fulfill a promise or face failure?

Question

Is there a way for me to either fulfill a promise or face failure?

Currently, I am working on creating a Thennable function that may return a promise based on its parameters. However, there is a possibility that the parameters are invalid which would require breaking the promise chain with something unexpected. What can be used in this scenario? Here is a rough outline of my current function:

function getThumbnailFromClips(res, clips) {
  var clips = content.clips;
  if (clips.length == 0) {
    res.status(400).send(new Error("Empty playlist"))
    // >> WHAT SHOULD BE RETURNED HERE?  <<
  } else {
    var pick1 = Math.floor(Math.random() * clips.length);
    var sql1 = ` SELECT  <details omitted>   `;
    let promise = client.query(sql1)
    return promise
  }
}

This function is typically called from an app.post callback like so:

app.post("/foo", (req,res)=>{
  getClips(req)
  .then((clips)=>getThumbnailFromClips(res,clips))
  .then(((result)=>createDatabaseEntry(result)))
  .catch(/*etc*/)
})

Also, should it be considered better practice to handle sending the 400 result code within the outermost caller instead?

javascript express es6-promise

Answer 1

Answer №1

The concept of alternating between sending a response and returning something entirely different is not advisable in terms of design. Consistency in return values is key; if you are occasionally returning a promise, then it is best practice to always return a promise. Errors can easily be relayed back through a rejected promise.

Likewise, it is important to avoid having request handler code paths that inconsistently send responses from different locations. This approach makes it difficult to maintain the code effectively ensuring that only one response is sent at all times and that errors are handled uniformly. It is recommended to centralize the response handling within the main request handler code rather than dispersing it throughout sub-functions. Sub-functions should focus on executing operations and returning results, while the request handler body orchestrates these functions, processes their results, and sends the response.

A suggested implementation could look like this:

function getThumbnailFromClips(clips) {
    const clips = content.clips;
    if (clips.length == 0) {
        const err = new Error("Empty playlist");
        err.status = 400;
        return Promise.reject(err);
    } else {
        const pick1 = Math.floor(Math.random() * clips.length);
        const sql1 = ` SELECT  <details omitted>   `;
        return client.query(sql1);
    }
}

app.post("/foo", (req, res) => {
    getClips(req)
        .then(getThumbnailFromClips)
        .then(createDatabaseEntry)
        .then(() => {
            // insert appropriate success status here
            res.send({status: "ok"});
        }).catch(err => {
            // handle all errors here
            const status = err.status || 500;
            res.status(status).send(err);
        });
});

Additionally, note that var is considered outdated. It is recommended to use const or let instead.

Answer 2

The concept of alternating between sending a response and returning something entirely different is not advisable in terms of design. Consistency in return values is key; if you are occasionally returning a promise, then it is best practice to always return a promise. Errors can easily be relayed back through a rejected promise.

Likewise, it is important to avoid having request handler code paths that inconsistently send responses from different locations. This approach makes it difficult to maintain the code effectively ensuring that only one response is sent at all times and that errors are handled uniformly. It is recommended to centralize the response handling within the main request handler code rather than dispersing it throughout sub-functions. Sub-functions should focus on executing operations and returning results, while the request handler body orchestrates these functions, processes their results, and sends the response.

A suggested implementation could look like this:

function getThumbnailFromClips(clips) {
    const clips = content.clips;
    if (clips.length == 0) {
        const err = new Error("Empty playlist");
        err.status = 400;
        return Promise.reject(err);
    } else {
        const pick1 = Math.floor(Math.random() * clips.length);
        const sql1 = ` SELECT  <details omitted>   `;
        return client.query(sql1);
    }
}

app.post("/foo", (req, res) => {
    getClips(req)
        .then(getThumbnailFromClips)
        .then(createDatabaseEntry)
        .then(() => {
            // insert appropriate success status here
            res.send({status: "ok"});
        }).catch(err => {
            // handle all errors here
            const status = err.status || 500;
            res.status(status).send(err);
        });
});

Additionally, note that var is considered outdated. It is recommended to use const or let instead.

Is there a way for me to either fulfill a promise or face failure?

Answer №1

Similar questions

What is the best way to verify a date in the format (yyyy-mm-dd) using jQuery?

Creating a seamless integration between a multi-step form in React and React Router

HTML: Efficiently updating multiple cell contents in a large table using jQuery or JavaScript

Use Javascript to set cookies and remember the show state when clicked

My JSON request seems to be malfunctioning and I can't figure out why

What is the method to convert Javascript values from pixels to percentages?

Partial View fails to render on the webpage

Tips on utilizing CSS modules in React without changing class names

Fetching an image from a fixed storage location with the help of Express JS in Angular 2

Accessing Private Files with Signed URLs from AWS S3

Extract the content from the division and set it as the image source

Creating an error handler in PHP for dynamically adding or removing input fields is a crucial step in ensuring smooth and

Encountering the 401 (Unauthorized) error while attempting to delete data in loopback?

The Tab component's onClick event is nonfunctional

Preserving input data based on click and change events

I'm encountering an error in my terminal while running the code

Looking for an easy solution in RegExp - how to locate the keys?

What is the process for updating an item in Sequelize?

Transferring data from JavaScript to PHP using the $.ajax method for storing information in a MySQL database

What's the best way to handle variables and numerical calculations within PHP loops when dealing with forms?