gatsby-node.js

const fetch = require(`node-fetch`);
const Path = require('path');

const { createEventFilters } = require('./src/utils/event-filters');
const { EVENT_REGEX, EVENT_PER_PAGE } = require('./src/utils/events');
const { EVENTS_BASE_PATH } = require('./src/utils/routes');
const { slugify } = require('./src/utils/slugify');

const DRAFT_FILTER = process.env.NODE_ENV === 'production' ? [false] : [true, false];

const BLOG_POSTS_PER_PAGE = 9;
const slugifyCategory = (item, pagePath) =>
  item === '*' ? `/${pagePath}/` : `/${pagePath}/categories/${slugify(item)}/`;

// Create Blog Posts
async function createBlogPosts({ graphql, actions }) {
  const {
    data: {
      allMdx: { nodes: blogPosts },
    },
  } = await graphql(`
    query BlogPosts {
      allMdx(filter: { internal: { contentFilePath: { regex: "/src/posts/" } } }) {
        nodes {
          id
          frontmatter {
            path
          }
          fields {
            draft
          }
          internal {
            contentFilePath
          }
        }
      }
    }
  `);

  blogPosts.forEach(
    ({ id, frontmatter: { path }, internal: { contentFilePath }, fields: { draft } }) => {
      // skip page creation if post has `draft` flag
      if (process.env.NODE_ENV === 'production' && draft) {
        return;
      }

      if (!path) {
        return;
      }

      const postTemplate = Path.resolve('./src/templates/blog-post.jsx');

      actions.createPage({
        path,
        component: `${postTemplate}?__contentFilePath=${contentFilePath}`,
        context: { id },
      });
    }
  );
}

// Create Blog Pages
async function createBlogPages({ graphql, actions, reporter }) {
  const { createPage } = actions;

  const {
    data: {
      featuredPostEdges: { edges: featuredPost },
      allCategories: { group: allCategories },
    },
  } = await graphql(`
    {
      allCategories: allMdx(filter: { internal: { contentFilePath: { regex: "/posts/" } } }) {
        group(field: { frontmatter: { categories: SELECT } }) {
          fieldValue
        }
        nodes {
          frontmatter {
            categories
          }
        }
      }
      featuredPostEdges: allMdx(
        filter: {
          internal: { contentFilePath: { regex: "/posts/" } }
          frontmatter: { isFeatured: { eq: true } }
        }
      ) {
        edges {
          node {
            id
            frontmatter {
              isFeatured
            }
            internal {
              contentFilePath
            }
          }
        }
      }
    }
  `);
  if (featuredPost?.length > 1) {
    const featuredPosts = featuredPost.map(
      ({
        node: {
          internal: { contentFilePath },
        },
      }) => contentFilePath
    );
    reporter.panicOnBuild(
      `There must be the only one featured post. Please, check "isFeatured" fields in your posts. File path: ${featuredPosts}`,
      new Error('Too much featured posts')
    );
  }

  const categories = ['*']
    .concat(allCategories.map((category) => category.fieldValue))
    .map((category) => ({
      label: category,
      basePath: slugifyCategory(category, 'blog'),
    }));

  // Create category pages
  await Promise.all(
    categories.map(async ({ label, basePath }) =>
      graphql(
        `
          query CategoryPostsQuery($tag: String!, $draftFilter: [Boolean]!) {
            allMdx(
              filter: {
                internal: { contentFilePath: { regex: "/posts/" } }
                fields: {
                  isFeatured: { eq: false }
                  categories: { glob: $tag }
                  draft: { in: $draftFilter }
                }
              }
              limit: 1000
            ) {
              edges {
                node {
                  id
                }
              }
            }
          }
        `,
        { tag: label, draftFilter: DRAFT_FILTER }
      ).then((result) => {
        if (result.errors) throw result.errors;
        const posts = result.data.allMdx.edges;
        const numPages = Math.ceil(posts.length / BLOG_POSTS_PER_PAGE);

        Array.from({ length: numPages }).forEach((_, i) => {
          const path = i === 0 ? basePath : `${basePath}${i + 1}`;
          createPage({
            path,
            component: Path.resolve('./src/templates/blog.jsx'),
            context: {
              limit: BLOG_POSTS_PER_PAGE,
              skip: i * BLOG_POSTS_PER_PAGE,
              numPages,
              currentPage: i + 1,
              basePath,
              currentCategory: label,
              categories,
              // get all posts with draft: 'false' if NODE_ENV is production, otherwise render them all
              draftFilter: DRAFT_FILTER,
            },
          });
        });
      })
    )
  );
}

