gatsby

method toString

toString: () => string;

• Allows type-safe access to the static query hash for debugging purposes.

method addGatsbyImageSourceUrl

addGatsbyImageSourceUrl: (this: void, sourceUrl: string) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#addGatsbyImageSourceUrl

method addRemoteFileAllowedUrl

addRemoteFileAllowedUrl: (
    this: void,
    url: string | Array<string>,
    plugin?: ActionPlugin,
    traceId?: string
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#addRemoteFileAllowedUrl

method addThirdPartySchema

addThirdPartySchema: (
    this: void,
    args: { schema: object },
    plugin?: ActionPlugin,
    traceId?: string
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#addThirdPartySchema

method createFieldExtension

createFieldExtension: (
    this: void,
    extension: object,
    plugin?: ActionPlugin,
    traceId?: string
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#createFieldExtension

method createJob

createJob: (
    this: void,
    job: Record<string, unknown> & { id: string },
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#createJob

method createJobV2

createJobV2: (
    this: void,
    job: {
        name: string;
        inputPaths: string[];
        outputDir: string;
        args: Record<string, unknown>;
    },
    plugin?: ActionPlugin
) => Promise<unknown>;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#createJobV2

method createNode

createNode: <TNode = Record<string, unknown>>(
    this: void,
    node: NodeInput & TNode,
    plugin?: ActionPlugin,
    options?: ActionOptions
) => void | Promise<void>;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#createNode

method createNodeField

createNodeField: (
    this: void,
    args: { node: Node; name?: string; value: any },
    plugin?: ActionPlugin,
    options?: ActionOptions
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#createNodeField

method createPage

createPage: <TContext = Record<string, unknown>>(
    this: void,
    args: Page<TContext>,
    plugin?: ActionPlugin,
    option?: ActionOptions
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#createPage

method createParentChildLink

createParentChildLink: (
    this: void,
    args: { parent: Node; child: NodeInput },
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#createParentChildLink

method createRedirect

createRedirect: (
    this: void,
    redirect: {
        [key: string]: unknown;
        fromPath: string;
        isPermanent?: boolean;
        toPath: string;
        redirectInBrowser?: boolean;
        force?: boolean;
        statusCode?: number;
        ignoreCase?: boolean;
    },
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#createRedirect

method createSlice

createSlice: <TContext = Record<string, unknown>>(
    this: void,
    args: SliceInput<TContext>,
    plugin?: ActionPlugin,
    option?: ActionOptions
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/reference/config-files/actions/#createSlice

method createTypes

createTypes: (
    this: void,
    types:
        | string
        | GraphQLOutputType
        | GatsbyGraphQLType
        | Array<string | GraphQLOutputType | GatsbyGraphQLType>,
    plugin?: ActionPlugin,
    traceId?: string
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#createTypes

method deleteNode

deleteNode: (node: NodeInput, plugin?: ActionPlugin) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#deleteNode

method deletePage

deletePage: (this: void, args: { path: string; component: string }) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#deletePage

method enableStatefulSourceNodes

enableStatefulSourceNodes: (this: void, plugin?: ActionPlugin) => void;

• Marks the source plugin that called this function as stateful. Gatsby will not check for stale nodes for any plugin that calls this.

method endJob

endJob: (this: void, job: { id: string }, plugin?: ActionPlugin) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#endJob

method printTypeDefinitions

printTypeDefinitions: (
    this: void,
    options: {
        path?: string;
        include?: { types?: Array<string>; plugins?: Array<string> };
        exclude?: { types?: Array<string>; plugins?: Array<string> };
        withFieldTypes?: boolean;
    },
    plugin?: ActionPlugin,
    traceId?: string
) => void;

method replaceWebpackConfig

replaceWebpackConfig: (
    this: void,
    config: object,
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#replaceWebpackConfig

method setBabelOptions

setBabelOptions: (this: void, options: object, plugin?: ActionPlugin) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#setBabelOptions

method setBabelPlugin

setBabelPlugin: (
    this: void,
    config: { name: string; options: object },
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#setBabelPlugin

method setBabelPreset

setBabelPreset: (
    this: void,
    config: { name: string; options: object },
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#setBabelPreset

method setJob

setJob: (
    this: void,
    job: Record<string, unknown> & { id: string },
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#setJob

method setPluginStatus

setPluginStatus: (
    this: void,
    status: Record<string, unknown>,
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#setPluginStatus

method setRequestHeaders

setRequestHeaders: (
    this: void,
    args: { domain: string; headers: Record<string, string> },
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#setRequestHeaders

method setWebpackConfig

setWebpackConfig: (this: void, config: object, plugin?: ActionPlugin) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#setWebpackConfig

method touchNode

touchNode: (node: NodeInput, plugin?: ActionPlugin) => void;

• See Also

  • https://www.gatsbyjs.com/docs/actions/#touchNode

method unstable_createNodeManifest

unstable_createNodeManifest: (
    this: void,
    args: { manifestId: string; node: Node; updatedAtUTC?: string | number },
    plugin?: ActionPlugin
) => void;

• See Also

  • https://www.gatsbyjs.com/docs/reference/config-files/actions/#unstable_createNodeManifest

property getResourceURLsForPathname

getResourceURLsForPathname: Function;

index signature

[key: string]: unknown;

method graphql

graphql: <TData, TVariables = any>(
    query: string,
    variables?: TVariables
) => Promise<{ errors?: any; data?: TData }>;

property cache

cache: {
    getAndPassUp: Function;
    wrap: Function;
    set: Function;
    mset: Function;
    get: Function;
    mget: Function;
    del: Function;
    reset: Function;
};

property name

name: string;

property store

store: {
    create: Function;
};

property stage

stage: GatsbyStages;

property app

app: any;

property node

node: Node & TNode;

property traceId

traceId: string;

property traceTags

traceTags: {
    nodeId: string;
    nodeType: string;
};

property page

page: Page<TContext>;

property traceId

traceId: string;

property traceId

traceId: string;

property waitForCascadingActions

waitForCascadingActions: boolean;

method graphql

graphql: <TData, TVariables = any>(
    query: string,
    variables?: TVariables
) => Promise<{ errors?: any; data?: TData }>;

property createResolvers

createResolvers: Function;

property intermediateSchema

intermediateSchema: object;

property traceId

traceId: 'initial-createResolvers';

property traceId

traceId: 'initial-createSchemaCustomization';

property getConfig

getConfig: Function;

property loaders

loaders: WebpackLoaders;

property plugins

plugins: WebpackPlugins;

property rules

rules: WebpackRules;

property stage

stage: GatsbyStages;

method disableCorePrefetching

disableCorePrefetching: (
    args: BrowserPluginArgs,
    options: PluginOptions
) => boolean;

method onClientEntry

onClientEntry: (args: BrowserPluginArgs, options: PluginOptions) => void;

method onInitialClientRender

onInitialClientRender: (args: BrowserPluginArgs, options: PluginOptions) => void;

method onPostPrefetchPathname

onPostPrefetchPathname: (
    args: PrefetchPathnameArgs,
    options: PluginOptions
) => void;

method onPrefetchPathname

onPrefetchPathname: (args: PrefetchPathnameArgs, options: PluginOptions) => void;

method onPreRouteUpdate

onPreRouteUpdate: (args: RouteUpdateArgs, options: PluginOptions) => void;

method onRouteUpdate

onRouteUpdate: (args: RouteUpdateArgs, options: PluginOptions) => void;

method onRouteUpdateDelayed

onRouteUpdateDelayed: (
    args: RouteUpdateDelayedArgs,
    options: PluginOptions
) => void;

method onServiceWorkerActive

onServiceWorkerActive: (args: ServiceWorkerArgs, options: PluginOptions) => void;

method onServiceWorkerInstalled

onServiceWorkerInstalled: (
    args: ServiceWorkerArgs,
    options: PluginOptions
) => void;

method onServiceWorkerRedundant

onServiceWorkerRedundant: (
    args: ServiceWorkerArgs,
    options: PluginOptions
) => void;

method onServiceWorkerUpdateFound

onServiceWorkerUpdateFound: (
    args: ServiceWorkerArgs,
    options: PluginOptions
) => void;

method onServiceWorkerUpdateReady

onServiceWorkerUpdateReady: (
    args: ServiceWorkerArgs,
    options: PluginOptions
) => void;

method registerServiceWorker

registerServiceWorker: (
    args: BrowserPluginArgs,
    options: PluginOptions
) => boolean;

method replaceHydrateFunction

replaceHydrateFunction: (
    args: BrowserPluginArgs,
    options: PluginOptions
) => Renderer;

method shouldUpdateScroll

shouldUpdateScroll: (
    args: ShouldUpdateScrollArgs,
    options: PluginOptions
) => boolean | [number, number] | string;

method wrapPageElement

wrapPageElement: (
    args: WrapPageElementBrowserArgs<DataType, PageContext, LocationState>,
    options: PluginOptions
) => React.ReactElement;

method wrapRootElement

wrapRootElement: (
    args: WrapRootElementBrowserArgs,
    options: PluginOptions
) => React.ReactElement;

property directory

directory: string;

property name

name: string;

method del

del: (key: string) => Promise<void>;

• Deletes cached value

  Parameter key

  Cache key

  Returns

  {Promise} Promise resolving once key is deleted from cache

  Example 1

  await cache.del(unique-key)

method get

get: (key: string) => Promise<any>;

• Retrieve cached value

  Parameter key

  Cache key

  Returns

  Promise resolving to cached value

  Example 1

  const value = await cache.get(unique-key)

method set

set: (key: string, value: any) => Promise<any>;

• Cache value

  Parameter key

  Cache key

  Parameter value

  Value to be cached

  Returns

  Promise resolving to cached value

  Example 1

  await cache.set(unique-key, value)

property adapter

adapter?: IAdapter;

• Adapters are responsible for taking the production output from Gatsby and turning it into something your deployment platform understands. They make it easier to build and deploy Gatsby on any deployment platform.

  See Also

  • http://www.gatsbyjs.com/docs/how-to/previews-deploys-hosting/adapters/

property assetPrefix

assetPrefix?: string;

• In some circumstances you may want to deploy assets (non-HTML resources such as JavaScript, CSS, etc.) to a separate domain. assetPrefix allows you to use Gatsby with assets hosted from a separate domain

property flags

flags?: Record<string, boolean>;

• You can activate and deactivate current experiments here. These are experimental features that are currently under development and need testing. When opting in to an experiment you'll receive a console message with more information of what it does and a link to an umbrella discussion.

property graphqlTypegen

graphqlTypegen?: boolean | GraphQLTypegenOptions;

• More easily incorporate content into your pages through automatic TypeScript type generation and better GraphQL IntelliSense. If set to true, the default GraphQLTypegenOptions are used. See https://www.gatsbyjs.com/docs/reference/config-files/gatsby-config/ for all options.

property headers

headers?: Array<Header>;

• You can set custom HTTP headers on the response of a given path. This allows you to, e.g. modify the caching behavior or configure access control. You can apply HTTP headers to static routes and redirects.

  See Also

  • http://www.gatsbyjs.com/docs/how-to/previews-deploys-hosting/headers/

property jsxImportSource

jsxImportSource?: string;

property jsxRuntime

jsxRuntime?: 'automatic' | 'classic';

property mapping

mapping?: Record<string, string>;

property partytownProxiedURLs

partytownProxiedURLs?: Array<string>;

• A list of trusted URLs that will be proxied for use with the gatsby-script off-main-thread strategy.

  See Also

  • https://gatsby.dev/gatsby-script

property pathPrefix

pathPrefix?: string;

• It’s common for sites to be hosted somewhere other than the root of their domain. Say we have a Gatsby site at example.com/blog/. In this case, we would need a prefix (/blog) added to all paths on the site.

property plugins

plugins?: Array<PluginRef>;

• Plugins are Node.js packages that implement Gatsby APIs. The config file accepts an array of plugins. Some plugins may need only to be listed by name, while others may take options.

property polyfill

polyfill?: boolean;

• Gatsby uses the ES6 Promise API. Because some browsers don't support this, Gatsby includes a Promise polyfill by default. If you'd like to provide your own Promise polyfill, you can set polyfill to false.

property proxy

proxy?: Proxy | Proxy[];

• Setting the proxy config option will tell the develop server to proxy any unknown requests to your specified server.

  See Also

  • https://www.gatsbyjs.com/docs/api-proxy/

property siteMetadata

siteMetadata?: Record<string, unknown>;

• When you want to reuse common pieces of data across the site (for example, your site title), you can store that here.

property trailingSlash

trailingSlash?: 'always' | 'never' | 'ignore';

• never removes all trailing slashes, always adds it, and ignore doesn't automatically change anything and it's in user hands to keep things consistent. By default always is used.

method developMiddleware

developMiddleware: (app: any) => void;

• Sometimes you need more granular/flexible access to the development server. Gatsby exposes the Express.js development server to your site’s gatsby-config.js where you can add Express middleware as needed.

property limit

limit?: string | number;

property type

type?: string;

property json

json?: GatsbyFunctionBodyParserCommonMiddlewareConfig;

property raw

raw?: GatsbyFunctionBodyParserCommonMiddlewareConfig;

property text

text?: GatsbyFunctionBodyParserCommonMiddlewareConfig;

property urlencoded

urlencoded?: GatsbyFunctionBodyParserUrlencodedConfig;

property extended

extended: boolean;

property bodyParser

bodyParser?: GatsbyFunctionBodyParserConfig;

property body

body: ReqBody;

property cookies

cookies: Record<string, string>;

• Object of cookies from header

property params

params: Record<string, string>;

• Object of values from route parameters

property query

query: Record<string, string>;

• Object of values from URL query parameters (after the ? in the URL)

property rawUrl

rawUrl?: string;

• Optional field to store the full raw URL by adapters

property json

json: Send<T>;

• Send JSON data in response

property send

send: Send<T>;

• Send any data in response

property status

status: (statusCode: number) => GatsbyFunctionResponse<T>;

• Set the HTTP status code of the response

method redirect

redirect: {
    (url: string): GatsbyFunctionResponse<T>;
    (status: number, url: string): GatsbyFunctionResponse<T>;
};

property config

config: ComposeEnumTypeConfig;

property kind

kind: 'ENUM';

property config

config: ComposeInputObjectTypeConfig;

property kind

kind: 'INPUT_OBJECT';

property config

config: ComposeInterfaceTypeConfig<any, any>;

property kind

kind: 'INTERFACE';

property config

config: ComposeObjectTypeConfig<any, any>;

property kind

kind: 'OBJECT';

property config

config: ComposeScalarTypeConfig;

property kind

kind: 'SCALAR';

property config

config: ComposeUnionTypeConfig<any, any>;

property kind

kind: 'UNION';

method createPages

createPages: (
    args: CreatePagesArgs & { traceId: 'initial-createPages' },
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• 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

  • https://www.gatsbyjs.com/docs/node-apis/#createPages

method createPagesStatefully

createPagesStatefully: (
    args: CreatePagesArgs & { traceId: 'initial-createPagesStatefully' },
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• 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.

method createResolvers

createResolvers: (
    args: CreateResolversArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• 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 schema 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 findOne, getNodeById and getNodesByIds, while more advanced queries can be composed with findAll. * 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).

  See Also

  • https://www.gatsbyjs.com/docs/reference/config-files/gatsby-node/#createResolvers

method createSchemaCustomization

createSchemaCustomization: (
    args: CreateSchemaCustomizationArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• Customize Gatsby’s GraphQL schema by creating type definitions, field extensions or adding third-party schemas. The createTypes, createFieldExtension and 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 API.

  See Also

  • https://www.gatsbyjs.com/docs/node-apis/#createSchemaCustomization

method onCreateBabelConfig

onCreateBabelConfig: (
    args: CreateBabelConfigArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• 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.

method onCreateDevServer

onCreateDevServer: (
    args: CreateDevServerArgs,
    options: PluginOptions,
    calllback: PluginCallback<void>
) => void | Promise<void>;

• Run when gatsby develop server is started, its useful to add proxy and middleware to the dev server app

  Parameter $0

  Parameter

  {Express} $0.app The [Express app](https://expressjs.com/en/4x/api.html#app) used to run the dev server

  Example 1

  exports.onCreateDevServer = ({ app }) => { app.get('/hello', function (req, res) { res.send('hello world') }) }

method onCreateNode

onCreateNode: (
    args: CreateNodeArgs<TNode>,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• 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 and [createNodeField](https://www.gatsbyjs.com/docs/reference/config-files/actions/#createNodeField)

  Parameter $0

  Parameter

  {object} $0.node A node object.

  Parameter

  {object} $0.actions

  Parameter

  {function} $0.actions.createNode Create a new node.

  Parameter

  {function} $0.actions.createNodeField Extend another node. The new node field is placed under the fields key on the extended node object.

  Example 1

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

  if (node.internal.type === MarkdownRemark) { const nodePath = node.fileAbsolutePath

  if (nodePath.match(//blog//)) { const postSlug = createFilePath({ node, getNode, basePath: src/content, trailingSlash: true, })

  createNodeField({ node, name: slug, value: /blog/${postSlug}/, }) } } }

method onCreatePage

onCreatePage: (
    args: CreatePageArgs<TContext>,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• 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](https://www.gatsbyjs.com/docs/creating-and-modifying-pages/) for more on this API.

method onCreateWebpackConfig

onCreateWebpackConfig: (
    args: CreateWebpackConfigArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• Let plugins extend/mutate the site's webpack configuration.

  See Also

  • https://www.gatsbyjs.com/docs/node-apis/#onCreateWebpackConfig

method onPluginInit

onPluginInit: (
    args: ParentSpanPluginArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• Lifecycle executed in each process (one time per process). Used to store actions, etc. for later use. Plugins should use this over other APIs like "onPreBootstrap" or "onPreInit" since onPluginInit will run in main process + all workers to support Parallel Query Running. 3.9.0

  Example 1

  let createJobV2 exports.onPluginInit = ({ actions }) => { // Store job creation action to use it later createJobV2 = actions.createJobV2 }

method onPostBootstrap

onPostBootstrap: (
    args: ParentSpanPluginArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• Called at the end of the bootstrap process after all other extension APIs have been called.

method onPostBuild

onPostBuild: (
    args: BuildArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• The last extension point called after all other parts of the build process are complete.

method onPreBootstrap

onPreBootstrap: (
    args: ParentSpanPluginArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• Called at the end of the bootstrap process after all other extension APIs have been called. If you indend to use this API in a plugin, use "onPluginInit" instead.

method onPreBuild

onPreBuild: (
    args: BuildArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• The first extension point called during the build process. Called after the bootstrap has completed but before the build steps start.

method onPreExtractQueries

onPreExtractQueries: (
    args: ParentSpanPluginArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• Called once Gatsby has initialized itself and is ready to bootstrap your site.

method onPreInit

onPreInit: (
    args: PreInitArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | Promise<void>;

• The first API called during Gatsby execution, runs as soon as plugins are loaded, before cache initialization and bootstrap preparation. If you indend to use this API in a plugin, use "onPluginInit" instead.

method pluginOptionsSchema

pluginOptionsSchema: (args: PluginOptionsSchemaArgs) => ObjectSchema;

• Add a Joi schema for the possible options of your plugin. Currently experimental and not enabled by default.

method preprocessSource

preprocessSource: (
    args: PreprocessSourceArgs,
    options: PluginOptions,
    callback: PluginCallback<void>
) => void | string | Promise<void | string>;

• Ask compile-to-js plugins to process source to JavaScript so the query runner can extract out GraphQL queries for running.

method resolvableExtensions

resolvableExtensions: (
    args: ResolvableExtensionsArgs,
    options: PluginOptions,
    callback: PluginCallback<Array<string>>
) => Array<string> | Promise<Array<string>>;