ernieyang09.github.io/gatsby-node.js at develop · ernieyang09/ernieyang09.github.io · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
const _ = require("lodash")
const Promise = require("bluebird")
const path = require("path")
const select = require(`unist-util-select`)
const fs = require(`fs-extra`)
const config = require(`./src/config`)

let edges;

exports.createPages = ({ graphql, boundActionCreators }) => {

  const { createPage } = boundActionCreators;

  return new Promise((resolve, reject) => {
    const pages = []
    const test = path.resolve("./src/pages/index.js")
    const blogPost = path.resolve("./src/templates/Posts.jsx")
    const tagPages = path.resolve("./src/templates/tag-page.jsx")
    resolve(
      graphql(
        `
      {
        allMarkdownRemark(
          limit: 1000
          filter: {frontmatter: { release: {eq: true} } }
        ) {
          edges {
            node {
              frontmatter {
                tags
              }
              fields {
                slug
              }
            }
          }
        }
      }
    `
      ).then(result => {
        if (result.errors) {
          reject(result.errors)
        }
        edges = result.data.allMarkdownRemark.edges;
        // Create blog posts pages.
        _.each(edges, (edge, index) => {

          createPage({
            path: edge.node.fields.slug,
            component: blogPost,
            // Query variable for template/Posts
            context: {
              slug: edge.node.fields.slug,
            },
          })

          if(index >= config.paginations && (index % config.paginations === 0)) {
            createPage({
              path: `/${index / config.paginations}`,
              component: test,
              // Query variable for index
              context: {
                offset: index,
                paginations: config.paginations,
                total: edges.length,
              },
            })
          }

        })

        // Tag pages.
        let tags = [];
        _.each(result.data.allMarkdownRemark.edges, edge => {
          if (_.get(edge, "node.frontmatter.tags")) {
            tags = tags.concat(edge.node.frontmatter.tags)
          }
        })
        tags = _.uniq(tags)
        tags.forEach(tag => {
          const tagPath = `/tags/${_.kebabCase(tag)}/`
          createPage({
            path: tagPath,
            component: tagPages,
            // Query variable for template/tag-page
            context: {
              tag,
            },
          })
        })
      })
    )
  })
}

exports.onCreatePage = ({ page, boundActionCreators }) => {

  return new Promise((resolve, reject)=> {
    if (page.path === '/') {
      page.context = {
        offset: 0,
        paginations: config.paginations,
        total: edges.length,
      }
    }
    resolve();
  })
};

exports.onCreateNode = ({ node, boundActionCreators, getNode }) => {

  const { createNodeField } = boundActionCreators;

  return new Promise((resolve, reject) => {
    let slug;
    if (node.internal.type === `MarkdownRemark`) {

      const fileNode = getNode(node.parent)
      const parsedFilePath = path.parse(fileNode.relativePath)
      slug = `/posts/${parsedFilePath.name.split("--")[1]}/`
      createNodeField({ node, name: `slug`, value: slug })
    }
    resolve();
  })

}