// Create Events Page
async function createEventsPage({ graphql, actions }) {
  const { createPage } = actions;

  const result = await graphql(
    `
      query ($draftFilter: [Boolean]!, $eventRegex: String!) {
        allMdx(
          filter: {
            internal: { contentFilePath: { regex: $eventRegex } }
            fields: { draft: { in: $draftFilter } }
          }
        ) {
          totalCount
        }
        allTypes: allMdx(filter: { internal: { contentFilePath: { regex: $eventRegex } } }) {
          group(field: { frontmatter: { type: SELECT } }) {
            fieldValue
          }
        }
        allRegions: allMdx(filter: { internal: { contentFilePath: { regex: $eventRegex } } }) {
          group(field: { frontmatter: { region: SELECT } }) {
            fieldValue
          }
        }
        allPosts: allMdx(
          filter: {
            internal: { contentFilePath: { regex: $eventRegex } }
            fields: { draft: { in: $draftFilter }, isFeatured: { eq: false } }
          }
          sort: { frontmatter: { date: DESC } }
        ) {
          nodes {
            frontmatter {
              date(formatString: "MMM DD, YYYY")
              region
              place
              type
              title
              ogSummary
              externalUrl
              ogImage {
                childImageSharp {
                  gatsbyImageData(width: 601)
                }
              }
            }
          }
        }
        featuredPost: allMdx(
          filter: {
            internal: { contentFilePath: { regex: $eventRegex } }
            fields: { draft: { in: $draftFilter }, isFeatured: { eq: true } }
          }
          sort: { frontmatter: { date: DESC } }
          limit: 1
        ) {
          nodes {
            frontmatter {
              date(formatString: "MMMM DD, YYYY")
              region
              place
              type
              title
              ogSummary
              externalUrl
              ogImage {
                childImageSharp {
                  gatsbyImageData(width: 735)
                }
              }
            }
          }
        }
      }
    `,
    { draftFilter: DRAFT_FILTER, eventRegex: EVENT_REGEX }
  );

  if (result.errors) throw new Error(result.errors);

  const {
    featuredPost: { nodes: featuredPost },
    allPosts: { nodes: allEvents },
    allTypes: { group: allTypes },
    allRegions: { group: allRegions },
  } = result.data;

  function getInitialFilters(allFilters) {
    return allFilters.reduce((acc, { label }) => {
      if (!acc[label]) {
        acc[label] = [];
      }
      return acc;
    }, {});
  }

  const postEvents = allEvents.map((event) => ({ ...event.frontmatter }));
  const featuredEvent = featuredPost[0].frontmatter;
  const types = allTypes.reduce((acc, type) => [...acc, type.fieldValue], []);
  const regions = allRegions.reduce((acc, type) => [...acc, type.fieldValue], []);
  const eventFilters = createEventFilters(types, regions);
  const initialFilters = getInitialFilters(eventFilters);
  const totalPageCount = Math.ceil(postEvents.length / EVENT_PER_PAGE);

  Array.from({ length: totalPageCount }).forEach((_, i) => {
    const path = i === 0 ? EVENTS_BASE_PATH : `${EVENTS_BASE_PATH}${i + 1}`;
    createPage({
      path,
      component: Path.resolve('./src/templates/events.jsx'),
      context: {
        limit: EVENT_PER_PAGE,
        skip: i * EVENT_PER_PAGE,
        totalPageCount,
        currentPage: i + 1,
        featuredEvent,
        postEvents,
        eventFilters,
        initialFilters,
      },
    });
  });
}

