@opennextjs/aws 3.7.5 → 3.7.6

package/dist/build/createAssets.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { loadConfig } from "../adapters/config/util.js";
+import { safeParseJsonFile } from "../utils/safe-json-parse.js";
 import logger from "../logger.js";
 import { isBinaryContentType } from "../utils/binary.js";
 import * as buildHelper from "./helper.js";
@@ -106,15 +107,20 @@ export function createCacheAssets(options) {
     // Generate cache file
     Object.entries(cacheFilesPath).forEach(([cacheFilePath, files]) => {
         const cacheFileMeta = files.meta
-            ? JSON.parse(fs.readFileSync(files.meta, "utf8"))
+            ? safeParseJsonFile(fs.readFileSync(files.meta, "utf8"), cacheFilePath)
             : undefined;
+        const cacheJson = files.json
+            ? safeParseJsonFile(fs.readFileSync(files.json, "utf8"), cacheFilePath)
+            : undefined;
+        if ((files.meta && !cacheFileMeta) || (files.json && !cacheJson)) {
+            logger.warn(`Skipping invalid cache file: ${cacheFilePath}`);
+            return;
+        }
         const cacheFileContent = {
             type: files.body ? "route" : files.json ? "page" : "app",
             meta: cacheFileMeta,
             html: files.html ? fs.readFileSync(files.html, "utf8") : undefined,
-            json: files.json
-                ? JSON.parse(fs.readFileSync(files.json, "utf8"))
-                : undefined,
+            json: cacheJson,
             rsc: files.rsc ? fs.readFileSync(files.rsc, "utf8") : undefined,
             body: files.body
                 ? fs
@@ -138,7 +144,7 @@ export function createCacheAssets(options) {
         fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
         buildHelper.traverseFiles(fetchCachePath, () => true, ({ absolutePath, relativePath }) => {
             const fileContent = fs.readFileSync(absolutePath, "utf8");
-            const fileData = JSON.parse(fileContent);
+            const fileData = safeParseJsonFile(fileContent, absolutePath);
             fileData?.tags?.forEach((tag) => {
                 metaFiles.push({
                     tag: { S: path.posix.join(buildId, tag) },
@@ -156,8 +162,8 @@ export function createCacheAssets(options) {
         sourceDirs.forEach((sourceDir) => {
             buildHelper.traverseFiles(sourceDir, ({ absolutePath, relativePath }) => absolutePath.endsWith(".meta") && !isFileSkipped(relativePath), ({ absolutePath, relativePath }) => {
                 const fileContent = fs.readFileSync(absolutePath, "utf8");
-                const fileData = JSON.parse(fileContent);
-                if (fileData.headers?.["x-next-cache-tags"]) {
+                const fileData = safeParseJsonFile(fileContent, absolutePath);
+                if (fileData?.headers?.["x-next-cache-tags"]) {
                     fileData.headers["x-next-cache-tags"]
                         .split(",")
                         .forEach((tag) => {

package/dist/build/createImageOptimizationBundle.js

@@ -76,7 +76,8 @@ export async function createImageOptimizationBundle(options) {
     const sharpVersion = process.env.SHARP_VERSION ?? "0.32.6";
     installDependencies(outputPath, config.imageOptimization?.install ?? {
         packages: [`sharp@${sharpVersion}`],
-        arch: "arm64",
+        // By not specifying an arch, `npm install` will choose one for us (i.e. our system one)
+        arch: config.imageOptimization?.loader === "fs-dev" ? undefined : "arm64",
         nodeVersion: "18",
         libc: "glibc",
     });

package/dist/core/routing/cacheInterceptor.js

@@ -175,7 +175,8 @@ export async function cacheInterceptor(event) {
                 return event;
             }
             // We need to check the tag cache now
-            if (cachedData.value?.type === "app") {
+            if (cachedData.value?.type === "app" ||
+                cachedData.value?.type === "route") {
                 const tags = getTagsFromValue(cachedData.value);
                 const _hasBeenRevalidated = await hasBeenRevalidated(localizedPath, tags, cachedData);
                 if (_hasBeenRevalidated) {

package/dist/overrides/tagCache/fs-dev-nextMode.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    name: string;
+    mode: "nextMode";
+    getLastRevalidated: (tags: string[]) => Promise<number>;
+    hasBeenRevalidated: (tags: string[], lastModified?: number) => Promise<boolean>;
+    writeTags: (tags: string[]) => Promise<void>;
+};
+export default _default;

package/dist/overrides/tagCache/fs-dev-nextMode.js

@@ -0,0 +1,42 @@
+import { debug } from "../../adapters/logger";
+const tagsMap = new Map();
+export default {
+    name: "fs-dev-nextMode",
+    mode: "nextMode",
+    getLastRevalidated: async (tags) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+            return 0;
+        }
+        let lastRevalidated = 0;
+        tags.forEach((tag) => {
+            const tagTime = tagsMap.get(tag);
+            if (tagTime && tagTime > lastRevalidated) {
+                lastRevalidated = tagTime;
+            }
+        });
+        debug("getLastRevalidated result:", lastRevalidated);
+        return lastRevalidated;
+    },
+    hasBeenRevalidated: async (tags, lastModified) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+            return false;
+        }
+        const hasRevalidatedTag = tags.some((tag) => {
+            const tagRevalidatedAt = tagsMap.get(tag);
+            return tagRevalidatedAt ? tagRevalidatedAt > (lastModified ?? 0) : false;
+        });
+        debug("hasBeenRevalidated result:", hasRevalidatedTag);
+        return hasRevalidatedTag;
+    },
+    writeTags: async (tags) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache ||
+            tags.length === 0) {
+            return;
+        }
+        debug("writeTags", { tags: tags });
+        tags.forEach((tag) => {
+            tagsMap.set(tag, Date.now());
+        });
+        debug("writeTags completed, written", tags.length, "tags");
+    },
+};

package/dist/overrides/tagCache/fs-dev.js

@@ -4,31 +4,35 @@ import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const tagFile = path.join(getMonorepoRelativePath(), "dynamodb-provider/dynamodb-cache.json");
 const tagContent = fs.readFileSync(tagFile, "utf-8");
 let tags = JSON.parse(tagContent);
+const { NEXT_BUILD_ID } = process.env;
+function buildKey(key) {
+    return path.posix.join(NEXT_BUILD_ID ?? "", key);
+}
 const tagCache = {
     name: "fs-dev",
     mode: "original",
     getByPath: async (path) => {
         return tags
-            .filter((tagPathMapping) => tagPathMapping.path.S === path)
-            .map((tag) => tag.tag.S);
+            .filter((tagPathMapping) => tagPathMapping.path.S === buildKey(path))
+            .map((tag) => tag.tag.S.replace(`${NEXT_BUILD_ID}/`, ""));
     },
     getByTag: async (tag) => {
         return tags
-            .filter((tagPathMapping) => tagPathMapping.tag.S === tag)
-            .map((tag) => tag.path.S);
+            .filter((tagPathMapping) => tagPathMapping.tag.S === buildKey(tag))
+            .map((tagEntry) => tagEntry.path.S.replace(`${NEXT_BUILD_ID}/`, ""));
     },
     getLastModified: async (path, lastModified) => {
-        const revalidatedTags = tags.filter((tagPathMapping) => tagPathMapping.path.S === path &&
+        const revalidatedTags = tags.filter((tagPathMapping) => tagPathMapping.path.S === buildKey(path) &&
             Number.parseInt(tagPathMapping.revalidatedAt.N) > (lastModified ?? 0));
         return revalidatedTags.length > 0 ? -1 : (lastModified ?? Date.now());
     },
     writeTags: async (newTags) => {
-        const newTagsSet = new Set(newTags.map(({ tag, path }) => `${tag}-${path}`));
+        const newTagsSet = new Set(newTags.map(({ tag, path }) => `${buildKey(tag)}-${buildKey(path)}`));
         const unchangedTags = tags.filter(({ tag, path }) => !newTagsSet.has(`${tag.S}-${path.S}`));
-        tags = unchangedTags.concat(newTags.map((tag) => ({
-            tag: { S: tag.tag },
-            path: { S: tag.path },
-            revalidatedAt: { N: String(tag.revalidatedAt ?? 1) },
+        tags = unchangedTags.concat(newTags.map((item) => ({
+            tag: { S: buildKey(item.tag) },
+            path: { S: buildKey(item.path) },
+            revalidatedAt: { N: `${item.revalidatedAt ?? Date.now()}` },
         })));
     },
 };

package/dist/overrides/wrappers/express-dev.js

@@ -4,6 +4,9 @@ import { NextConfig } from "../../adapters/config/index";
 import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const wrapper = async (handler, converter) => {
     const app = express();
+    // We disable this cause we wanna use it ourself
+    // https://stackoverflow.com/a/13055495/16587222
+    app.disable("x-powered-by");
     // To serve static assets
     const basePath = NextConfig.basePath ?? "";
     app.use(basePath, express.static(path.join(getMonorepoRelativePath(), "assets")));

package/dist/types/open-next.d.ts

@@ -100,7 +100,7 @@ export interface MiddlewareResult extends RoutingResult, BaseEventOrResult<"midd
 }
 export type IncludedQueue = "sqs" | "sqs-lite" | "direct" | "dummy";
 export type IncludedIncrementalCache = "s3" | "s3-lite" | "multi-tier-ddb-s3" | "fs-dev" | "dummy";
-export type IncludedTagCache = "dynamodb" | "dynamodb-lite" | "dynamodb-nextMode" | "fs-dev" | "dummy";
+export type IncludedTagCache = "dynamodb" | "dynamodb-lite" | "dynamodb-nextMode" | "fs-dev" | "fs-dev-nextMode" | "dummy";
 export type IncludedImageLoader = "s3" | "s3-lite" | "host" | "fs-dev" | "dummy";
 export type IncludedOriginResolver = "pattern-env" | "dummy";
 export type IncludedWarmer = "aws-lambda" | "dummy";

package/dist/utils/safe-json-parse.d.ts

@@ -0,0 +1 @@
+export declare function safeParseJsonFile<T = any>(input: string, filePath: string, fallback?: T): T | undefined;

package/dist/utils/safe-json-parse.js

@@ -0,0 +1,10 @@
+import logger from "../logger.js";
+export function safeParseJsonFile(input, filePath, fallback) {
+    try {
+        return JSON.parse(input);
+    }
+    catch (err) {
+        logger.warn(`Failed to parse JSON file "${filePath}". Error: ${err.message}`);
+        return fallback;
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.7.5",
+  "version": "3.7.6",
   "bin": {
     "open-next": "./dist/index.js"
   },