gatsby-source-filesystem 4.12.0 → 4.12.1

package/create-file-node-from-buffer.js

@@ -0,0 +1,192 @@
+"use strict";
+
+const fs = require(`fs-extra`);
+
+const path = require(`path`);
+
+const fileType = require(`file-type`);
+
+const {
+  createFileNode
+} = require(`./create-file-node`);
+
+const {
+  createContentDigest,
+  createFilePath
+} = require(`gatsby-core-utils`);
+
+const cacheId = hash => `create-file-node-from-buffer-${hash}`;
+/********************
+ * Type Definitions *
+ ********************/
+
+/**
+ * @typedef {GatsbyCache}
+ * @see gatsby/packages/gatsby/utils/cache.js
+ */
+
+/**
+ * @typedef {CreateFileNodeFromBufferPayload}
+ * @typedef {Object}
+ * @description Create File Node From Buffer Payload
+ *
+ * @param  {Buffer} options.buffer
+ * @param  {String} options.hash
+ * @param  {GatsbyCache} options.cache
+ * @param  {Function} options.getCache
+ * @param  {Function} options.createNode
+ */
+
+/**
+ * writeBuffer
+ * --
+ * Write the contents of `buffer` to `filename`
+ *
+ *
+ * @param {String} filename
+ * @param {Buffer} buffer
+ * @returns {Promise<void>}
+ */
+
+
+const writeBuffer = (filename, buffer) => new Promise((resolve, reject) => {
+  fs.writeFile(filename, buffer, err => err ? reject(err) : resolve());
+});
+/**
+ * processBufferNode
+ * --
+ * Write the buffer contents out to disk and return the fileNode
+ *
+ * @param {CreateFileNodeFromBufferPayload} options
+ * @return {Promise<Object>} Resolves with the fileNode
+ */
+
+
+async function processBufferNode({
+  buffer,
+  hash,
+  cache,
+  createNode,
+  parentNodeId,
+  createNodeId,
+  ext,
+  name
+}) {
+  const pluginCacheDir = cache.directory; // See if there's a cache file for this buffer's contents from
+  // a previous run
+
+  let filename = await cache.get(cacheId(hash));
+
+  if (!filename) {
+    // If the user did not provide an extension and we couldn't get
+    // one from remote file, try and guess one
+    if (typeof ext === `undefined`) {
+      const filetype = await fileType.fromBuffer(buffer);
+      ext = filetype ? `.${filetype.ext}` : `.bin`;
+    }
+
+    filename = createFilePath(path.join(pluginCacheDir, hash), name, ext);
+    await fs.ensureDir(path.dirname(filename)); // Cache the buffer contents
+
+    await writeBuffer(filename, buffer); // Save the cache file path for future use
+
+    await cache.set(cacheId(hash), filename);
+  } // Create the file node.
+
+
+  const fileNode = await createFileNode(filename, createNodeId, {});
+  fileNode.internal.description = `File "Buffer<${hash}>"`;
+  fileNode.hash = hash;
+  fileNode.parent = parentNodeId; // Override the default plugin as gatsby-source-filesystem needs to
+  // be the owner of File nodes or there'll be conflicts if any other
+  // File nodes are created through normal usages of
+  // gatsby-source-filesystem.
+
+  await createNode(fileNode, {
+    name: `gatsby-source-filesystem`
+  });
+  return fileNode;
+}
+/**
+ * Index of promises resolving to File node from buffer cache
+ */
+
+
+const processingCache = {};
+/***************
+ * Entry Point *
+ ***************/
+
+/**
+ * createFileNodeFromBuffer
+ * --
+ *
+ * Cache a buffer's contents to disk
+ * First checks cache to ensure duplicate buffers aren't processed
+ *
+ * @param {CreateFileNodeFromBufferPayload} options
+ * @return {Promise<Object>}                  Returns the created node
+ */
+
+module.exports = ({
+  buffer,
+  hash,
+  cache,
+  createNode,
+  getCache,
+  parentNodeId = null,
+  createNodeId,
+  ext,
+  name
+}) => {
+  // validation of the input
+  // without this it's notoriously easy to pass in the wrong `createNodeId`
+  // see gatsbyjs/gatsby#6643
+  if (typeof createNodeId !== `function`) {
+    throw new Error(`createNodeId must be a function, was ${typeof createNodeId}`);
+  }
+
+  if (typeof createNode !== `function`) {
+    throw new Error(`createNode must be a function, was ${typeof createNode}`);
+  }
+
+  if (typeof getCache === `function`) {
+    // use cache of this plugin and not cache of function caller
+    cache = getCache(`gatsby-source-filesystem`);
+  }
+
+  if (typeof cache !== `object`) {
+    throw new Error(`Neither "cache" or "getCache" was passed. getCache must be function that return Gatsby cache, "cache" must be the Gatsby cache, was ${typeof cache}`);
+  }
+
+  if (!buffer) {
+    return Promise.reject(`bad buffer: ${buffer}`);
+  }
+
+  if (!hash) {
+    hash = createContentDigest(buffer);
+  }
+
+  if (!name) {
+    name = hash;
+  } // Check if we already requested node for this remote file
+  // and return stored promise if we did.
+
+
+  if (processingCache[hash]) {
+    return processingCache[hash];
+  }
+
+  const bufferCachePromise = processBufferNode({
+    buffer,
+    hash,
+    cache,
+    createNode,
+    parentNodeId,
+    createNodeId,
+    ext,
+    name
+  });
+  processingCache[hash] = bufferCachePromise;
+  return processingCache[hash];
+};

