gatsby-node.js

const path = require(`path`)
const { postsPerPage } = require(`./src/utils/siteConfig`)
const { paginate } = require(`gatsby-awesome-pagination`)

/**
 * Here is the place where Gatsby creates the URLs for all the
 * posts, tags, pages and authors that we fetched from the Ghost site.
 */
exports.createPages = async ({ graphql, actions }) => {
    const { createPage } = actions

    const result = await graphql(`
        {
            allGhostPost(sort: { order: ASC, fields: published_at }) {
                edges {
                    node {
                        id
                        slug
                        primary_tag{
                            name
                        }
                        tags{
                            name
                        }
                    }
                }
            }
            allGhostTag(sort: { order: ASC, fields: name }) {
                edges {
                    node {
                        slug
                        url
                        postCount
                    }
                }
            }
            allGhostPage(sort: { order: ASC, fields: published_at }) {
                edges {
                    node {
                        slug
                        url
                    }
                }
            }
        }
    `)

    // Check for any errors
    if (result.errors) {
        throw new Error(result.errors)
    }

    // Extract query results
    const tags = result.data.allGhostTag.edges
    // const authors = result.data.allGhostAuthor.edges
    const pages = result.data.allGhostPage.edges
    const posts = result.data.allGhostPost.edges
    const podcastsingle = result.data.allGhostPost.edges
    const index = [];

    // Load templates
    const indexTemplate = path.resolve(`./src/templates/index.js`)
    const tagsTemplate = path.resolve(`./src/templates/tag.js`)
    // const authorTemplate = path.resolve(`./src/templates/author.js`)
    const pageTemplate = path.resolve(`./src/templates/page.js`)
    const postTemplate = path.resolve(`./src/templates/post.js`)
    const podcastSingleTemplate = path.resolve(`./src/templates/podcastsingle.js`)
    const amppostTemplate = path.resolve(`./src/templates/post.amp.js`)
    // const amppodcastTemplate = path.resolve(`./src/templates/post.amp.js`)


    // Create tag pages
    tags.forEach(({ node }) => {
        const totalPosts = node.postCount !== null ? node.postCount : 0
        const numberOfPages = Math.ceil(totalPosts / postsPerPage)

        // This part here defines, that our tag pages will use
        // a `/tag/:slug/` permalink.
        node.url = `/tag/${node.slug}/`

        Array.from({ length: numberOfPages }).forEach((_, i) => {
            const currentPage = i + 1
            const prevPageNumber = currentPage <= 1 ? null : currentPage - 1
            const nextPageNumber =
                currentPage + 1 > numberOfPages ? null : currentPage + 1
            const previousPagePath = prevPageNumber
                ? prevPageNumber === 1
                    ? node.url
                    : `${node.url}page/${prevPageNumber}/`
                : null
            const nextPagePath = nextPageNumber
                ? `${node.url}page/${nextPageNumber}/`
                : null

            createPage({
                path: i === 0 ? node.url : `${node.url}page/${i + 1}/`,
                component: tagsTemplate,
                context: {
                    // Data passed to context is available
                    // in page queries as GraphQL variables.
                    slug: node.slug,
                    limit: postsPerPage,
                    skip: i * postsPerPage,
                    numberOfPages: numberOfPages,
                    humanPageNumber: currentPage,
                    prevPageNumber: prevPageNumber,
                    nextPageNumber: nextPageNumber,
                    previousPagePath: previousPagePath,
                    nextPagePath: nextPagePath,
                },
            })
        })
    })

    // Create author pages
    // authors.forEach(({ node }) => {
    //     const totalPosts = node.postCount !== null ? node.postCount : 0
    //     const numberOfPages = Math.ceil(totalPosts / postsPerPage)

    //     // This part here defines, that our author pages will use
    //     // a `/author/:slug/` permalink.
    //     node.url = `/author/${node.slug}/`

    //     Array.from({ length: numberOfPages }).forEach((_, i) => {
    //         const currentPage = i + 1
    //         const prevPageNumber = currentPage <= 1 ? null : currentPage - 1
    //         const nextPageNumber =
    //             currentPage + 1 > numberOfPages ? null : currentPage + 1
    //         const previousPagePath = prevPageNumber
    //             ? prevPageNumber === 1
    //                 ? node.url
    //                 : `${node.url}page/${prevPageNumber}/`
    //             : null
    //         const nextPagePath = nextPageNumber
    //             ? `${node.url}page/${nextPageNumber}/`
    //             : null

    //         createPage({
    //             path: i === 0 ? node.url : `${node.url}page/${i + 1}/`,
    //             component: authorTemplate,
    //             context: {
    //                 // Data passed to context is available
    //                 // in page queries as GraphQL variables.
    //                 slug: node.slug,
    //                 limit: postsPerPage,
    //                 skip: i * postsPerPage,
    //                 numberOfPages: numberOfPages,
    //                 humanPageNumber: currentPage,
    //                 prevPageNumber: prevPageNumber,
    //                 nextPageNumber: nextPageNumber,
    //                 previousPagePath: previousPagePath,
    //                 nextPagePath: nextPagePath,
    //             },
    //         })
    //     })
    // })

    // Create pages
    pages.forEach(({ node }) => {
        // This part here defines, that our pages will use
        // a `/:slug/` permalink.
        node.url = `/${node.slug}/`

        createPage({
            path: node.url,
            component: pageTemplate,
            context: {
                // Data passed to context is available
                // in page queries as GraphQL variables.
                slug: node.slug,
            },
        })
    })

    // Create post pages
    posts.forEach(({ node }) => {
        // This part here defines, that our posts will use
        // a `/:slug/` permalink.
        node.url = `/${node.slug}/`

        if(node.primary_tag){
            // console.log(node.primary_tag)
           var primary_tag = node.primary_tag.name
        }else{
            var primary_tag = ""
        }
        // console.log(node.tags)
        if(node.tags && node.tags.length >0 && node.tags[0].name !== '#Podcasts'){

            createPage({
                path: node.url,
                component: postTemplate,
                context: {
                    // Data passed to context is available
                    // in page queries as GraphQL variables.
                    id: node.id,
                    slug: node.slug,
                    primary_tag: primary_tag,
                },
            })
        }
    })

    // Create podcast post pages
    podcastsingle.forEach(({ node }) => {
        node.url = `/podcasts/${node.slug}/`
        // console.log(node.tags)
        if(node.tags && node.tags.length >0 && node.tags[0].name === '#Podcasts'){                
            createPage({
                path: node.url,
                component: podcastSingleTemplate,
                context: {
                    slug: node.slug,
                },
            })
        }
      
    })


    // Create pagination
    paginate({
        createPage,
        items: index,
        itemsPerPage: 5,
        component: indexTemplate,
        pathPrefix: ({ pageNumber }) => {
            console.log(pageNumber)
            if (pageNumber === 0) {
                return `/`
            }else {
                return `/page`
            }
        },
    })
    

    // Create AMP post pages
    posts.forEach(({ node }) => {
        node.url = `/${node.slug}/amp/`

        if(node.tags && node.tags.length >0 && node.tags[0].name !== '#Podcasts'){

            createPage({
                path: node.url,
                component: amppostTemplate,
                context: {
                    slug: node.slug,
                },
            })
        }
    })

    podcastsingle.forEach(({ node }) => {
        
        node.url = `/podcasts/${node.slug}/amp/`

        if(node.tags && node.tags.length >0 && node.tags[0].name === '#Podcasts'){
            createPage({
                path: node.url,
                component: amppostTemplate,
                context: {
                    slug: node.slug,
                },
            })

        }
        
    })
}

// const { createRemoteFileNode } = require(`gatsby-source-filesystem`);

// exports.onCreateNode = async ({
//     node,
//     actions,
//     store,
//     createNodeId,
//     cache
// }) => {
//     // Check that we are modifying right node types.
//     const nodeTypes = [`GhostPost`, `GhostPage`];
//     if (!nodeTypes.includes(node.internal.type)) {
//         return;
//     }

//     const { createNode } = actions;

//     // Download image and create a File node with gatsby-transformer-sharp.
//     if (
//         node.internal.type === "GhostPost"
//     ){
//         const fileNode = await createRemoteFileNode({
//             url: node.feature_image,
//             store,
//             cache,
//             createNode,
//             parentNodeId: node.id,
//             createNodeId,
//         })
//         if (fileNode) {
//             // Link File node to GhostPost node at field image.
//             node.localFeatureImage___NODE = fileNode.id;
//         }
//     }
// };