Monolithic function

[rathorevaibhav]

Description

Following is a monolithic function that runs when a GraphQL API call is made to create a manuscript. The front-end sends a payload in the API request which is then processed by the function below and returns the created manuscript object.

1. Count the number of different actions this function is responsible for?
2. What would be the correct way to divide responsibilities?
3. Refactor the code and post your solution as per Single Responsibility Principle

async createManuscript(_, vars, ctx) {
  const submissionForm = await models.Form.findOneByField(
    'purpose',
    'submit',
  )

  const { meta, files } = vars.input
  const parsedFormStructure = submissionForm.structure.children
    .map(formElement => {
      const parsedName = formElement.name && formElement.name.split('.')[1]
      if (parsedName) {
        return {
          name: parsedName,
          component: formElement.component,
        }
      }
      return undefined
    })
    .filter(x => x !== undefined)

  const emptySubmission = parsedFormStructure.reduce((acc, curr) => {
    acc[curr.name] = curr.component === 'CheckboxGroup' || curr.component === 'LinksInput' ? [] : ''
    return {
      ...acc,
    }
  }, {})

  // We want the submission information to be stored as JSONB but we want the input to come in as a JSON string
  const submission = vars.input.submission
    ? JSON.parse(vars.input.submission)
    : emptySubmission

  const emptyManuscript = {
    meta,
    status: 'new',
    submission,
    submitterId: ctx.user,
    // Create two channels: 1. free for all involved, 2. editorial
    channels: [
      {
        topic: 'Manuscript discussion',
        type: 'all',
      },
      {
        topic: 'Editorial discussion',
        type: 'editorial',
      },
    ],
    files: files.map(file => {
      return {
        ...file,
      }
    }),
    reviews: [],
    teams: [
      {
        role: 'author',
        name: 'Author',
        members: [{ user: { id: ctx.user } }],
        objectType: 'manuscript',
      },
    ],
  }

  const manuscript = await models.Manuscript.query().upsertGraphAndFetch(
    emptyManuscript,
    { relate: true },
  )

  const { source } = manuscript.meta
  if (typeof source === 'string') {
    const images = await base64Images(source)
    if (images.length > 0) {
      const uploadedImages = await Promise.all(
        map(images, async image => {
          const uploadedImage = await uploadImage(image, manuscript.id)
          return uploadedImage
        }),
      )
      const uploadedImagesWithUrl = await getFilesWithUrl(uploadedImages)
      const $ = cheerio.load(source)
      map(images, (image, index) => {
        const elem = $('img').get(index)
        const $elem = $(elem)
        $elem.attr('data-fileid', uploadedImagesWithUrl[index].id)
        $elem.attr('alt', uploadedImagesWithUrl[index].name)
        $elem.attr(
          'src',
          uploadedImagesWithUrl[index].storedObjects.find(
            storedObject => storedObject.type === 'medium',
          ).url,
        )
      })
      manuscript.meta.source = $.html()
    }
  }

  const updatedManuscript = await models.Manuscript.query().updateAndFetchById(
    manuscript.id,
    manuscript,
  )

  // newly uploaded files get tasks populated
  await populateTemplatedTasksForManuscript(manuscript.id)

  return updatedManuscript
}