努力使用Ramda.js重构这个，这是我有多远

Question

I'm learning Ramda.js. The function I'm trying to refactor using Ramda is below. It calls a function firestore database method to get some data. But firestore returns data inside a snapshot method and we need to call .data() . Depending on the result, I want to construct different response.

Would love to here your thought process

const queryForUsersQuizResults = async (request, response) => {
  try {
    const snapshot = await firestore
      .collection("quizResults")
      .doc(request.user.uid)
      .collection("courses_chapters")
      .doc(request.params.courseId + "_" + request.params.chapterId)
      .get();

    let data = snapshot.data();
    if (!data) {
      data = {
        message: "result not found for this user for this course and chapter"
      };
    }

    return response.send(data);
  } catch (error) {
    return response.status(500).send(error);
  }
}

...and here is what I have been able to refactor, would love to see better/other ways of doing this (I'm not sure if this even works). I'm struggling with the sendResult method.

//get user id
export const getUserId = pathOr('', ['user', 'uid']);

// get chapter id
export const getChapterId = concat(pathOr('', ['params', 'courseId']), '_', pathOr('', ['params', 'chapterId']));

//queryQuizResult
export const query = curry(async (firestore, request) => {
  return tryCatch(() =>
    firestore
    .collection("quizResults")
    .doc(getUserId(request))
    .collection("courses_chapters")
    .doc(getChapterId(request))
    .get(), F)();
});

//Receives "response" object and calls response.status with the value passed to the new status function
export const status = invoker(1, "status");

//Receives "response" object and calls response.send witht he value passed to the new send function
export const send = invoker(1, "send");

//Create {"message",Your_Error} object
export const constructError = objOf('message');

//Returns JSON from Firestore's snapshot object
export const getDataFromSnapshot = (snapshot) => snapshot.data();

//Actual error message
const QUIZ_RESULTS_NOT_FOUND = "Quiz results not found for this user for this course and chapter";

//Returns error message
export const quizResultsNotFoundError = constructError(QUIZ_RESULTS_NOT_FOUND);

//Receives "response" object and calls response.status and then respose.send
export const sendError = pipe(
  status(401),
  send(quizResultsNotFoundError)
);
//Sends valid result  //IS there any better way of doing this?
export const sendResult = (snapshot, response) => {
  const data = getDataFromSnapshot(snapshot);
  response.send(data); //Especially this, I wanted to use the "send" method and pipe things
}

//Main Method
export const  queryForUsersQuizResults = async (firestore, request, response) => {
 const snapshot = await query(firestore, request);
 snapshot ? sendResult(snapshot, response) :sendError(response);
}

Answer 1

Here's the moving parts I see. It's just one of the many possible ways to write the program –

const tryCatch = f =>
  new Promise
    ( (resolve, reject) =>
        { try { resolve (f ()) }
          catch (err) { reject (err) }
        }
    )

const handleSuccess = res => data =>
  res .send (data)

const handleError = res => err =>
  res .status (500) .send (err)

const getSnapshot = (uid, docid) =>
  firestore
    .collection ("quizResults")
    .doc (uid)
    .collection ("courses_chapters")
    .doc (docid)
    .get ()
    .data ()

const queryForUsersQuizResults = (req, res) =>
  tryCatch
    ( () =>
        getSnapshot
          ( req.user.uid
          , req.params.courseId + "_" + req.params.chapterId
          )
    )
    .catch
      ( _ => Promise .reject (Error ("result not found for this user for this course and chapter"))
      )

const main = (req, res) =>
  queryForUsersQuizResults (req, res)
    .then
      ( handleSuccess (res)
      , handleError (res)
      )

And here's a working demo to show the concepts in action -

 const DB = { 1: "ant" , 2: "bear" , 3: "cuttlefish" } const queryForUsersQuizResults = (id = 0) => { if (DB[id] === undefined) throw Error (`no record for id: ${id}`) else return DB[id] } const tryCatch = f => { try { return Promise .resolve (f ()) } catch (err) { return Promise .reject (err) } } const fakeResponse = (status = 200) => ({ send: data => console .log ("=>", status, data) , status: n => fakeResponse (n) }) const demo = (req, res) => tryCatch (() => queryForUsersQuizResults (req.params.uid)) .then ( data => res .send (data) , err => res .status (500) .send (err) ) demo ( { params: { uid: 1 } } , fakeResponse () ) // => 200 ant demo ( { params: { uid: 2 } } , fakeResponse () ) // => 200 bear demo ( { params: { uid: 3 } } , fakeResponse () ) // => 200 cuttlefish demo ( { params: { uid: 4 } } , fakeResponse () ) // => 500 Error: no record for id: 4 

Answer 2

I also think that what you have already is fine, if you really wanted to use composition, it could be something like this:

export const sendResult = (snapshot, response) =>
  pipe(getDataFromSnapshot, flip(send)(response))
    (snapshot);

You need to use flip as you don't have (at the time of the pipe definition) the result of getDataFromSnapshot(snapshot) yet, but you already have the object holding the implementation of your send method.