package/create-file-node.js

@@ -0,0 +1,89 @@
+"use strict";
+
+const path = require(`path`);
+
+const fs = require(`fs-extra`);
+
+const mime = require(`mime`);
+
+const prettyBytes = require(`pretty-bytes`);
+
+const md5File = require(`md5-file`);
+
+const {
+  createContentDigest,
+  slash
+} = require(`gatsby-core-utils`);
+
+exports.createFileNode = async (pathToFile, createNodeId, pluginOptions = {}) => {
+  const slashed = slash(pathToFile);
+  const parsedSlashed = path.parse(slashed);
+  const slashedFile = { ...parsedSlashed,
+    absolutePath: slashed,
+    // Useful for limiting graphql query with certain parent directory
+    relativeDirectory: slash(path.relative(pluginOptions.path || process.cwd(), parsedSlashed.dir))
+  };
+  const stats = await fs.stat(slashedFile.absolutePath);
+  let internal;
+
+  if (stats.isDirectory()) {
+    const contentDigest = createContentDigest({
+      stats: stats,
+      absolutePath: slashedFile.absolutePath
+    });
+    internal = {
+      contentDigest,
+      type: `Directory`,
+      description: `Directory "${path.relative(process.cwd(), slashed)}"`
+    };
+  } else {
+    const contentDigest = await md5File(slashedFile.absolutePath);
+    const mediaType = mime.getType(slashedFile.ext);
+    internal = {
+      contentDigest,
+      type: `File`,
+      mediaType: mediaType ? mediaType : `application/octet-stream`,
+      description: `File "${path.relative(process.cwd(), slashed)}"`
+    };
+  }
+
+  return {
+    // Don't actually make the File id the absolute path as otherwise
+    // people will use the id for that and ids shouldn't be treated as
+    // useful information.
+    id: createNodeId(pathToFile),
+    children: [],
+    parent: null,
+    internal,
+    sourceInstanceName: pluginOptions.name || `__PROGRAMMATIC__`,
+    relativePath: slash(path.relative(pluginOptions.path || process.cwd(), slashedFile.absolutePath)),
+    extension: slashedFile.ext.slice(1).toLowerCase(),
+    prettySize: prettyBytes(stats.size),
+    modifiedTime: stats.mtime.toJSON(),
+    accessTime: stats.atime.toJSON(),
+    changeTime: stats.ctime.toJSON(),
+    birthTime: stats.birthtime.toJSON(),
+    // Note: deprecate splatting the slashedFile object
+    // Note: the object may contain different properties depending on File or Dir
+    ...slashedFile,
+    // TODO: deprecate copying the entire object
+    // Note: not splatting for perf reasons (make sure Date objects are serialized)
+    dev: stats.dev,
+    mode: stats.mode,
+    nlink: stats.nlink,
+    uid: stats.uid,
+    rdev: stats.rdev,
+    blksize: stats.blksize,
+    ino: stats.ino,
+    size: stats.size,
+    blocks: stats.blocks,
+    atimeMs: stats.atimeMs,
+    mtimeMs: stats.mtimeMs,
+    ctimeMs: stats.ctimeMs,
+    birthtimeMs: stats.birthtimeMs,
+    atime: stats.atime.toJSON(),
+    mtime: stats.mtime.toJSON(),
+    ctime: stats.ctime.toJSON(),
+    birthtime: stats.birthtime.toJSON()
+  };
+};

