Setfieldsongraphqlnodetype

setfieldsongraphqlnodetype
/**
* In order to resolve frontmatter as markdown using the same infrastructure
* as with the markdown body, we call the `setFieldsOnGraphQLNodeType` function
* exported by gatsby-transformer-remark
*
* We get the field to operate on using the generated MarkdownRemarkFieldsEnum
* In order to resolve field enum to a corresponding value, we must use the
* getValueAt function, which is a utility function internal to gatsby.
* We should find a more stable way of doing this.
*
* gatsby-transformer-remark’s `setFieldsOnGraphQLNodeType` function
setfieldsongraphqlnodetype here setfieldsongraphqlnodetype
* checks the `type` value first thing, returning `{}` if it is not set
* to ‘MarkdownRemark’, so we must spoof that.
*
* We are not calling this function through gatsby from the plugin context,
* so we must manually get the plugin options for gatsby-transformer-remark
* by using the store and getting the flattenedPlugins value. Note that the
* store is considered internal, and may change at any time. It would be
* a good idea to find a better way of doing this.
*
* The `setFieldsOnGraphQLNodeType` function returns a map of resolvers
setfieldsongraphqlnodetype read more setfieldsongraphqlnodetype
* we can provide these resolvers with newly created nodes containing
* the markdown content that we want to convert. Many other plugins expect
* markdown nodes to be the children of File nodes, or nodes containing some
* File properties, so first we get the parent node that owns this Frontmatter,
* and merge most of the properties into the new node before creation
*
* We must guarantee that the markdown Node that we provide to the resolvers
* has a unique `internal.contentDigest`
*
* This should remain stable unless the `setFieldsOnGraphQLNodeType` signature
setfieldsongraphqlnodetype here setfieldsongraphqlnodetype
* changes, or gatsby-transformer-remark changes what resolvers they return,
* or the store changes to not provide the flattened plugins
*
* As a fallback, if any errors are thrown during execution of this function,
* our normal markdown stack using unified could be used, with a consequence
* of a loss of functionality and performance
*
* @param {import(‘gatsby’).API.NodeJS.SharedHelpers & { type?: null | { name: string } }} helpers
* @returns {Promise} resolver map
*/
setfieldsongraphqlnodetype read more setfieldsongraphqlnodetype
const getMarkdownResolvers = helpers => {
/** @type {import(‘gatsby’).API.NodeJS.Exports} */
// @ts-ignore
const gatsbyTransformerRemark = require(‘gatsby-transformer-remark/gatsby-node’)

// get the gatsby-transformer-remark plugin options
// there should be a better way to do this, store is considered
// internal
const plugins = helpers.store.getState().flattenedPlugins
const transformerRemarkPlugin = plugins.find(
setfieldsongraphqlnodetype here setfieldsongraphqlnodetype
p => p.name === ‘gatsby-transformer-remark’,
)

if (!transformerRemarkPlugin)
throw new Error(‘gatsby-transformer-remark plugin not found’)

const { setFieldsOnGraphQLNodeType } = gatsbyTransformerRemark
if (!setFieldsOnGraphQLNodeType)
throw new Error(‘gatsby-transformer-remark implementation changed’)

setfieldsongraphqlnodetype get more info setfieldsongraphqlnodetype
// bypass type check by gatsby-transformer-remark
if (!helpers.type || helpers.type.name !== ‘MarkdownRemark’)
helpers.type = { name: ‘MarkdownRemark’ }

return setFieldsOnGraphQLNodeType(
// @ts-ignore
helpers,
transformerRemarkPlugin.pluginOptions,
)
}
setfieldsongraphqlnodetype website setfieldsongraphqlnodetype

// @ts-ignore
const { getValueAt } = require(‘gatsby/dist/utils/get-value-at’)

