@netlify/plugin-nextjs 5.10.0 → 5.10.2

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2023 Netlify <team@netlify.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/build/advanced-api-routes.js

@@ -5,10 +5,142 @@
       })();
     
 import {
-  ApiRouteType,
-  getAPIRoutesConfigs
-} from "../esm-chunks/chunk-ZENB67PD.js";
-import "../esm-chunks/chunk-OEQOKJGE.js";
+  __require
+} from "../esm-chunks/chunk-OEQOKJGE.js";
+
+// src/build/advanced-api-routes.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var ApiRouteType = /* @__PURE__ */ ((ApiRouteType2) => {
+  ApiRouteType2["SCHEDULED"] = "experimental-scheduled";
+  ApiRouteType2["BACKGROUND"] = "experimental-background";
+  return ApiRouteType2;
+})(ApiRouteType || {});
+async function getAPIRoutesConfigs(ctx) {
+  const uniqueApiRoutes = /* @__PURE__ */ new Set();
+  const functionsConfigManifestPath = join(
+    ctx.publishDir,
+    "server",
+    "functions-config-manifest.json"
+  );
+  if (existsSync(functionsConfigManifestPath)) {
+    const functionsConfigManifest = JSON.parse(
+      await readFile(functionsConfigManifestPath, "utf-8")
+    );
+    for (const apiRoute of Object.keys(functionsConfigManifest.functions)) {
+      uniqueApiRoutes.add(apiRoute);
+    }
+  }
+  const pagesManifestPath = join(ctx.publishDir, "server", "pages-manifest.json");
+  if (existsSync(pagesManifestPath)) {
+    const pagesManifest = JSON.parse(await readFile(pagesManifestPath, "utf-8"));
+    for (const route of Object.keys(pagesManifest)) {
+      if (route.startsWith("/api/")) {
+        uniqueApiRoutes.add(route);
+      }
+    }
+  }
+  if (uniqueApiRoutes.size === 0) {
+    return [];
+  }
+  const appDir = ctx.resolveFromSiteDir(".");
+  const pagesDir = join(appDir, "pages");
+  const srcPagesDir = join(appDir, "src", "pages");
+  const { pageExtensions } = ctx.requiredServerFiles.config;
+  return Promise.all(
+    [...uniqueApiRoutes].map(async (apiRoute) => {
+      const filePath = getSourceFileForPage(apiRoute, [pagesDir, srcPagesDir], pageExtensions);
+      const sharedFields = {
+        apiRoute,
+        filePath,
+        config: {}
+      };
+      if (filePath) {
+        const config = await extractConfigFromFile(filePath, appDir);
+        return {
+          ...sharedFields,
+          config
+        };
+      }
+      return sharedFields;
+    })
+  );
+}
+var SOURCE_FILE_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
+var getSourceFileForPage = (page, roots, pageExtensions = SOURCE_FILE_EXTENSIONS) => {
+  for (const root of roots) {
+    for (const extension of pageExtensions) {
+      const file = join(root, `${page}.${extension}`);
+      if (existsSync(file)) {
+        return file;
+      }
+      const fileAtFolderIndex = join(root, page, `index.${extension}`);
+      if (existsSync(fileAtFolderIndex)) {
+        return fileAtFolderIndex;
+      }
+    }
+  }
+};
+var findModuleFromBase = ({
+  paths,
+  candidates
+}) => {
+  for (const candidate of candidates) {
+    try {
+      const modulePath = __require.resolve(candidate, { paths });
+      if (modulePath) {
+        return modulePath;
+      }
+    } catch {
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      const modulePath = __require.resolve(candidate);
+      if (modulePath) {
+        return modulePath;
+      }
+    } catch {
+    }
+  }
+  return null;
+};
+var extractConstValue;
+var parseModule;
+var extractConfigFromFile = async (apiFilePath, appDir) => {
+  if (!apiFilePath || !existsSync(apiFilePath)) {
+    return {};
+  }
+  const extractConstValueModulePath = findModuleFromBase({
+    paths: [appDir],
+    candidates: ["next/dist/build/analysis/extract-const-value"]
+  });
+  const parseModulePath = findModuleFromBase({
+    paths: [appDir],
+    candidates: ["next/dist/build/analysis/parse-module"]
+  });
+  if (!extractConstValueModulePath || !parseModulePath) {
+    return {};
+  }
+  if (!extractConstValue && extractConstValueModulePath) {
+    extractConstValue = __require(extractConstValueModulePath);
+  }
+  if (!parseModule && parseModulePath) {
+    parseModule = __require(parseModulePath).parseModule;
+  }
+  const { extractExportedConstValue } = extractConstValue;
+  const fileContent = await readFile(apiFilePath, "utf8");
+  if (!fileContent.includes("config")) {
+    return {};
+  }
+  const ast = await parseModule(apiFilePath, fileContent);
+  try {
+    return extractExportedConstValue(ast, "config");
+  } catch {
+    return {};
+  }
+};
 export {
   ApiRouteType,
   getAPIRoutesConfigs

package/dist/build/cache.js

@@ -4,11 +4,32 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  restoreBuildCache,
-  saveBuildCache
-} from "../esm-chunks/chunk-72ZI2IVI.js";
 import "../esm-chunks/chunk-OEQOKJGE.js";
