jamstackBlog/gatsby-node.js at master · socraticDevBlog/jamstackBlog · 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
127
128
129
const { slugify, tagsSorted } = require(`./src/util/util-functions.js`)
const _ = require("lodash")
const path = require("path")

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

  if (node.internal.type === "MarkdownRemark") {
    createNodeField({
      node,
      name: "slug",
      value: slugify(node.frontmatter.title),
    })
  }
}

exports.createPages = ({ actions, graphql }) => {
  const { createPage } = actions

  const templates = {
    singlePost: path.resolve("src/templates/single-post.js"),
    tagsPage: path.resolve("src/templates/tags-page.js"),
    tagPosts: path.resolve("src/templates/tag-posts.js"),
    postsList: path.resolve("src/templates/posts-list.js"),
  }

  return graphql(`
    {
      allMarkdownRemark(
        filter: { frontmatter: { is_archived: { eq: false } } }
        sort: { frontmatter: { date: DESC } }
      ) {
        edges {
          node {
            frontmatter {
              author
              tags
            }
            fields {
              slug
            }
          }
        }
      }
    }
  `).then((res) => {
    if (res.errors) return Promise.reject(res.errors)

    const posts = res.data.allMarkdownRemark.edges

    // creating single-post pages
    //
    posts.forEach(({ node }) => {
      createPage({
        path: node.fields.slug,
        component: templates.singlePost,
        context: {
          slug: node.fields.slug,
        },
      })
    })

    let tags = []
    _.each(posts, (edge) => {
      // si un post n'a pas de tag, alors on ne fait rien
      //
      if (_.get(edge, "node.frontmatter.tags")) {
        tags = tags.concat(edge.node.frontmatter.tags)
      }
    })

    // créer un dictionnaire : {tag:count, tag2:count}
    //
    let tagPostCounts = {}
    tags.forEach((tag) => {
      tagPostCounts[tag] = (tagPostCounts[tag] || 0) + 1
    })

    // présenter les sujets les plus discutés en premier
    //
    tags = tagsSorted(tagPostCounts)

    // creating tags page
    //
    createPage({
      path: "/tags",
      component: templates.tagsPage,
      context: {
        tags,
        tagPostCounts,
      },
    })

    // creating tag posts page
    //
    tags.forEach((tag) => {
      createPage({
        path: `/tag/${slugify(tag)}`,
        component: templates.tagPosts,
        context: {
          tag,
        },
      })
    })

    // todo: federate this value (have only one). it is also configured in 'index.js'.
    const postsPerPage = 20

    const pagesCount = Math.ceil(posts.length / postsPerPage)

    Array.from({ length: pagesCount }).forEach((_, index) => {
      const isFirstPage = index === 0
      const currentPage = index + 1

      if (isFirstPage) return

      createPage({
        path: `/page/${currentPage}`,
        component: templates.postsList,
        context: {
          limit: postsPerPage,
          skip: index * postsPerPage,
          currentPage,
          pagesCount,
        },
      })
    })
  })
}