package/create-file-path.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const path = require(`path`);
+
+const {
+  slash
+} = require(`gatsby-core-utils`);
+
+function findFileNode({
+  node,
+  getNode
+}) {
+  // Find the file node.
+  let fileNode = node;
+  let whileCount = 0;
+
+  while (fileNode.internal.type !== `File` && fileNode.parent && getNode(fileNode.parent) !== undefined && whileCount < 101) {
+    fileNode = getNode(fileNode.parent);
+    whileCount += 1;
+
+    if (whileCount > 100) {
+      console.log(`It looks like you have a node that's set its parent as itself`, fileNode);
+    }
+  }
+
+  return fileNode;
+}
+
+module.exports = ({
+  node,
+  getNode,
+  basePath = `src/pages`,
+  trailingSlash = true
+}) => {
+  // Find the File node
+  const fileNode = findFileNode({
+    node,
+    getNode
+  });
+  if (!fileNode) return undefined;
+  const relativePath = path.posix.relative(slash(basePath), slash(fileNode.relativePath));
+  const {
+    dir = ``,
+    name
+  } = path.parse(relativePath);
+  const parsedName = name === `index` ? `` : name;
+  return path.posix.join(`/`, dir, parsedName, trailingSlash ? `/` : ``);
+};

package/create-remote-file-node.js

