gatsby-adapter-netlify/dist/index.js

Gatsby adapter for Netlify

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
exports.__esModule = true;
exports.default = void 0;
var _path = require("path");
var _lambdaHandler = require("./lambda-handler");
var _fileCdnHandler = require("./file-cdn-handler");
var _routeHandler = require("./route-handler");
var _package = _interopRequireDefault(require("gatsby-adapter-netlify/package.json"));
var _allowedRemoteUrls = require("./allowed-remote-urls");
let _cacheUtils;
async function getCacheUtils() {
  if (_cacheUtils) {
    return _cacheUtils;
  }
  let CACHE_DIR;
  if (process.env.NETLIFY_LOCAL) {
    CACHE_DIR = (0, _path.join)(process.cwd(), `.netlify`, `build-cache`);
  } else if (process.env.NETLIFY) {
    CACHE_DIR = `/opt/build/cache`;
  }
  if (CACHE_DIR) {
    _cacheUtils = (await import(`@netlify/cache-utils`)).bindOpts({
      cacheDir: CACHE_DIR
    });
    return _cacheUtils;
  }
  return undefined;
}
const createNetlifyAdapter = options => {
  let useNetlifyImageCDN = options === null || options === void 0 ? void 0 : options.imageCDN;
  if (typeof useNetlifyImageCDN === `undefined` && typeof process.env.NETLIFY_IMAGE_CDN !== `undefined`) {
    useNetlifyImageCDN = process.env.NETLIFY_IMAGE_CDN === `true` || process.env.NETLIFY_IMAGE_CDN === `1`;
  }
  return {
    name: `gatsby-adapter-netlify`,
    cache: {
      async restore({
        directories,
        reporter
      }) {
        const utils = await getCacheUtils();
        if (utils) {
          reporter.verbose(`[gatsby-adapter-netlify] using @netlify/cache-utils restore`);
          const didRestore = await utils.restore(directories);
          if (didRestore) {
            reporter.info(`[gatsby-adapter-netlify] Found a Gatsby cache. We're about to go FAST. ⚡`);
          }
          return didRestore;
        }
        return false;
      },
      async store({
        directories,
        reporter
      }) {
        const utils = await getCacheUtils();
        if (utils) {
          reporter.verbose(`[gatsby-adapter-netlify] using @netlify/cache-utils save`);
          await utils.save(directories);
          reporter.info(`[gatsby-adapter-netlify] Stored the Gatsby cache to speed up future builds. 🔥`);
        }
      }
    },
    async adapt({
      routesManifest,
      functionsManifest,
      headerRoutes,
      pathPrefix,
      remoteFileAllowedUrls,
      reporter
    }) {
      if (useNetlifyImageCDN) {
        await (0, _allowedRemoteUrls.handleAllowedRemoteUrlsNetlifyConfig)({
          remoteFileAllowedUrls,
          reporter
        });
        await (0, _fileCdnHandler.prepareFileCdnHandler)({
          pathPrefix,
          remoteFileAllowedUrls
        });
      }
      const {
        lambdasThatUseCaching
      } = await (0, _routeHandler.handleRoutesManifest)(routesManifest, headerRoutes);

      // functions handling
      for (const fun of functionsManifest) {
        await (0, _lambdaHandler.prepareFunctionVariants)(fun, lambdasThatUseCaching.get(fun.functionId));
      }
    },
    config: ({
      reporter
    }) => {
      var _packageJson$version;
      reporter.verbose(`[gatsby-adapter-netlify] version: ${(_packageJson$version = _package.default === null || _package.default === void 0 ? void 0 : _package.default.version) !== null && _packageJson$version !== void 0 ? _packageJson$version : `unknown`}`);
      // excludeDatastoreFromEngineFunction can be enabled either via options or via env var (to preserve handling of env var that existed in Netlify build plugin).
      let excludeDatastoreFromEngineFunction = options === null || options === void 0 ? void 0 : options.excludeDatastoreFromEngineFunction;
      if (typeof excludeDatastoreFromEngineFunction === `undefined` && typeof process.env.GATSBY_EXCLUDE_DATASTORE_FROM_BUNDLE !== `undefined`) {
        excludeDatastoreFromEngineFunction = process.env.GATSBY_EXCLUDE_DATASTORE_FROM_BUNDLE === `true` || process.env.GATSBY_EXCLUDE_DATASTORE_FROM_BUNDLE === `1`;
      }
      if (typeof excludeDatastoreFromEngineFunction === `undefined`) {
        excludeDatastoreFromEngineFunction = false;
      }
      const deployURL = process.env.NETLIFY_LOCAL ? `http://localhost:8888` : process.env.DEPLOY_URL;
      if (excludeDatastoreFromEngineFunction && !deployURL) {
        reporter.warn(`[gatsby-adapter-netlify] excludeDatastoreFromEngineFunction is set to true but no DEPLOY_URL is set. Disabling excludeDatastoreFromEngineFunction.`);
        excludeDatastoreFromEngineFunction = false;
      }
      return {
        excludeDatastoreFromEngineFunction,
        deployURL,
        supports: {
          pathPrefix: true,
          trailingSlash: [`always`, `never`, `ignore`]
        },
        pluginsToDisable: [`gatsby-plugin-netlify-cache`, `gatsby-plugin-netlify`],
        imageCDNUrlGeneratorModulePath: useNetlifyImageCDN ? require.resolve(`./image-cdn-url-generator`) : undefined,
        fileCDNUrlGeneratorModulePath: useNetlifyImageCDN ? require.resolve(`./file-cdn-url-generator`) : undefined,
        functionsPlatform: `linux`,
        functionsArch: `x64`
      };
    }
  };
};
var _default = createNetlifyAdapter;
exports.default = _default;