How to use the rdflib.parse function in rdflib

assignURI(req.fullURL, req.get('Slug'), function(err, loc) {
				if (err !== 201) {
					console.log(err)
					res.sendStatus(500)
					return
				}

				// Parse the entity response body, the resource to add to the container
				var newMember = new rdflib.IndexedFormula();
				newMember.uri = loc; 
				rdflib.parse(req.rawBody, newMember, loc, serialize, function(err, document) {
					// document and newMember are the same thing from here on...
					if (err) {
						// allow the URI to be used again if this is a bad request
						console.log(`error parsing POST body for ${loc}, error: ${err}`);
						db.releaseURI(loc)
						res.sendStatus(400)
						return
					}
					updateInteractionModel(newMember); // newMember is RDFResource, DirectContainer or BasicContainer
					addHeaders(req, res, newMember)

					// check if the client requested a specific interaction model through a Link header
					// if so, override what we found from the RDF content
					// TODO: look for Link type=container as well
					if (hasResourceLink(req)) {
						newMember.interactionModel = ldp.RDFSource

async listContainer (filename, reqUri, containerData, hostname) {
    const resourceGraph = $rdf.graph()

    try {
      $rdf.parse(containerData, resourceGraph, reqUri, 'text/turtle')
    } catch (err) {
      debug.handlers('GET -- Error parsing data: ' + err)
      throw error(500, "Can't parse container")
    }

    try {
      // add container stats
      await ldpContainer.addContainerStats(this, reqUri, filename, resourceGraph)
      // read directory
      const files = await ldpContainer.readdir(filename)
      // iterate through all the files
      await Promise.all(files.map(async file => {
        const { url: fileUri } = await this.resourceMapper.mapFileToUrl(
          { path: path.join(filename, file), hostname })
        return await ldpContainer.addFile(this, resourceGraph, reqUri, fileUri, filename, file)
      }))

request.get(options, function (error, response, body) {
        assert.equal(error, null)
        assert.equal(response.statusCode, 200)
        var globGraph = $rdf.graph()
        $rdf.parse(body, globGraph, address + testDir + '/', 'text/turtle')
        var authz = globGraph.the(undefined, undefined, ns.acl('Authorization'))
        assert.equal(authz, null)
        done()
      })
    })

return new Promise((resolve, reject) => {
    const patchGraph = $rdf.graph()
    $rdf.parse(patchText, patchGraph, patchURI, 'text/n3')
    resolve(patchGraph)
  })
  .catch(err => { throw error(400, `Patch document syntax error: ${err}`) })

async function getQuota (root, serverUri) {
  const filename = path.join(root, 'settings/serverSide.ttl')
  var prefs
  try {
    prefs = await _asyncReadfile(filename)
  } catch (error) {
    debug('Setting no quota. While reading serverSide.ttl, got ' + error)
    return Infinity
  }
  var graph = $rdf.graph()
  const storageUri = serverUri + '/'
  try {
    $rdf.parse(prefs, graph, storageUri, 'text/turtle')
  } catch (error) {
    throw new Error('Failed to parse serverSide.ttl, got ' + error)
  }
  return Number(graph.anyValue($rdf.sym(storageUri), ns.solid('storageQuota'))) || Infinity
}

.on('end', function () {
        const graph = $rdf.graph()
        $rdf.parse(data, graph, baseUri, from, function (err) {
          if (err) return reject(err)
          resolve(serialize(graph, baseUri, to))
        })
      })
  })

ldp.readFile(metaFile, function (err, rawMetadata) {
          if (err) {
            return callback(err)
          }

          var metadataGraph = $rdf.graph()
          try {
            $rdf.parse(
              rawMetadata,
              metadataGraph,
              fileBaseUri,
              'text/turtle')
          } catch (dirErr) {
            return callback(error(err, 'Can\'t parse container metadata'))
          }
          return callback(null, metadataGraph)
        })
      } else {

this.text2graph = function(text,url,contentType){
    contentType = contentType || this.guessFileType(url)
    var graph=$rdf.graph();
    try{
        $rdf.parse(text,graph,url,contentType);
        return graph;
    } catch(err){
        self.err=err
        return false
    }
}
this.add = async function(parentFolder,newThing,type,content) {