@@ -0,0 +1,172 @@
+"use strict";
+
+const {
+  fetchRemoteFile
+} = require(`gatsby-core-utils/fetch-remote-file`);
+
+const {
+  isWebUri
+} = require(`valid-url`);
+
+const {
+  createFileNode
+} = require(`./create-file-node`);
+/********************
+ * Type Definitions *
+ ********************/
+
+/**
+ * @typedef {GatsbyCache}
+ * @see gatsby/packages/gatsby/utils/cache.js
+ */
+
+/**
+ * @typedef {Reporter}
+ * @see gatsby/packages/gatsby-cli/lib/reporter.js
+ */
+
+/**
+ * @typedef {Auth}
+ * @type {Object}
+ * @property {String} htaccess_pass
+ * @property {String} htaccess_user
+ */
+
+/**
+ * @typedef {CreateRemoteFileNodePayload}
+ * @typedef {Object}
+ * @description Create Remote File Node Payload
+ *
+ * @param  {String} options.url
+ * @param  {GatsbyCache} options.cache
+ * @param  {Function} options.createNode
+ * @param  {Function} options.getCache
+ * @param  {Auth} [options.auth]
+ * @param  {Reporter} [options.reporter]
+ */
+
+/******************
+ * Core Functions *
+ ******************/
+
+/**
+ * processRemoteNode
+ * --
+ * Request the remote file and return the fileNode
+ *
+ * @param {CreateRemoteFileNodePayload} options
+ * @return {Promise<Object>} Resolves with the fileNode
+ */
+
+
+async function processRemoteNode({
+  url,
+  cache,
+  createNode,
+  parentNodeId,
+  auth = {},
+  httpHeaders = {},
+  createNodeId,
+  ext,
+  name
+}) {
+  const filename = await fetchRemoteFile({
+    url,
+    cache,
+    auth,
+    httpHeaders,
+    ext,
+    name
+  }); // Create the file node.
+
+  const fileNode = await createFileNode(filename, createNodeId, {});
+  fileNode.internal.description = `File "${url}"`;
+  fileNode.url = url;
+  fileNode.parent = parentNodeId; // Override the default plugin as gatsby-source-filesystem needs to
+  // be the owner of File nodes or there'll be conflicts if any other
+  // File nodes are created through normal usages of
+  // gatsby-source-filesystem.
+
+  await createNode(fileNode, {
+    name: `gatsby-source-filesystem`
+  });
+  return fileNode;
+}
+/**
+ * Index of promises resolving to File node from remote url
+ */
+
+
+const processingCache = {};
+/***************
+ * Entry Point *
+ ***************/
+
+/**
+ * createRemoteFileNode
+ * --
+ *
+ * Download a remote file
+ * First checks cache to ensure duplicate requests aren't processed
+ * Then pushes to a queue
+ *
+ * @param {CreateRemoteFileNodePayload} options
+ * @return {Promise<Object>}                  Returns the created node
+ */
+
+module.exports = function createRemoteFileNode({
+  url,
+  cache,
+  createNode,
+  getCache,
+  parentNodeId = null,
+  auth = {},
+  httpHeaders = {},
+  createNodeId,
+  ext = null,
+  name = null
+}) {
+  // validation of the input
+  // without this it's notoriously easy to pass in the wrong `createNodeId`
+  // see gatsbyjs/gatsby#6643
+  if (typeof createNodeId !== `function`) {
+    throw new Error(`createNodeId must be a function, was ${typeof createNodeId}`);
+  }
+
+  if (typeof createNode !== `function`) {
+    throw new Error(`createNode must be a function, was ${typeof createNode}`);
+  }
+
+  if (typeof getCache === `function`) {
+    // use cache of this plugin and not cache of function caller
+    cache = getCache(`gatsby-source-filesystem`);
+  }
+
+  if (typeof cache !== `object`) {
+    throw new Error(`Neither "cache" or "getCache" was passed. getCache must be function that return Gatsby cache, "cache" must be the Gatsby cache, was ${typeof cache}`);
+  } // Check if we already requested node for this remote file
+  // and return stored promise if we did.
+
+
+  if (processingCache[url]) {
+    return processingCache[url];
+  }
+
+  if (!url || isWebUri(url) === undefined) {
+    throw new Error(`url passed to createRemoteFileNode is either missing or not a proper web uri: ${url}`);
+  }
+
+  const fileDownloadPromise = processRemoteNode({
+    url,
+    cache,
+    createNode,
+    parentNodeId,
+    createNodeId,
+    auth,
+    httpHeaders,
+    ext,
+    name
+  });
+  processingCache[url] = fileDownloadPromise.then(node => node);
+  return processingCache[url];
+};

package/error-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports.prefixId = prefixId;
+exports.ERROR_MAP = exports.pluginPrefix = exports.CODES = void 0;
+const CODES = {
+  Generic: `10000`,
+  MissingResource: `10001`
+};
+exports.CODES = CODES;
+const pluginPrefix = `gatsby-source-filesystem`;
+exports.pluginPrefix = pluginPrefix;
+
+function prefixId(id) {
+  return `${pluginPrefix}_${id}`;
+} // TODO: Refactor to use contextual data instead of only context.sourceMessage
+// once reporter.setErrorMap is guaranteed to be available
+
+
+const ERROR_MAP = {
+  [CODES.Generic]: {
+    text: context => context.sourceMessage,
+    level: `ERROR`,
+    type: `PLUGIN`
+  },
+  [CODES.MissingResource]: {
+    text: context => context.sourceMessage,
+    level: `ERROR`,
+    type: `PLUGIN`,
+    category: `USER`
+  }
+};
+exports.ERROR_MAP = ERROR_MAP;

