async function getNode(
  typeName,
  resolveInfo,
  context,
  condition,
  dbCall,
  options = {},
) {
  // get the GraphQL type from the schema using the name
  const type = resolveInfo.schema._typeMap[typeName]
  assert(type, `Type "${typeName}" not found in your schema.`)
  assert(
    getConfigFromSchemaObject(type).sqlTable,
    `joinMonster can't fetch a ${typeName} as a Node unless it has "sqlTable" tagged.`,
  )

  // we need to determine what the WHERE function should be
  let where = buildWhereFunction(type, condition, options)

  // our getGraphQLType expects every requested field to be in the schema definition. "node" isn't a parent of whatever type we're getting, so we'll just wrap that type in an object that LOOKS that same as a hypothetical Node type
  const fakeParentNode = {
    _fields: {
      node: {
        type,
        name: type.name.toLowerCase(),
        args: [],
        extensions: {
          joinMonster: {
            where,
          },
        },
      },
    },
  }
  const namespace = new AliasNamespace(options.minify, options.aliasPrefix)
  const sqlAST = {}
  const fieldNodes = resolveInfo.fieldNodes || resolveInfo.fieldASTs
  // uses the same underlying function as the main `joinMonster`
  queryAST.populateASTNode.call(
    resolveInfo,
    fieldNodes[0],
    fakeParentNode,
    sqlAST,
    namespace,
    0,
    options,
    context,
  )
  queryAST.pruneDuplicateSqlDeps(sqlAST, namespace)
  const { sql, shapeDefinition } = await compileSqlAST(sqlAST, context, options)
  const data = arrToConnection(
    await handleUserDbCall(dbCall, sql, sqlAST, shapeDefinition),
    sqlAST,
  )
  await nextBatch(sqlAST, data, dbCall, context, options)
  if (!data) return data
  data.__type__ = type.name
  return data
}
A helper for resolving the Node type in Relay.
@param {String} typeName - The Name of the GraphQLObjectType
@param {Object} resolveInfo - Contains the parsed GraphQL query, schema definition, and more. Obtained from the fourth argument to the resolver.
@param {Object} context - An arbitrary object that gets passed to the `where` function. Useful for contextual infomation that influeces the  WHERE condition, e.g. session, logged in user, localization.
@param {where|Number|String|Array} condition - A value to determine the `where` function for searching the node. If it's a function, that function will be used as the `where` function. Otherwise, it is assumed to be the value(s) of the `primaryKey`. An array of values is needed for composite primary keys.
@param {Function} dbCall - A function that is passed the compiled SQL that calls the database and returns (a promise of) the data.
@param {Object} [options] - Same as `joinMonster` function's options.
@returns {Promise.<Object>} The correctly nested data from the database. The GraphQL Type is added to the "\_\_type\_\_" property, which is helpful for the `resolveType` function in the `nodeDefinitions` of **graphql-relay-js**.