gatsby-node.js

const getPageParent = async (page, context) => {
  return await context.nodeModel.findOne({
    type: "ContentfulPage",
    query: {
      filter: {
        subpages: { elemMatch: { id: { eq: page.id } } },
        id: { ne: page.id },
      },
    },
  });
};
const getBlockParent = async (block, context) => {
  const garden = await context.nodeModel.findOne({
    type: "ContentfulGarden",
    query: {
      filter: {
        block: { id: { eq: block.id } },
      },
    },
  });

  if (garden) {
    console.log(`BUILDING GARDEN: ${JSON.stringify(garden.streetAddress)}`);
    const page = await context.nodeModel.findOne({
      type: "ContentfulPage",
      query: {
        filter: {
          slug: { eq: "gardens" },
        },
      },
    });
    if (page) return page;
    else console.log(`NO PAGE FOUND FOR ${garden.streetAddress}`);
  }

  return await context.nodeModel.findOne({
    type: "ContentfulPage",
    query: {
      filter: {
        blocks: { elemMatch: { id: { eq: block.id } } },
      },
    },
  });
};

const buildBlockURL = async (block, context) => {
  let p = await getBlockParent(block, context);
  const c = [block.slug];

  while (p) {
    c.push(p.slug);
    p = await getPageParent(p, context);
  }
  return `/${c.reverse().join("/")}`;
};

exports.createResolvers = ({ createResolvers }) => {
  const resolvers = {
    ContentfulBlock: {
      url: {
        type: "String",
        resolve: (source, args, context, info) => {
          return buildBlockURL(source, context);
        },
      },
      pageLineage: {
        type: "[ContentfulPage]",
        resolve: async (source, args, context, info) => {
          const firstParent = await getBlockParent(source, context);
          if (!firstParent) return [];
          const lineage = [firstParent];
          let hasParent = true;
          while (hasParent) {
            const p = await getPageParent(lineage[lineage.length - 1], context);
            hasParent = !!p;
            if (p) {
              lineage.push(p);
            }
          }
          return lineage;
        },
      },
      cousinPages: {
        type: "[ContentfulPage]",
        resolve: async (source, args, context, info) => {
          const firstParent = await getBlockParent(source, context);
          if (!firstParent) return [];
          let greatestGrandParent = firstParent;
          let hasParent = true;
          while (hasParent) {
            const p = await getPageParent(greatestGrandParent, context);
            hasParent = !!p;
            if (p) {
              greatestGrandParent = p;
            }
          }
          const ids = greatestGrandParent.subpages___NODE || [];
          return await context.nodeModel.getNodesByIds({
            ids,
            type: "ContentfulPage",
          });
        },
      },
    },
  };
  createResolvers(resolvers);
};