How to use gridsome - 8 common examples

transformSchema (schema) {
    const query = schema.getQueryType()

    let newQuery // eslint-disable-line
    const nestedType = new GraphQLObjectType({
      name: this.typeName,
      fields: () =>
        fieldMapToFieldConfigMap(
          query.getFields(),
          createResolveType(typeName => {
            if (typeName === query.name) {
              return newQuery
            } else {
              return schema.getType(typeName)
            }
          }),
          true
        )
    })
    newQuery = new GraphQLObjectType({
      name: query.name,

fetchPath2 (path) {
      fetch(path).catch(err => {
        this.testDoc = null
      })
    }
  }

const {
  GraphQLInt,
  GraphQLString,
  GraphQLEnumType,
  GraphQLObjectType
} = require('gridsome/graphql')

const HeadingType = new GraphQLObjectType({
  name: 'RemarkHeading',
  fields: {
    depth: { type: GraphQLInt },
    value: { type: GraphQLString },
    anchor: { type: GraphQLString }
  }
})

const HeadingLevels = new GraphQLEnumType({
  name: 'RemarkHeadingLevels',
  values: {
    h1: { value: 1 },
    h2: { value: 2 },
    h3: { value: 3 },
    h4: { value: 4 },
    h5: { value: 5 },

const nestedType = new GraphQLObjectType({
      name: this.typeName,
      fields: () =>
        fieldMapToFieldConfigMap(
          query.getFields(),
          createResolveType(typeName => {
            if (typeName === query.name) {
              return newQuery
            } else {
              return schema.getType(typeName)
            }
          }),
          true
        )
    })
    newQuery = new GraphQLObjectType({
      name: query.name,
      fields: {
        [this.fieldName]: {
          type: nestedType,
          resolve: (parent, args, context, info) => {
            return {}
          }
        }
      }
    })
    const typeMap = schema.getTypeMap()
    const allTypes = Object.keys(typeMap)
      .filter(name => name !== query.name)
      .map(key => typeMap[key])

    return new GraphQLSchema({

GraphQLInt,
  GraphQLString,
  GraphQLEnumType,
  GraphQLObjectType
} = require('gridsome/graphql')

const HeadingType = new GraphQLObjectType({
  name: 'RemarkHeading',
  fields: {
    depth: { type: GraphQLInt },
    value: { type: GraphQLString },
    anchor: { type: GraphQLString }
  }
})

const HeadingLevels = new GraphQLEnumType({
  name: 'RemarkHeadingLevels',
  values: {
    h1: { value: 1 },
    h2: { value: 2 },
    h3: { value: 3 },
    h4: { value: 4 },
    h5: { value: 5 },
    h6: { value: 6 }
  }
})

module.exports = {
  HeadingType,
  HeadingLevels
}

extendNodeType () {
    return {
      content: {
        type: GraphQLString,
        resolve: node => this._nodeToHTML(node)
      },
      headings: {
        type: new GraphQLList(HeadingType),
        args: {
          depth: { type: HeadingLevels },
          stripTags: { type: GraphQLBoolean, defaultValue: true }
        },
        resolve: async (node, { depth, stripTags }) => {
          const key = cacheKey(node, 'headings')
          let headings = cache.get(key)

          if (!headings) {
            const ast = await this._nodeToAST(node)
            headings = findHeadings(ast)
            cache.set(key, headings)
          }

          return headings
            .filter(heading =>

const { documentToHtmlString } = require('@contentful/rich-text-html-renderer')
const { GraphQLScalarType } = require('gridsome/graphql')

const ContentfulRichTextField = new GraphQLScalarType({
  name: 'ContentfulRichTextField',
  serialize: value => value
})

module.exports = options => ({
  type: ContentfulRichTextField,
  args: {
    html: { type: 'Boolean', defaultValue: false }
  },
  resolve (obj, args, context, info) {
    const value = obj[info.fieldName]

    const json = typeof value === 'string'
      ? JSON.parse(value)
      : null

name: query.name,
      fields: {
        [this.fieldName]: {
          type: nestedType,
          resolve: (parent, args, context, info) => {
            return {}
          }
        }
      }
    })
    const typeMap = schema.getTypeMap()
    const allTypes = Object.keys(typeMap)
      .filter(name => name !== query.name)
      .map(key => typeMap[key])

    return new GraphQLSchema({
      query: newQuery,
      types: allTypes
    })
  }
}