+
+// src/build/cache.ts
+import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+var saveBuildCache = async (ctx) => {
+  const { cache } = ctx.utils;
+  const cacheDir = join(ctx.publishDir, "cache");
+  if (existsSync(cacheDir)) {
+    await rm(join(cacheDir, "fetch-cache"), { recursive: true, force: true });
+    await cache.save(cacheDir);
+    console.log("Next.js cache saved");
+  } else {
+    console.log("No Next.js cache to save");
+  }
+};
+var restoreBuildCache = async (ctx) => {
+  const { cache } = ctx.utils;
+  const cacheDir = join(ctx.publishDir, "cache");
+  if (await cache.restore(cacheDir)) {
+    console.log("Next.js cache restored");
+  } else {
+    console.log("No Next.js cache to restore");
+  }
+};
 export {
   restoreBuildCache,
   saveBuildCache

package/dist/build/content/prerendered.js

@@ -5,17 +5,299 @@
       })();
     
 import {
-  copyFetchContent,
-  copyPrerenderedContent
-} from "../../esm-chunks/chunk-DLBTTDNJ.js";
-import "../../esm-chunks/chunk-5QSXBV7L.js";
-import "../../esm-chunks/chunk-GNGHTHMQ.js";
-import "../../esm-chunks/chunk-ZSVHJNNY.js";
-import "../../esm-chunks/chunk-KGYJQ2U2.js";
-import "../../esm-chunks/chunk-ZENB67PD.js";
-import "../../esm-chunks/chunk-APO262HE.js";
-import "../../esm-chunks/chunk-TYCYFZ22.js";
-import "../../esm-chunks/chunk-OEQOKJGE.js";
+  wrapTracer
+} from "../../esm-chunks/chunk-5QSXBV7L.js";
+import {
+  init_esm,
+  trace
+} from "../../esm-chunks/chunk-GNGHTHMQ.js";
+import {
+  require_out
+} from "../../esm-chunks/chunk-KGYJQ2U2.js";
+import {
+  require_semver
+} from "../../esm-chunks/chunk-APO262HE.js";
+import {
+  __toESM
+} from "../../esm-chunks/chunk-OEQOKJGE.js";
+
+// src/build/content/prerendered.ts
+init_esm();
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var import_fast_glob = __toESM(require_out(), 1);
+
+// node_modules/yocto-queue/index.js
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+
+// node_modules/p-limit/index.js
+import { AsyncResource } from "async_hooks";
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (function_, resolve, arguments_) => {
+    activeCount++;
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve, arguments_) => {
+    queue.enqueue(
+      AsyncResource.bind(run.bind(void 0, function_, resolve, arguments_))
+    );
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve) => {
+    enqueue(function_, resolve, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// src/build/content/prerendered.ts
+var import_semver = __toESM(require_semver(), 1);
+import { encodeBlobKey } from "../../shared/blobkey.js";
+import { verifyNetlifyForms } from "../verification.js";
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var writeCacheEntry = async (route, value, lastModified, ctx) => {
+  const path = join(ctx.blobDir, await encodeBlobKey(route));
+  const entry = JSON.stringify({
+    lastModified,
+    value
+  });
+  await writeFile(path, entry, "utf-8");
+};
+var routeToFilePath = (path) => {
+  if (path === "/") {
+    return "/index";
+  }
+  if (path.startsWith("/")) {
+    return path;
+  }
+  return `/${path}`;
+};
+var buildPagesCacheValue = async (path, initialRevalidateSeconds, shouldUseEnumKind, shouldSkipJson = false) => ({
+  kind: shouldUseEnumKind ? "PAGES" : "PAGE",
+  html: await readFile(`${path}.html`, "utf-8"),
+  pageData: shouldSkipJson ? {} : JSON.parse(await readFile(`${path}.json`, "utf-8")),
+  headers: void 0,
+  status: void 0,
+  revalidate: initialRevalidateSeconds
+});
+var buildAppCacheValue = async (path, shouldUseAppPageKind) => {
+  const meta = JSON.parse(await readFile(`${path}.meta`, "utf-8"));
+  const html = await readFile(`${path}.html`, "utf-8");
+  if (shouldUseAppPageKind) {
+    return {
+      kind: "APP_PAGE",
+      html,
+      rscData: await readFile(`${path}.rsc`, "base64").catch(
+        () => readFile(`${path}.prefetch.rsc`, "base64")
+      ),
+      ...meta
+    };
+  }
+  const rsc = await readFile(`${path}.rsc`, "utf-8").catch(
+    () => readFile(`${path}.prefetch.rsc`, "utf-8")
+  );
+  if (!meta.status && rsc.includes("NEXT_NOT_FOUND") && !meta.headers["x-next-cache-tags"].includes("/@")) {
+    meta.status = 404;
+  }
+  return {
+    kind: "PAGE",
+    html,
+    pageData: rsc,
+    ...meta
+  };
+};
+var buildRouteCacheValue = async (path, initialRevalidateSeconds, shouldUseEnumKind) => ({
+  kind: shouldUseEnumKind ? "APP_ROUTE" : "ROUTE",
+  body: await readFile(`${path}.body`, "base64"),
+  ...JSON.parse(await readFile(`${path}.meta`, "utf-8")),
+  revalidate: initialRevalidateSeconds
+});
+var buildFetchCacheValue = async (path) => ({
+  kind: "FETCH",
+  ...JSON.parse(await readFile(path, "utf-8"))
+});
+var copyPrerenderedContent = async (ctx) => {
+  return tracer.withActiveSpan("copyPrerenderedContent", async () => {
+    try {
+      await mkdir(ctx.blobDir, { recursive: true });
+      const manifest = await ctx.getPrerenderManifest();
+      const limitConcurrentPrerenderContentHandling = pLimit(10);
+      const shouldUseAppPageKind = ctx.nextVersion ? (0, import_semver.satisfies)(ctx.nextVersion, ">=15.0.0-canary.13 <15.0.0-d || >15.0.0-rc.0", {
+        includePrerelease: true
+      }) : false;
+      const shouldUseEnumKind = ctx.nextVersion ? (0, import_semver.satisfies)(ctx.nextVersion, ">=15.0.0-canary.114 <15.0.0-d || >15.0.0-rc.0", {
+        includePrerelease: true
+      }) : false;
+      await Promise.all([
+        ...Object.entries(manifest.routes).map(
+          ([route, meta]) => limitConcurrentPrerenderContentHandling(async () => {
+            const lastModified = meta.initialRevalidateSeconds ? Date.now() - 31536e6 : Date.now();
+            const key = routeToFilePath(route);
+            let value;
+            switch (true) {
+              // Parallel route default layout has no prerendered page
+              case (meta.dataRoute?.endsWith("/default.rsc") && !existsSync(join(ctx.publishDir, "server/app", `${key}.html`))):
+                return;
+              case meta.dataRoute?.endsWith(".json"):
+                if (manifest.notFoundRoutes.includes(route)) {
+                  return;
+                }
+                value = await buildPagesCacheValue(
+                  join(ctx.publishDir, "server/pages", key),
+                  meta.initialRevalidateSeconds,
+                  shouldUseEnumKind
+                );
+                break;
+              case meta.dataRoute?.endsWith(".rsc"):
+                value = await buildAppCacheValue(
+                  join(ctx.publishDir, "server/app", key),
+                  shouldUseAppPageKind
+                );
+                break;
+              case meta.dataRoute === null:
+                value = await buildRouteCacheValue(
+                  join(ctx.publishDir, "server/app", key),
+                  meta.initialRevalidateSeconds,
+                  shouldUseEnumKind
+                );
+                break;
+              default:
+                throw new Error(`Unrecognized content: ${route}`);
+            }
+            if (value.kind === "PAGE" || value.kind === "PAGES" || value.kind === "APP_PAGE") {
+              verifyNetlifyForms(ctx, value.html);
+            }
+            await writeCacheEntry(key, value, lastModified, ctx);
+          })
+        ),
+        ...ctx.getFallbacks(manifest).map(async (route) => {
+          const key = routeToFilePath(route);
+          const value = await buildPagesCacheValue(
+            join(ctx.publishDir, "server/pages", key),
+            void 0,
+            shouldUseEnumKind,
+            true
+            // there is no corresponding json file for fallback, so we are skipping it for this entry
+          );
+          await writeCacheEntry(key, value, Date.now(), ctx);
+        })
+      ]);
+      if (existsSync(join(ctx.publishDir, `server/app/_not-found.html`))) {
+        const lastModified = Date.now();
+        const key = "/404";
+        const value = await buildAppCacheValue(
+          join(ctx.publishDir, "server/app/_not-found"),
+          shouldUseAppPageKind
+        );
+        await writeCacheEntry(key, value, lastModified, ctx);
+      }
+    } catch (error) {
+      ctx.failBuild("Failed assembling prerendered content for upload", error);
+    }
+  });
+};
+var copyFetchContent = async (ctx) => {
+  try {
+    const paths = await (0, import_fast_glob.glob)(["!(*.*)"], {
+      cwd: join(ctx.publishDir, "cache/fetch-cache"),
+      extglob: true
+    });
+    await Promise.all(
+      paths.map(async (key) => {
+        const lastModified = Date.now() - 31536e6;
+        const path = join(ctx.publishDir, "cache/fetch-cache", key);
+        const value = await buildFetchCacheValue(path);
+        await writeCacheEntry(key, value, lastModified, ctx);
+      })
+    );
+  } catch (error) {
+    ctx.failBuild("Failed assembling fetch content for upload", error);
+  }
+};
 export {
   copyFetchContent,
   copyPrerenderedContent