415 lines
14 KiB
JavaScript
415 lines
14 KiB
JavaScript
"use strict";
|
|
|
|
/**
|
|
* Lets plugins implementing support for other compile-to-js add to the list
|
|
* of "resolvable" file extensions. Gatsby supports `.js` and `.jsx` by default.
|
|
* @returns {Array<string>} array of extensions
|
|
*/
|
|
exports.resolvableExtensions = true;
|
|
/**
|
|
* Tell plugins to add pages. This extension point is called only after the initial
|
|
* sourcing and transformation of nodes plus creation of the GraphQL schema are
|
|
* complete so you can query your data in order to create pages.
|
|
*
|
|
* See also [the documentation for the action `createPage`](/docs/actions/#createPage).
|
|
* @example
|
|
* const path = require(`path`)
|
|
*
|
|
* exports.createPages = ({ graphql, actions }) => {
|
|
* const { createPage } = actions
|
|
* const blogPostTemplate = path.resolve(`src/templates/blog-post.js`)
|
|
* // Query for markdown nodes to use in creating pages.
|
|
* // You can query for whatever data you want to create pages for e.g.
|
|
* // products, portfolio items, landing pages, etc.
|
|
* // Variables can be added as the second function parameter
|
|
* return graphql(`
|
|
* query loadPagesQuery ($limit: Int!) {
|
|
* allMarkdownRemark(limit: $limit) {
|
|
* edges {
|
|
* node {
|
|
* frontmatter {
|
|
* slug
|
|
* }
|
|
* }
|
|
* }
|
|
* }
|
|
* }
|
|
* `, { limit: 1000 }).then(result => {
|
|
* if (result.errors) {
|
|
* throw result.errors
|
|
* }
|
|
*
|
|
* // Create blog post pages.
|
|
* result.data.allMarkdownRemark.edges.forEach(edge => {
|
|
* createPage({
|
|
* // Path for this page — required
|
|
* path: `${edge.node.frontmatter.slug}`,
|
|
* component: blogPostTemplate,
|
|
* context: {
|
|
* // Add optional context data to be inserted
|
|
* // as props into the page component..
|
|
* //
|
|
* // The context data can also be used as
|
|
* // arguments to the page GraphQL query.
|
|
* //
|
|
* // The page "path" is always available as a GraphQL
|
|
* // argument.
|
|
* },
|
|
* })
|
|
* })
|
|
* })
|
|
* }
|
|
*/
|
|
|
|
exports.createPages = true;
|
|
/**
|
|
* Like `createPages` but for plugins who want to manage creating and removing
|
|
* pages themselves in response to changes in data *not* managed by Gatsby.
|
|
* Plugins implementing `createPages` will get called regularly to recompute
|
|
* page information as Gatsby's data changes but those implementing
|
|
* `createPagesStatefully` will not.
|
|
*
|
|
* An example of a plugin that uses this extension point is the plugin
|
|
* [gatsby-plugin-page-creator](https://github.com/gatsbyjs/gatsby/tree/master/packages/gatsby-plugin-page-creator)
|
|
* which monitors the `src/pages` directory for the adding and removal of JS
|
|
* pages. As its source of truth, files in the pages directory, is not known by
|
|
* Gatsby, it needs to keep its own state about its world to know when to
|
|
* add and remove pages.
|
|
*/
|
|
|
|
exports.createPagesStatefully = true;
|
|
/**
|
|
* Extension point to tell plugins to source nodes. This API is called during
|
|
* the Gatsby bootstrap sequence. Source plugins use this hook to create nodes.
|
|
* This API is called exactly once per plugin (and once for your site's
|
|
* `gatsby-config.js` file). If you define this hook in `gatsby-node.js` it
|
|
* will be called exactly once after all of your source plugins have finished
|
|
* creating nodes.
|
|
*
|
|
* See also the documentation for [`createNode`](/docs/actions/#createNode).
|
|
* @example
|
|
* exports.sourceNodes = ({ actions, createNodeId, createContentDigest }) => {
|
|
* const { createNode } = actions
|
|
*
|
|
* // Data can come from anywhere, but for now create it manually
|
|
* const myData = {
|
|
* key: 123,
|
|
* foo: `The foo field of my node`,
|
|
* bar: `Baz`
|
|
* }
|
|
*
|
|
* const nodeContent = JSON.stringify(myData)
|
|
*
|
|
* const nodeMeta = {
|
|
* id: createNodeId(`my-data-${myData.key}`),
|
|
* parent: null,
|
|
* children: [],
|
|
* internal: {
|
|
* type: `MyNodeType`,
|
|
* mediaType: `text/html`,
|
|
* content: nodeContent,
|
|
* contentDigest: createContentDigest(myData)
|
|
* }
|
|
* }
|
|
*
|
|
* const node = Object.assign({}, myData, nodeMeta)
|
|
* createNode(node)
|
|
* }
|
|
*/
|
|
|
|
exports.sourceNodes = true;
|
|
/**
|
|
* Called when a new node is created. Plugins wishing to extend or
|
|
* transform nodes created by other plugins should implement this API.
|
|
*
|
|
* See also the documentation for [`createNode`](/docs/actions/#createNode)
|
|
* and [`createNodeField`](/docs/actions/#createNodeField)
|
|
* @example
|
|
* exports.onCreateNode = ({ node, actions }) => {
|
|
* const { createNode, createNodeField } = actions
|
|
* // Transform the new node here and create a new node or
|
|
* // create a new node field.
|
|
* }
|
|
*/
|
|
|
|
exports.onCreateNode = true;
|
|
/**
|
|
* Called when a new page is created. This extension API is useful
|
|
* for programmatically manipulating pages created by other plugins e.g.
|
|
* if you want paths without trailing slashes.
|
|
*
|
|
* See the guide [Creating and Modifying Pages](/docs/creating-and-modifying-pages/)
|
|
* for more on this API.
|
|
*/
|
|
|
|
exports.onCreatePage = true;
|
|
/**
|
|
* Called during the creation of the GraphQL schema. Allows plugins
|
|
* to add new fields to the types created from data nodes. It will be called
|
|
* separately for each type.
|
|
*
|
|
* This function should return an object in the shape of
|
|
* [GraphQLFieldConfigMap](https://graphql.org/graphql-js/type/#graphqlobjecttype)
|
|
* which will be appended to fields inferred by Gatsby from data nodes.
|
|
*
|
|
* *Note:* Import GraphQL types from `gatsby/graphql` and don't add the `graphql`
|
|
* package to your project/plugin dependencies to avoid `Schema must
|
|
* contain unique named types but contains multiple types named` errors.
|
|
* `gatsby/graphql` exports all builtin GraphQL types as well as the `GraphQLJSON`
|
|
* type.
|
|
*
|
|
* Many transformer plugins use this to add fields that take arguments.
|
|
*
|
|
* * [`gatsby-transformer-remark`](/packages/gatsby-transformer-remark/)
|
|
* adds an "excerpt" field where the user when writing their query can specify
|
|
* how many characters to prune the markdown source to.
|
|
* * [`gatsby-transformer-sharp`](/packages/gatsby-transformer-sharp/) exposes
|
|
* many image transformation options as GraphQL fields.
|
|
*
|
|
* @param {object} $0
|
|
* @param {object} $0.type Object containing `name` and `nodes`
|
|
* @example
|
|
* import { GraphQLString } from "gatsby/graphql"
|
|
*
|
|
* exports.setFieldsOnGraphQLNodeType = ({ type }) => {
|
|
* if (type.name === `File`) {
|
|
* return {
|
|
* newField: {
|
|
* type: GraphQLString,
|
|
* args: {
|
|
* myArgument: {
|
|
* type: GraphQLString,
|
|
* }
|
|
* },
|
|
* resolve: (source, fieldArgs) => {
|
|
* return `Id of this node is ${source.id}.
|
|
* Field was called with argument: ${fieldArgs.myArgument}`
|
|
* }
|
|
* }
|
|
* }
|
|
* }
|
|
*
|
|
* // by default return empty object
|
|
* return {}
|
|
* }
|
|
*/
|
|
|
|
exports.setFieldsOnGraphQLNodeType = true;
|
|
/**
|
|
* Customize Gatsby's GraphQL schema by creating type definitions, field
|
|
* extensions or adding third-party schemas.
|
|
*
|
|
* The [`createTypes`](/docs/actions/#createTypes),
|
|
* [`createFieldExtension`](/docs/actions/#createFieldExtension) and
|
|
* [`addThirdPartySchema`](/docs/actions/#addThirdPartySchema) actions
|
|
* are only available in this API. For details on their usage please refer to
|
|
* the actions documentation.
|
|
*
|
|
* This API runs immediately before schema generation. For modifications of the
|
|
* generated schema, e.g. to customize added third-party types, use the
|
|
* [`createResolvers`](/docs/node-apis/#createResolvers) API.
|
|
*
|
|
* @gatsbyVersion 2.12.0
|
|
* @param {object} $0
|
|
* @param {object} $0.actions
|
|
* @param {object} $0.actions.createTypes
|
|
* @param {object} $0.actions.createFieldExtension
|
|
* @param {object} $0.actions.addThirdPartySchema
|
|
* @example
|
|
* exports.createSchemaCustomization = ({ actions }) => {
|
|
* const { createTypes, createFieldExtension } = actions
|
|
*
|
|
* createFieldExtension({
|
|
* name: 'shout',
|
|
* extend: () => ({
|
|
* resolve(source, args, context, info) {
|
|
* return String(source[info.fieldName]).toUpperCase()
|
|
* }
|
|
* })
|
|
* })
|
|
*
|
|
* const typeDefs = `
|
|
* type MarkdownRemark implements Node @dontInfer {
|
|
* frontmatter: Frontmatter
|
|
* }
|
|
* type Frontmatter {
|
|
* title: String!
|
|
* tagline: String @shout
|
|
* date: Date @dateformat
|
|
* image: File @fileByRelativePath
|
|
* }
|
|
* `
|
|
* createTypes(typeDefs)
|
|
* }
|
|
*/
|
|
|
|
exports.createSchemaCustomization = true;
|
|
/**
|
|
* Add custom field resolvers to the GraphQL schema.
|
|
*
|
|
* Allows adding new fields to types by providing field configs, or adding resolver
|
|
* functions to existing fields.
|
|
*
|
|
* Things to note:
|
|
* * Overriding field types is disallowed, instead use the `createTypes`
|
|
* action. In case of types added from third-party schemas, where this is not
|
|
* possible, overriding field types is allowed.
|
|
* * New fields will not be available on `filter` and `sort` input types. Extend
|
|
* types defined with `createTypes` if you need this.
|
|
* * In field configs, types can be referenced as strings.
|
|
* * When extending a field with an existing field resolver, the original
|
|
* resolver function is available from `info.originalResolver`.
|
|
* * The `createResolvers` API is called as the last step in schema generation.
|
|
* Thus, an intermediate schema is made available on the `intermediateSchema` property.
|
|
* In resolver functions themselves, it is recommended to access the final
|
|
* built schema from `info.schema`.
|
|
* * Gatsby's data layer, including all internal query capabilities, is
|
|
* exposed on [`context.nodeModel`](/docs/node-model/). The node store can be
|
|
* queried directly with `getAllNodes`, `getNodeById` and `getNodesByIds`,
|
|
* while more advanced queries can be composed with `runQuery`. Note that
|
|
* `runQuery` will call field resolvers before querying, so e.g. foreign-key
|
|
* fields will be expanded to full nodes. The other methods on `nodeModel`
|
|
* don't do this.
|
|
* * It is possible to add fields to the root `Query` type.
|
|
* * When using the first resolver argument (`source` in the example below,
|
|
* often also called `parent` or `root`), take care of the fact that field
|
|
* resolvers can be called more than once in a query, e.g. when the field is
|
|
* present both in the input filter and in the selection set. This means that
|
|
* foreign-key fields on `source` can be either resolved or not-resolved.
|
|
*
|
|
* For fuller examples, see [`using-type-definitions`](https://github.com/gatsbyjs/gatsby/tree/master/examples/using-type-definitions).
|
|
*
|
|
* @gatsbyVersion 2.2.0
|
|
* @param {object} $0
|
|
* @param {GraphQLSchema} $0.intermediateSchema Current GraphQL schema
|
|
* @param {function} $0.createResolvers Add custom resolvers to GraphQL field configs
|
|
* @param {object} $1
|
|
* @param {object} $1.resolvers Resolvers from plugin options in `gatsby-config.js`.
|
|
* @example
|
|
* exports.createResolvers = ({ createResolvers }) => {
|
|
* const resolvers = {
|
|
* Author: {
|
|
* fullName: {
|
|
* resolve: (source, args, context, info) => {
|
|
* return source.firstName + source.lastName
|
|
* }
|
|
* },
|
|
* },
|
|
* Query: {
|
|
* allRecentPosts: {
|
|
* type: [`BlogPost`],
|
|
* resolve: (source, args, context, info) => {
|
|
* const posts = context.nodeModel.getAllNodes({ type: `BlogPost` })
|
|
* const recentPosts = posts.filter(
|
|
* post => post.publishedAt > Date.UTC(2018, 0, 1)
|
|
* )
|
|
* return recentPosts
|
|
* }
|
|
* }
|
|
* }
|
|
* }
|
|
* createResolvers(resolvers)
|
|
* }
|
|
*/
|
|
|
|
exports.createResolvers = true;
|
|
/**
|
|
* Ask compile-to-js plugins to process source to JavaScript so the query
|
|
* runner can extract out GraphQL queries for running.
|
|
*/
|
|
|
|
exports.preprocessSource = true;
|
|
/**
|
|
* Tell plugins with expensive "side effects" from queries to start running
|
|
* those now. This is a soon-to-be-replaced API only currently in use by
|
|
* `gatsby-plugin-sharp`.
|
|
*/
|
|
|
|
exports.generateSideEffects = true;
|
|
/**
|
|
* Let plugins extend/mutate the site's Babel configuration.
|
|
* This API will change before 2.0 as it needs still to be converted to use
|
|
* Redux actions.
|
|
*/
|
|
|
|
exports.onCreateBabelConfig = true;
|
|
/**
|
|
* Let plugins extend/mutate the site's webpack configuration.
|
|
*
|
|
* See also the documentation for [`setWebpackConfig`](/docs/actions/#setWebpackConfig).
|
|
*
|
|
* @param {object} $0
|
|
* @param {string} $0.stage The current build stage. One of 'develop', 'develop-html',
|
|
* 'build-javascript', or 'build-html'
|
|
* @param {function} $0.getConfig Returns the current webpack config
|
|
* @param {object} $0.rules A set of preconfigured webpack config rules
|
|
* @param {object} $0.loaders A set of preconfigured webpack config loaders
|
|
* @param {object} $0.plugins A set of preconfigured webpack config plugins
|
|
* @param {object} $0.actions
|
|
* @example
|
|
* exports.onCreateWebpackConfig = ({
|
|
* stage, getConfig, rules, loaders, actions
|
|
* }) => {
|
|
* actions.setWebpackConfig({
|
|
* module: {
|
|
* rules: [
|
|
* {
|
|
* test: 'my-css',
|
|
* use: [loaders.style(), loaders.css()]
|
|
* },
|
|
* ],
|
|
* },
|
|
* });
|
|
* }
|
|
*/
|
|
|
|
exports.onCreateWebpackConfig = true;
|
|
/**
|
|
* The first API called during Gatsby execution, runs as soon as plugins are loaded, before cache initialization and bootstrap preparation.
|
|
*/
|
|
|
|
exports.onPreInit = true;
|
|
/**
|
|
* Called once Gatsby has initialized itself and is ready to bootstrap your site.
|
|
*/
|
|
|
|
exports.onPreBootstrap = true;
|
|
/**
|
|
* Called at the end of the bootstrap process after all other extension APIs have been called.
|
|
*/
|
|
|
|
exports.onPostBootstrap = true;
|
|
/**
|
|
* The first extension point called during the build process. Called after the bootstrap has completed but before the build steps start.
|
|
*/
|
|
|
|
exports.onPreBuild = true;
|
|
/**
|
|
* The last extension point called after all other parts of the build process
|
|
* are complete.
|
|
*/
|
|
|
|
exports.onPostBuild = true;
|
|
/**
|
|
* Run before GraphQL queries/fragments are extracted from JavaScript files. Useful for plugins
|
|
* to add more JavaScript files with queries/fragments e.g. from node_modules.
|
|
*
|
|
* See gatsby-transformer-sharp and gatsby-source-contentful for examples.
|
|
*/
|
|
|
|
exports.onPreExtractQueries = true;
|
|
/**
|
|
* Run when gatsby develop server is started, its useful to add proxy and middleware
|
|
* to the dev server app
|
|
* @param {object} $0
|
|
* @param {Express} $0.app The [Express app](https://expressjs.com/en/4x/api.html#app) used to run the dev server
|
|
* @example
|
|
* exports.onCreateDevServer = ({ app }) => {
|
|
* app.get('/hello', function (req, res) {
|
|
* res.send('hello world')
|
|
* })
|
|
* }
|
|
*/
|
|
|
|
exports.onCreateDevServer = true;
|
|
//# sourceMappingURL=api-node-docs.js.map
|