package/extend-file-node.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const {
+  GraphQLString
+} = require(`gatsby/graphql`);
+
+const fs = require(`fs-extra`);
+
+const path = require(`path`);
+
+const {
+  prefixId,
+  CODES
+} = require(`./error-utils`);
+
+module.exports = ({
+  type,
+  getNodeAndSavePathDependency,
+  pathPrefix = ``,
+  reporter
+}) => {
+  if (type.name !== `File`) {
+    return {};
+  }
+
+  return {
+    publicURL: {
+      type: GraphQLString,
+      args: {},
+      description: `Copy file to static directory and return public url to it`,
+      resolve: (file, fieldArgs, context) => {
+        const details = getNodeAndSavePathDependency(file.id, context.path);
+        const fileName = `${file.internal.contentDigest}/${details.base}`;
+        const publicPath = path.join(process.cwd(), `public`, `static`, fileName);
+
+        if (!fs.existsSync(publicPath)) {
+          fs.copySync(details.absolutePath, publicPath, {
+            dereference: true
+          }, err => {
+            if (err) {
+              reporter.panic({
+                id: prefixId(CODES.MissingResource),
+                context: {
+                  sourceMessage: `error copying file from ${details.absolutePath} to ${publicPath}`
+                }
+              }, err);
+            }
+          });
+        }
+
+        return `${pathPrefix}/static/${fileName}`;
+      }
+    }
+  };
+};

package/gatsby-node.js

