allow processing of custom markdown nodes

README.md

@@ -71,6 +71,23 @@ module.exports = {
               // [Optional] Exclude the following fields, use dot notation for nested fields
               // No fields are excluded by default
               exclude: ['featured.skip'],
+              // [Optional] in case you want to process markdown nodes that were not created from a file
+              // you can provide a resolver function which produces the absolute path for a given node.
+              // In the example below the remarkNode was a child node of a fileNode. E.g. if you have
+              // markdown content in your frontmatter fields.
+              resolveNodePath: ({ node, getNode }) => {
+                let fileAbsolutePath = undefined;
+                let curNode = node;
+                while (curNode.parent && !fileAbsolutePath) {
+                  curNode = getNode(curNode.parent);
+                  fileAbsolutePath =
+                    curNode.fileAbsolutePath || curNode.absolutePath;
+                  if (fileAbsolutePath) {
+                    return fileAbsolutePath;
+                  }
+                }
+                return undefined;
+              },
             },
           },
           {

src/index.ts

@@ -3,6 +3,7 @@ import { selectAll } from 'unist-util-select';
 import { defaults, isString, find } from 'lodash';
 import cheerio from 'cheerio';
 import { slash } from './utils';
+import { GatsbyNode } from 'gatsby';
 
 export type GatsbyNodePluginArgs = {
   files: GatsbyFile[];
@@ -11,16 +12,24 @@ export type GatsbyNodePluginArgs = {
   reporter: {
     info: (msg: string, error?: Error) => void;
   };
+  getNode: (id: string) => GatsbyNode;
 };
 
 export type GatsbyFile = {
   absolutePath: string;
 };
 
+export interface ResolveNodeArgs {
+  node: GatsbyNode;
+  getNode: (id: string) => GatsbyNode;
+}
+export type ResolveNodeFunc = (args: ResolveNodeArgs) => string;
+
 export type PluginOptions = {
   staticFolderName: string;
   include: string[];
   exclude: string[];
+  resolveNodePath?: ResolveNodeFunc;
 };
 
 export type FrontMatterOptions = {
@@ -72,15 +81,23 @@ export const findMatchingFile = (
 };
 
 export default async (
-  { files, markdownNode, markdownAST }: GatsbyNodePluginArgs,
+  { files, markdownNode, markdownAST, getNode }: GatsbyNodePluginArgs,
   pluginOptions: PluginOptions
 ) => {
   // Default options
   const options = defaults(pluginOptions, defaultPluginOptions);
 
-  if (!markdownNode.fileAbsolutePath) return;
+  let fileAbsolutePath = markdownNode.fileAbsolutePath;
+
+  if (!fileAbsolutePath && pluginOptions.resolveNodePath) {
+    fileAbsolutePath = pluginOptions.resolveNodePath({
+      node: markdownNode,
+      getNode,
+    });
+  }
+  if (!fileAbsolutePath) return;
 
-  const directory = path.dirname(markdownNode.fileAbsolutePath);
+  const directory = path.dirname(fileAbsolutePath);
 
   // Process all markdown image nodes
   selectAll('image', markdownAST).forEach((_node: any) => {

src/on-create-node.ts

@@ -1,3 +1,4 @@
+import { GatsbyNode } from 'gatsby';
 import path from 'path';
 import { defaults, isString } from 'lodash';
 import traverse from 'traverse';
@@ -12,21 +13,25 @@ import {
 export type GatsbyPluginArgs = {
   node: MarkdownNode;
   getNodesByType: (type: string) => GatsbyFile[];
+  getNode: (id: string) => GatsbyNode;
   reporter: {
     info: (msg: string, error?: Error) => void;
   };
 };
 
 export const onCreateNode = (
-  { node, getNodesByType }: GatsbyPluginArgs,
+  { node, getNodesByType, getNode }: GatsbyPluginArgs,
   pluginOptions: PluginOptions
 ) => {
   const options = defaults(pluginOptions, defaultPluginOptions);
 
   if (node.internal.type === `MarkdownRemark` || node.internal.type === `Mdx`) {
     const files = getNodesByType(`File`);
 
-    const directory = path.dirname(node.fileAbsolutePath);
+    let fileAbsolutePath = node.fileAbsolutePath;
+    if (!fileAbsolutePath && pluginOptions.resolveNodePath) {
+    }
+    const directory = path.dirname(fileAbsolutePath);
 
     // Deeply iterate through frontmatter data for absolute paths
     traverse(node.frontmatter).forEach(function (value) {