onCreateNode Mdx node missing fields

[dustinlacewell]

I am using onCreateNode to handle Mdx type nodes and I'm finding that the node data is missing some expected fields. When I console.table(Object.keys(node)) I get the following:

┌─────────┬────────────────────┐
│ (index) │       Values       │
├─────────┼────────────────────┤
│    0    │        'id'        │
│    1    │     'children'     │
│    2    │      'parent'      │
│    3    │     'internal'     │
│    4    │   'frontmatter'    │
│    5    │     'excerpt'      │
│    6    │     'exports'      │
│    7    │     'rawBody'      │
│    8    │ 'fileAbsolutePath' │
└─────────┴────────────────────┘

Where is body? Where is slug, etc?

[LekoArts]

This is expected behavior as it adds those fields during the createSchemaCustomization step which runs after the createNodes (when onCreateNode is called).

gatsby/packages/gatsby-plugin-mdx/gatsby/create-schema-customization.js

Lines 121 to 294 in a67d339

	const MdxType = schema.buildObjectType({
	name: `Mdx`,
	fields: {
	rawBody: { type: `String!` },
	fileAbsolutePath: { type: `String!` },
	frontmatter: { type: `MdxFrontmatter` },
	slug: {
	type: `String`,
	async resolve(mdxNode, args, context) {
	const nodeWithContext = context.nodeModel.findRootNodeAncestor(
	mdxNode,
	node => node.internal && node.internal.type === `File`
	)
	if (!nodeWithContext) {
	return null
	}
	const fileRelativePath = nodeWithContext.relativePath
	const parsedPath = path.parse(fileRelativePath)
	let relevantPath
	if (parsedPath.name === `index`) {
	relevantPath = fileRelativePath.replace(parsedPath.base, ``)
	} else {
	relevantPath = fileRelativePath.replace(parsedPath.ext, ``)
	}
	return slugify(relevantPath, {
	remove: /[^\w\s$*_+~.()'"!\-:@/]/g, // this is the set of allowable characters
	})
	},
	},
	body: {
	type: `String!`,
	async resolve(mdxNode) {
	const { body } = await processMDX({ node: mdxNode })
	return body
	},
	},
	excerpt: {
	type: `String!`,
	args: {
	pruneLength: {
	type: `Int`,
	defaultValue: 140,
	},
	truncate: {
	type: GraphQLBoolean,
	defaultValue: false,
	},
	},
	async resolve(mdxNode, { pruneLength, truncate }) {
	if (mdxNode.excerpt) {
	return Promise.resolve(mdxNode.excerpt)
	}
	const { mdast } = await processMDX({ node: mdxNode })
	const excerptNodes = []
	visit(mdast, node => {
	if (node.type === `text` || node.type === `inlineCode`) {
	excerptNodes.push(node.value)
	}
	return
	})
	if (!truncate) {
	return prune(excerptNodes.join(` `), pruneLength, `…`)
	}
	return _.truncate(excerptNodes.join(` `), {
	length: pruneLength,
	omission: `…`,
	})
	},
	},
	headings: {
	type: `[MdxHeadingMdx]`,
	args: {
	depth: {
	type: `HeadingsMdx`,
	},
	},
	async resolve(mdxNode, { depth }) {
	// TODO: change this to operate on html instead of mdast
	const { mdast } = await processMDX({ node: mdxNode })
	let headings = []
	visit(mdast, `heading`, heading => {
	headings.push({
	value: toString(heading),
	depth: heading.depth,
	})
	})
	if (headingsMdx.includes(depth)) {
	headings = headings.filter(heading => `h${heading.depth}` === depth)
	}
	return headings
	},
	},
	html: {
	type: `String`,
	async resolve(mdxNode) {
	if (mdxNode.html) {
	return Promise.resolve(mdxNode.html)
	}
	const { body } = await processMDX({ node: mdxNode })
	try {
	if (!mdxHTMLLoader) {
	mdxHTMLLoader = loader({ reporter, cache, store })
	}
	const html = await mdxHTMLLoader.load({ ...mdxNode, body })
	return html
	} catch (e) {
	reporter.error(
	`gatsby-plugin-mdx: Error querying the \`html\` field.
	This field is intended for use with RSS feed generation.
	If you're trying to use it in application-level code, try querying for \`Mdx.body\` instead.
	Original error:
	${e}`
	)
	return undefined
	}
	},
	},
	mdxAST: {
	type: `JSON`,
	async resolve(mdxNode) {
	const { mdast } = await processMDX({ node: mdxNode })
	return mdast
	},
	},
	tableOfContents: {
	type: `JSON`,
	args: {
	maxDepth: {
	type: `Int`,
	default: 6,
	},
	},
	async resolve(mdxNode, { maxDepth }) {
	const { mdast } = await processMDX({ node: mdxNode })
	const toc = generateTOC(mdast, { maxDepth })
	return getTableOfContents(toc.map, {})
	},
	},
	timeToRead: {
	type: `Int`,
	async resolve(mdxNode) {
	const { mdast } = await processMDX({ node: mdxNode })
	const { words } = await getCounts({ mdast })
	let timeToRead = 0
	const avgWPM = 265
	timeToRead = Math.round(words / avgWPM)
	if (timeToRead === 0) {
	timeToRead = 1
	}
	return timeToRead
	},
	},
	wordCount: {
	type: `MdxWordCount`,
	async resolve(mdxNode) {
	const { mdast } = await processMDX({ node: mdxNode })
	return getCounts({ mdast })
	},
	},
	},
	interfaces: [`Node`],
	extensions: {
	childOf: {
	mimeTypes: options.mediaTypes,
	},
	},
	})

If you want to access them/do something with them you'll have to use the createSchemaCustomization/createResolvers API.