// Create Labs Page
async function createLabsPage({ graphql, actions }) {
  const { createPage } = actions;

  const LABS_BASE_TEMPLATE = './src/templates/labs.jsx';
  const LABS_REGEX = '/content/labs/';
  const LABS_PER_PAGE = 12;

  const template = Path.resolve(LABS_BASE_TEMPLATE);

  const result = await graphql(
    `
      query ($labsRegex: String!, $draftFilter: [Boolean]!) {
        allMdx(
          filter: {
            internal: { contentFilePath: { regex: $labsRegex } }
            fields: { draft: { in: $draftFilter } }
          }
        ) {
          edges {
            node {
              frontmatter {
                categories
              }
            }
          }
        }
        allCategories: allMdx(filter: { internal: { contentFilePath: { regex: $labsRegex } } }) {
          group(field: { frontmatter: { categories: SELECT } }) {
            fieldValue
          }
        }
      }
    `,
    { labsRegex: LABS_REGEX, draftFilter: DRAFT_FILTER }
  );

  if (result.errors) throw new Error(result.errors);

  const {
    allCategories: { group: allCategories },
  } = result.data;

  const categories = ['*'].concat(allCategories.map((category) => category.fieldValue));
  const categoriesWithBasePath = categories.map((category) => ({
    label: category,
    basePath: slugifyCategory(category, 'labs'),
  }));
  const labList = result.data.allMdx.edges.map(({ node: { frontmatter: lab } }) => ({ ...lab }));

  const promiseList = [];

  categories.forEach((category) => {
    const totalCount =
      category === '*'
        ? labList.length
        : labList.filter(({ categories }) => categories.includes(category)).length;
    const totalPageCount = Math.ceil(totalCount / LABS_PER_PAGE);

    Array.from({ length: totalPageCount }).forEach((_, i) => {
      promiseList.push(
        graphql(
          `
            query CategoryLabsQuery(
              $labsRegex: String!
              $tag: String!
              $draftFilter: [Boolean]!
              $limit: Int!
              $skip: Int!
            ) {
              allMdx(
                filter: {
                  internal: { contentFilePath: { regex: $labsRegex } }
                  fields: { categories: { glob: $tag }, draft: { in: $draftFilter } }
                }
                sort: { frontmatter: { title: ASC } }
                limit: $limit
                skip: $skip
              ) {
                edges {
                  node {
                    frontmatter {
                      date(formatString: "MMM DD, YYYY")
                      categories
                      title
                      ogSummary
                      externalUrl
                      from
                      ogImage {
                        childImageSharp {
                          gatsbyImageData(width: 601)
                        }
                      }
                    }
                  }
                }
              }
            }
          `,
          {
            labsRegex: LABS_REGEX,
            tag: category,
            draftFilter: DRAFT_FILTER,
            limit: LABS_PER_PAGE,
            skip: i * LABS_PER_PAGE,
          }
        ).then((result) => {
          if (result.errors) throw new Error(result.errors);
          const labs = result.data.allMdx.edges;
          const pathBase = slugifyCategory(category, 'labs');
          const path = i === 0 ? pathBase : `${pathBase}${i + 1}`;

          createPage({
            path,
            component: template,
            context: {
              labs,
              basePath: pathBase,
              categories: categoriesWithBasePath,
              currentCategory: category,
              totalPageCount,
              currentPage: i + 1,
            },
          });
        })
      );
    });
  });

  await Promise.all(promiseList);
}

exports.createPages = async (options) => {
  await createBlogPages(options);
  await createBlogPosts(options);
  await createEventsPage(options);
  await createLabsPage(options);
};