/**
* Gets a field to operate on from the frontmatter,
* @param {import(‘gatsby’).API.NodeJS.SharedHelpers} options
* @param {‘html’ | ‘htmlAst’ | ‘excerpt’ | ‘excerptAst’ | ‘headings’ | ‘timeToRead’ | ‘tableOfContents’ | ‘wordCount’} resolver
* @returns {import(‘gatsby’).API.NodeJS.Resolver}
*/
setfieldsongraphqlnodetype website setfieldsongraphqlnodetype
const wrappedRemarkResolver = (options, resolver) => async (
source,
allArgs,
context,
info,
) => {
const {
createNodeId,
createContentDigest,
actions: { createNode, createParentChildLink },
setfieldsongraphqlnodetype get more info setfieldsongraphqlnodetype
} = options

/** @type {{ field: string }} */
let { field, …args } = allArgs
if (!field.startsWith(‘frontmatter.’)) {
throw new Error(‘field must be in frontmatter’)
}

field = field.replace(‘frontmatter.’, ”)

setfieldsongraphqlnodetype get more info setfieldsongraphqlnodetype
const value = getValueAt(source, field)
if (typeof value !== ‘string’) return null

// we get the parent markdown node
// and pretend that the content is the
// content of the frontmatter field instead
const markdownNode = context.nodeModel.findRootNodeAncestor(source)

/** @typedef {import(‘gatsby’).Node} Node */
/** @type {Node} */
setfieldsongraphqlnodetype get more info setfieldsongraphqlnodetype
const parentNode = {
…markdownNode,
id: createNodeId(‘fake-markdown’),
parent: markdownNode && markdownNode.id,
children: [],
// @ts-ignore
internal: {
…(markdownNode && markdownNode.internal),
// we must set content, otherwise when loadNodeContent
// is called in gatsby-transform-remark
setfieldsongraphqlnodetype website setfieldsongraphqlnodetype
// if it isn’t set, a search will go for the owner plugin
// and request it to load the content and since the owner
// does not exist, that will fail and an error will be thrown
content: value,
contentDigest:
((markdownNode && markdownNode.internal.contentDigest) || ”) +
createContentDigest(value),
mediaType: ‘text/markdown’,
type: FAKE_MARKDOWN_FILE_TYPE,
},
setfieldsongraphqlnodetype more info setfieldsongraphqlnodetype
}

// owner is created by gatsby based on plugin. throws on creation if set
delete parentNode.internal.owner

const node = await createNode(parentNode)
// add a parent link if we have a parent markdown node
if (markdownNode)
createParentChildLink({ parent: markdownNode, child: parentNode })

setfieldsongraphqlnodetype check here setfieldsongraphqlnodetype
// sometimes an array is returned sometimes not. weird
const realNode = Array.isArray(node) ? node[0] : node
if (!realNode) return null

// make sure correct type is sent to gatsby-transformer-remark resolvers
const MarkdownRemarkType = info.schema.getType(‘MarkdownRemark’)
const resolvers = await getMarkdownResolvers({
…options,
type: MarkdownRemarkType,
})
setfieldsongraphqlnodetype here setfieldsongraphqlnodetype

// we create nodes and don’t clean up after
// if we do delete them we get undefined errors
// no amount of querying through graphql shows the
// created nodes, so I expect they get cleaned up somehow
// besides, since gatsby isn’t a long-running process (just static generation)
// a memory leak shouldn’t be too big of an issue

return resolvers[resolver].resolve(realNode, args, context, info)
}
setfieldsongraphqlnodetype check here setfieldsongraphqlnodetype

module.exports = {
createResolvers(options) {
const { createResolvers } = options

createResolvers({
Frontmatter: {
getHtml: {
type: ‘String’,
args: {
setfieldsongraphqlnodetype read more setfieldsongraphqlnodetype
field: {
type: ‘MarkdownRemarkFieldsEnum!’,
},
},
resolve: wrappedRemarkResolver(options, ‘html’),
},
getHtmlAst: {
type: ‘JSON’,
args: {
field: {
setfieldsongraphqlnodetype read more setfieldsongraphqlnodetype
type: ‘MarkdownRemarkFieldsEnum!’,
},
},
resolve: wrappedRemarkResolver(options, ‘htmlAst’),
},
}
})
}
}
setfieldsongraphqlnodetype

Tags: setfieldsongraphqlnodetype, www bcfakes com

Leave a Comment