@@ -0,0 +1,277 @@
+"use strict";
+
+const chokidar = require(`chokidar`);
+
+const fs = require(`fs`);
+
+const path = require(`path`);
+
+const {
+  Machine,
+  interpret
+} = require(`xstate`);
+
+const {
+  createFileNode
+} = require(`./create-file-node`);
+
+const {
+  ERROR_MAP
+} = require(`./error-utils`);
+
+exports.onPreInit = ({
+  reporter
+}) => {
+  if (reporter.setErrorMap) {
+    reporter.setErrorMap(ERROR_MAP);
+  }
+};
+/**
+ * Create a state machine to manage Chokidar's not-ready/ready states.
+ */
+
+
+const createFSMachine = ({
+  actions: {
+    createNode,
+    deleteNode
+  },
+  getNode,
+  createNodeId,
+  reporter
+}, pluginOptions) => {
+  const createAndProcessNode = path => {
+    const fileNodePromise = createFileNode(path, createNodeId, pluginOptions).then(fileNode => {
+      createNode(fileNode);
+      return null;
+    });
+    return fileNodePromise;
+  };
+
+  const deletePathNode = path => {
+    const node = getNode(createNodeId(path)); // It's possible the node was never created as sometimes tools will
+    // write and then immediately delete temporary files to the file system.
+
+    if (node) {
+      deleteNode(node);
+    }
+  }; // For every path that is reported before the 'ready' event, we throw them
+  // into a queue and then flush the queue when 'ready' event arrives.
+  // After 'ready', we handle the 'add' event without putting it into a queue.
+
+
+  let pathQueue = [];
+
+  const flushPathQueue = () => {
+    const queue = pathQueue.slice();
+    pathQueue = null;
+    return Promise.all( // eslint-disable-next-line consistent-return
+    queue.map(({
+      op,
+      path
+    }) => {
+      switch (op) {
+        case `delete`:
+          return deletePathNode(path);
+
+        case `upsert`:
+          return createAndProcessNode(path);
+      }
+    }));
+  };
+
+  const log = expr => (ctx, action, meta) => {
+    if (meta.state.matches(`BOOTSTRAP.BOOTSTRAPPED`)) {
+      reporter.info(expr(ctx, action, meta));
+    }
+  };
+
+  const fsMachine = Machine({
+    id: `fs`,
+    type: `parallel`,
+    states: {
+      BOOTSTRAP: {
+        initial: `BOOTSTRAPPING`,
+        states: {
+          BOOTSTRAPPING: {
+            on: {
+              BOOTSTRAP_FINISHED: `BOOTSTRAPPED`
+            }
+          },
+          BOOTSTRAPPED: {
+            type: `final`
+          }
+        }
+      },
+      CHOKIDAR: {
+        initial: `NOT_READY`,
+        states: {
+          NOT_READY: {
+            on: {
+              CHOKIDAR_READY: `READY`,
+              CHOKIDAR_ADD: {
+                actions: `queueNodeProcessing`
+              },
+              CHOKIDAR_CHANGE: {
+                actions: `queueNodeProcessing`
+              },
+              CHOKIDAR_UNLINK: {
+                actions: `queueNodeDeleting`
+              }
+            },
+            exit: `flushPathQueue`
+          },
+          READY: {
+            on: {
+              CHOKIDAR_ADD: {
+                actions: [`createAndProcessNode`, log((_, {
+                  pathType,
+                  path
+                }) => `added ${pathType} at ${path}`)]
+              },
+              CHOKIDAR_CHANGE: {
+                actions: [`createAndProcessNode`, log((_, {
+                  pathType,
+                  path
+                }) => `changed ${pathType} at ${path}`)]
+              },
+              CHOKIDAR_UNLINK: {
+                actions: [`deletePathNode`, log((_, {
+                  pathType,
+                  path
+                }) => `deleted ${pathType} at ${path}`)]
+              }
+            }
+          }
+        }
+      }
+    }
+  }, {
+    actions: {
+      createAndProcessNode(_, {
+        pathType,
+        path
+      }) {
+        createAndProcessNode(path).catch(err => reporter.error(err));
+      },
+
+      deletePathNode(_, {
+        pathType,
+        path
+      }, {
+        state
+      }) {
+        deletePathNode(path);
+      },
+
+      flushPathQueue(_, {
+        resolve,
+        reject
+      }) {
+        flushPathQueue().then(resolve, reject);
+      },
+
+      queueNodeDeleting(_, {
+        path
+      }) {
+        pathQueue.push({
+          op: `delete`,
+          path
+        });
+      },
+
+      queueNodeProcessing(_, {
+        path
+      }) {
+        pathQueue.push({
+          op: `upsert`,
+          path
+        });
+      }
+
+    }
+  });
+  return interpret(fsMachine).start();
+};
+
+exports.pluginOptionsSchema = ({
+  Joi
+}) => Joi.object({
+  name: Joi.string(),
+  path: Joi.string(),
+  ignore: Joi.array().items(Joi.string(), Joi.object().regex(), Joi.function())
+});
+
+exports.sourceNodes = (api, pluginOptions) => {
+  // Validate that the path exists.
+  if (!fs.existsSync(pluginOptions.path)) {
+    api.reporter.panic(`
+The path passed to gatsby-source-filesystem does not exist on your file system:
+${pluginOptions.path}
+Please pick a path to an existing directory.
+See docs here - https://www.gatsbyjs.com/plugins/gatsby-source-filesystem/
+      `);
+  } // Validate that the path is absolute.
+  // Absolute paths are required to resolve images correctly.
+
+
+  if (!path.isAbsolute(pluginOptions.path)) {
+    pluginOptions.path = path.resolve(process.cwd(), pluginOptions.path);
+  }
+
+  const fsMachine = createFSMachine(api, pluginOptions); // Once bootstrap is finished, we only let one File node update go through
+  // the system at a time.
+
+  api.emitter.on(`BOOTSTRAP_FINISHED`, () => {
+    fsMachine.send(`BOOTSTRAP_FINISHED`);
+  });
+  const watcher = chokidar.watch(pluginOptions.path, {
+    ignored: [`**/*.un~`, `**/.DS_Store`, `**/.gitignore`, `**/.npmignore`, `**/.babelrc`, `**/yarn.lock`, `**/bower_components`, `**/node_modules`, `../**/dist/**`, ...(pluginOptions.ignore || [])]
+  });
+  watcher.on(`add`, path => {
+    fsMachine.send({
+      type: `CHOKIDAR_ADD`,
+      pathType: `file`,
+      path
+    });
+  });
+  watcher.on(`change`, path => {
+    fsMachine.send({
+      type: `CHOKIDAR_CHANGE`,
+      pathType: `file`,
+      path
+    });
+  });
+  watcher.on(`unlink`, path => {
+    fsMachine.send({
+      type: `CHOKIDAR_UNLINK`,
+      pathType: `file`,
+      path
+    });
+  });
+  watcher.on(`addDir`, path => {
+    fsMachine.send({
+      type: `CHOKIDAR_ADD`,
+      pathType: `directory`,
+      path
+    });
+  });
+  watcher.on(`unlinkDir`, path => {
+    fsMachine.send({
+      type: `CHOKIDAR_UNLINK`,
+      pathType: `directory`,
+      path
+    });
+  });
+  return new Promise((resolve, reject) => {
+    watcher.on(`ready`, () => {
+      fsMachine.send({
+        type: `CHOKIDAR_READY`,
+        resolve,
+        reject
+      });
+    });
+  });
+};
+
+exports.setFieldsOnGraphQLNodeType = require(`./extend-file-node`);