exports.onCreateNode = ({ node, actions }) => {
  const { createNodeField } = actions;

  if (node.frontmatter) {
    createNodeField({
      node,
      name: 'categories',
      value: node.frontmatter.categories || Array.of('*'),
    });
    createNodeField({
      node,
      name: 'isFeatured',
      value: node.frontmatter.isFeatured || false,
    });
    createNodeField({
      node,
      name: 'isPopular',
      value: node.frontmatter.isPopular || false,
    });
    createNodeField({
      node,
      name: 'draft',
      value: node.frontmatter.draft || false,
    });
    createNodeField({
      node,
      name: 'ogImageUrl',
      value: node.frontmatter.ogImageUrl || '',
    });
    createNodeField({
      node,
      name: 'externalUrl',
      value: node.frontmatter.externalUrl || '',
    });
    createNodeField({
      node,
      name: 'type',
      value: node.frontmatter.type || '',
    });
    createNodeField({
      node,
      name: 'region',
      value: node.frontmatter.region || '',
    });
    createNodeField({
      node,
      name: 'title',
      value: node.frontmatter.title || '',
    });
  }
};

async function getHubspotEmails({ actions: { createNode }, createContentDigest }) {
  const getObjects = async () => {
    if (process.env.NODE_ENV === 'production' && process.env.HUBSPOT_ACCESS_TOKEN) {
      let hubspotEmailsData;
      try {
        const hubspotEmails = await fetch(
          `https://api.hubapi.com/marketing-emails/v1/emails?limit=150&name__icontains=eCHO+news&orderBy=-publish_date`,
          {
            method: 'GET',
            headers: {
              Authorization: `Bearer ${process.env.HUBSPOT_ACCESS_TOKEN}`,
              'Content-Type': 'application/json',
            },
          }
        );
        hubspotEmailsData = await hubspotEmails.json();
      } catch (error) {
        console.log(error);
        return [];
      }

      return hubspotEmailsData.objects
        .filter(({ isPublished }) => isPublished !== false)
        .map(({ name, publishDate, isPublished, publishedUrl }) => ({
          name,
          publishDate,
          isPublished,
          publishedUrl,
        }));
    }

    return [];
  };

  const objects = await getObjects();

  objects.forEach((object, i) => {
    createNode({
      ...object,
      id: `hubspot-email-${i}`,
      parent: null,
      children: [],
      internal: {
        type: `HubspotEmail`,
        contentDigest: createContentDigest(object),
      },
    });
  });
}

async function getGithubStars({ actions: { createNode }, createContentDigest, cache }) {
  let stars;
  try {
    // Set expiration time as 24 hours in milliseconds
    const expirationTime = 24 * 60 * 60 * 1000;
    const cacheKey = `stars-cilium`;
    const cacheStarsData = await cache.get(cacheKey);
    // Use cache if it is not expired
    if (cacheStarsData && cacheStarsData.created > Date.now() - expirationTime) {
      stars = cacheStarsData.stars;
    } else {
      const response = await fetch(`https://api.github.com/repos/cilium/cilium`);
      const { stargazers_count } = await response.json();

      if (typeof stargazers_count !== 'number') {
        throw new Error('Failed to fetch GitHub stars');
      }

      // covert stars to string
      stars = stargazers_count.toString();

      await cache.set(cacheKey, {
        stars,
        created: Date.now(),
      });
    }
  } catch (error) {
    console.log(error);
    throw new Error('Failed to fetch GitHub stars');
  }

  createNode({
    id: `github-stars-cilium`,
    parent: null,
    githubStars: stars,
    children: [],
    internal: {
      type: `GithubStars`,
      contentDigest: createContentDigest(stars),
    },
  });
}

exports.sourceNodes = async (options) => {
  await getHubspotEmails(options);
  await getGithubStars(options);
};

exports.createSchemaCustomization = ({ actions }) => {
  const { createTypes } = actions;
  const typeDefs = `
    type HubspotEmail implements Node {
      name: String
      publishDate: String
      isPublished: Boolean
      publishedUrl: String
    }
  `;
  createTypes(typeDefs);
};