336 lines
9.1 KiB
JavaScript
336 lines
9.1 KiB
JavaScript
const { createFilePath } = require('gatsby-source-filesystem');
|
|
// TODO: ideally we'd remove lodash and just use lodash-es, but we can't require
|
|
// es modules here.
|
|
const uniq = require('lodash/uniq');
|
|
const MonacoWebpackPlugin = require('monaco-editor-webpack-plugin');
|
|
const webpack = require('webpack');
|
|
const env = require('../config/env.json');
|
|
|
|
const { blockNameify } = require('../utils/block-nameify');
|
|
const {
|
|
createChallengePages,
|
|
createBlockIntroPages,
|
|
createSuperBlockIntroPages
|
|
} = require('./utils/gatsby');
|
|
|
|
const createByIdentityMap = {
|
|
blockIntroMarkdown: createBlockIntroPages,
|
|
superBlockIntroMarkdown: createSuperBlockIntroPages
|
|
};
|
|
|
|
exports.onCreateNode = function onCreateNode({ node, actions, getNode }) {
|
|
const { createNodeField } = actions;
|
|
|
|
if (node.internal.type === 'MarkdownRemark') {
|
|
const slug = createFilePath({ node, getNode });
|
|
if (!slug.includes('LICENSE')) {
|
|
const {
|
|
frontmatter: { component = '' }
|
|
} = node;
|
|
createNodeField({ node, name: 'slug', value: slug });
|
|
createNodeField({ node, name: 'component', value: component });
|
|
}
|
|
}
|
|
};
|
|
|
|
exports.createPages = function createPages({ graphql, actions, reporter }) {
|
|
if (!env.algoliaAPIKey || !env.algoliaAppId) {
|
|
if (process.env.FREECODECAMP_NODE_ENV === 'production') {
|
|
throw new Error(
|
|
'Algolia App id and API key are required to start the client!'
|
|
);
|
|
} else {
|
|
reporter.info(
|
|
'Algolia keys missing or invalid. Required for search to yield results.'
|
|
);
|
|
}
|
|
}
|
|
|
|
if (!env.stripePublicKey) {
|
|
if (process.env.FREECODECAMP_NODE_ENV === 'production') {
|
|
throw new Error('Stripe public key is required to start the client!');
|
|
} else {
|
|
reporter.info(
|
|
'Stripe public key is missing or invalid. Required for Stripe integration.'
|
|
);
|
|
}
|
|
}
|
|
|
|
const { createPage } = actions;
|
|
|
|
return new Promise((resolve, reject) => {
|
|
// Query for all markdown 'nodes' and for the slug we previously created.
|
|
resolve(
|
|
graphql(`
|
|
{
|
|
allChallengeNode(
|
|
sort: {
|
|
fields: [
|
|
challenge___superOrder
|
|
challenge___order
|
|
challenge___challengeOrder
|
|
]
|
|
}
|
|
) {
|
|
edges {
|
|
node {
|
|
challenge {
|
|
block
|
|
certification
|
|
challengeType
|
|
fields {
|
|
slug
|
|
}
|
|
hasEditableBoundaries
|
|
id
|
|
order
|
|
required {
|
|
link
|
|
src
|
|
}
|
|
challengeOrder
|
|
challengeFiles {
|
|
name
|
|
ext
|
|
contents
|
|
head
|
|
tail
|
|
history
|
|
}
|
|
solutions {
|
|
contents
|
|
ext
|
|
history
|
|
}
|
|
superBlock
|
|
superOrder
|
|
template
|
|
usesMultifileEditor
|
|
}
|
|
}
|
|
}
|
|
}
|
|
allMarkdownRemark {
|
|
edges {
|
|
node {
|
|
fields {
|
|
slug
|
|
nodeIdentity
|
|
component
|
|
}
|
|
frontmatter {
|
|
certification
|
|
block
|
|
superBlock
|
|
title
|
|
}
|
|
htmlAst
|
|
id
|
|
excerpt
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`).then(result => {
|
|
if (result.errors) {
|
|
console.log(result.errors);
|
|
return reject(result.errors);
|
|
}
|
|
|
|
// Create challenge pages.
|
|
result.data.allChallengeNode.edges.forEach(
|
|
createChallengePages(createPage)
|
|
);
|
|
|
|
const blocks = uniq(
|
|
result.data.allChallengeNode.edges.map(
|
|
({
|
|
node: {
|
|
challenge: { block }
|
|
}
|
|
}) => block
|
|
)
|
|
).map(block => blockNameify(block));
|
|
|
|
const superBlocks = uniq(
|
|
result.data.allChallengeNode.edges.map(
|
|
({
|
|
node: {
|
|
challenge: { superBlock }
|
|
}
|
|
}) => superBlock
|
|
)
|
|
);
|
|
|
|
// Create intro pages
|
|
// TODO: Remove allMarkdownRemark (populate from elsewhere)
|
|
result.data.allMarkdownRemark.edges.forEach(edge => {
|
|
const {
|
|
node: { frontmatter, fields }
|
|
} = edge;
|
|
|
|
if (!fields) {
|
|
return;
|
|
}
|
|
const { slug, nodeIdentity } = fields;
|
|
if (slug.includes('LICENCE')) {
|
|
return;
|
|
}
|
|
try {
|
|
if (nodeIdentity === 'blockIntroMarkdown') {
|
|
if (!blocks.includes(frontmatter.block)) {
|
|
return;
|
|
}
|
|
} else if (!superBlocks.includes(frontmatter.superBlock)) {
|
|
return;
|
|
}
|
|
const pageBuilder = createByIdentityMap[nodeIdentity](createPage);
|
|
pageBuilder(edge);
|
|
} catch (e) {
|
|
console.log(e);
|
|
console.log(`
|
|
ident: ${nodeIdentity} does not belong to a function
|
|
|
|
${frontmatter ? JSON.stringify(edge.node) : 'no frontmatter'}
|
|
|
|
|
|
`);
|
|
}
|
|
});
|
|
|
|
return null;
|
|
})
|
|
);
|
|
});
|
|
};
|
|
|
|
exports.onCreateWebpackConfig = ({ stage, actions }) => {
|
|
const newPlugins = [
|
|
// We add the shims of the node globals to the global scope
|
|
new webpack.ProvidePlugin({
|
|
Buffer: ['buffer', 'Buffer']
|
|
}),
|
|
new webpack.ProvidePlugin({
|
|
process: 'process/browser'
|
|
})
|
|
];
|
|
// The monaco editor relies on some browser only globals so should not be
|
|
// involved in SSR. Also, if the plugin is used during the 'build-html' stage
|
|
// it overwrites the minfied files with ordinary ones.
|
|
if (stage !== 'build-html') {
|
|
newPlugins.push(
|
|
new MonacoWebpackPlugin({ filename: '[name].worker-[contenthash].js' })
|
|
);
|
|
}
|
|
actions.setWebpackConfig({
|
|
resolve: {
|
|
fallback: {
|
|
fs: false,
|
|
path: require.resolve('path-browserify'),
|
|
assert: require.resolve('assert'),
|
|
crypto: require.resolve('crypto-browserify'),
|
|
util: require.resolve('util/util'),
|
|
buffer: require.resolve('buffer'),
|
|
stream: require.resolve('stream-browserify'),
|
|
process: require.resolve('process/browser')
|
|
}
|
|
},
|
|
plugins: newPlugins
|
|
});
|
|
};
|
|
|
|
exports.onCreateBabelConfig = ({ actions }) => {
|
|
actions.setBabelPlugin({
|
|
name: '@babel/plugin-proposal-function-bind'
|
|
});
|
|
actions.setBabelPlugin({
|
|
name: '@babel/plugin-proposal-export-default-from'
|
|
});
|
|
actions.setBabelPlugin({
|
|
name: 'babel-plugin-transform-imports',
|
|
options: {
|
|
'@freecodecamp/react-bootstrap': {
|
|
transform: '@freecodecamp/react-bootstrap/lib/${member}',
|
|
preventFullImport: true
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
exports.onCreatePage = async ({ page, actions }) => {
|
|
const { createPage } = actions;
|
|
// Only update the `/challenges` page.
|
|
if (page.path.match(/^\/challenges/)) {
|
|
// page.matchPath is a special key that's used for matching pages
|
|
// with corresponding routes only on the client.
|
|
page.matchPath = '/challenges/*';
|
|
// Update the page.
|
|
createPage(page);
|
|
}
|
|
};
|
|
|
|
exports.createSchemaCustomization = ({ actions }) => {
|
|
const { createTypes } = actions;
|
|
const typeDefs = `
|
|
type ChallengeNode implements Node {
|
|
challenge: Challenge
|
|
}
|
|
type Challenge {
|
|
challengeFiles: [FileContents]
|
|
notes: String
|
|
url: String
|
|
}
|
|
type FileContents {
|
|
fileKey: String
|
|
ext: String
|
|
name: String
|
|
contents: String
|
|
head: String
|
|
tail: String
|
|
editableRegionBoundaries: [Int]
|
|
}
|
|
`;
|
|
createTypes(typeDefs);
|
|
};
|
|
|
|
// TODO: this broke the React challenges, not sure why, but I'll investigate
|
|
// further and reimplement if it's possible and necessary (Oliver)
|
|
// I'm still not sure why, but the above schema seems to work.
|
|
// Typically the schema can be inferred, but not when some challenges are
|
|
// skipped (at time of writing the Chinese only has responsive web design), so
|
|
// this makes the missing fields explicit.
|
|
// exports.createSchemaCustomization = ({ actions }) => {
|
|
// const { createTypes } = actions;
|
|
// const typeDefs = `
|
|
// type ChallengeNode implements Node {
|
|
// question: Question
|
|
// videoId: String
|
|
// required: ExternalFile
|
|
// files: ChallengeFile
|
|
// }
|
|
// type Question {
|
|
// text: String
|
|
// answers: [String]
|
|
// solution: Int
|
|
// }
|
|
// type ChallengeFile {
|
|
// indexhtml: FileContents
|
|
// indexjs: FileContents
|
|
// indexjsx: FileContents
|
|
// }
|
|
// type ExternalFile {
|
|
// link: String
|
|
// src: String
|
|
// }
|
|
// type FileContents {
|
|
// key: String
|
|
// ext: String
|
|
// name: String
|
|
// contents: String
|
|
// head: String
|
|
// tail: String
|
|
// }
|
|
// `;
|
|
// createTypes(typeDefs);
|
|
// };
|