package/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+const fs = require(`fs-extra`);
+
+function loadNodeContent(fileNode) {
+  return fs.readFile(fileNode.absolutePath, `utf-8`);
+}
+
+exports.createFilePath = require(`./create-file-path`);
+exports.createRemoteFileNode = require(`./create-remote-file-node`);
+exports.createFileNodeFromBuffer = require(`./create-file-node-from-buffer`);
+exports.loadNodeContent = loadNodeContent;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gatsby-source-filesystem",
   "description": "Gatsby source plugin for building websites from local data. Markdown, JSON, images, YAML, CSV, and dozens of other data types supported.",
-  "version": "4.12.0",
+  "version": "4.12.1",
   "author": "Kyle Mathews <mathews.kyle@gmail.com>",
   "bugs": {
     "url": "https://github.com/gatsbyjs/gatsby/issues"
@@ -11,7 +11,7 @@
     "chokidar": "^3.5.2",
     "file-type": "^16.5.3",
     "fs-extra": "^10.0.0",
-    "gatsby-core-utils": "^3.12.0",
+    "gatsby-core-utils": "^3.12.1",
     "got": "^9.6.0",
     "md5-file": "^5.0.0",
     "mime": "^2.5.2",
@@ -23,7 +23,7 @@
   "devDependencies": {
     "@babel/cli": "^7.15.4",
     "@babel/core": "^7.15.5",
-    "babel-preset-gatsby-package": "^2.12.0",
+    "babel-preset-gatsby-package": "^2.12.1",
     "cross-env": "^7.0.3"
   },
   "homepage": "https://github.com/gatsbyjs/gatsby/tree/master/packages/gatsby-source-filesystem#readme",
@@ -49,5 +49,5 @@
   "engines": {
     "node": ">=14.15.0"
   },
-  "gitHead": "12e90fce284eb0a64b7d1f15e293027483826372"
+  "gitHead": "4765c4514325cf1d4bd209854fd974ba56e8a751"
 }

package/utils.js

@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getRemoteFileExtension = getRemoteFileExtension;
+exports.getRemoteFileName = getRemoteFileName;
+exports.createFilePath = void 0;
+
+const path = require(`path`);
+
+const Url = require(`url`);
+
+const {
+  createFilePath
+} = require(`gatsby-core-utils`);
+/**
+ * getParsedPath
+ * --
+ * Parses remote url to a path object
+ *
+ *
+ * @param  {String}          url
+ * @return {Object}          path
+ */
+
+
+exports.createFilePath = createFilePath;
+
+function getParsedPath(url) {
+  return path.parse(Url.parse(url).pathname);
+}
+/**
+ * getRemoteFileExtension
+ * --
+ * Parses remote url to retrieve remote file extension
+ *
+ *
+ * @param  {String}          url
+ * @return {String}          extension
+ */
+
+
+function getRemoteFileExtension(url) {
+  return getParsedPath(url).ext;
+}
+/**
+ * getRemoteFileName
+ * --
+ * Parses remote url to retrieve remote file name
+ *
+ *
+ * @param  {String}          url
+ * @return {String}          filename
+ */
+
+
+function getRemoteFileName(url) {
+  return getParsedPath(url).name;
+} // createFilePath should be imported from `gatsby-core-utils`
+// but some plugins already do import it from `gatsby-source-filesystem/utils`
+// so just keeping re-export here for backward compatibility