@netlify/plugin-nextjs 5.14.0 → 5.14.1

package/dist/run/handlers/tags-handler.cjs

@@ -86,7 +86,7 @@ var pipeline = (0, import_util.promisify)(import_stream.pipeline);
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.14.0";
+var version = "5.14.1";
 
 // src/run/handlers/tags-handler.cts
 var import_storage = require("../storage/storage.cjs");
@@ -206,9 +206,21 @@ async function doRevalidateTagAndPurgeEdgeCache(tags, durations) {
 }
 function markTagsAsStaleAndPurgeEdgeCache(tagOrTags, durations) {
   const tags = getCacheTagsFromTagOrTags(tagOrTags);
-  const revalidateTagPromise = doRevalidateTagAndPurgeEdgeCache(tags, durations);
+  const revalidationKey = JSON.stringify({ tags, durations });
   const requestContext = (0, import_request_context.getRequestContext)();
   if (requestContext) {
+    const ongoingRevalidation = requestContext.ongoingRevalidations?.get(revalidationKey);
+    if (ongoingRevalidation) {
+      return ongoingRevalidation;
+    }
+  }
+  const revalidateTagPromise = doRevalidateTagAndPurgeEdgeCache(tags, durations);
+  if (requestContext) {
+    requestContext.ongoingRevalidations ??= /* @__PURE__ */ new Map();
+    requestContext.ongoingRevalidations.set(revalidationKey, revalidateTagPromise);
+    process.nextTick(() => {
+      requestContext.ongoingRevalidations?.delete(revalidationKey);
+    });
     requestContext.trackBackgroundWork(revalidateTagPromise);
   }
   return revalidateTagPromise;

package/dist/run/handlers/use-cache-handler.js

@@ -1444,24 +1444,29 @@ var NetlifyDefaultUseCacheHandler = {
           });
           return void 0;
         }
-        const { stale } = await isAnyTagStaleOrExpired(entry.tags, entry.timestamp);
-        if (stale) {
-          getLogger().withFields({ cacheKey, ttl, status: "STALE BY TAG" }).debug(`[NetlifyDefaultUseCacheHandler] get result`);
+        const { stale, expired } = await isAnyTagStaleOrExpired(entry.tags, entry.timestamp);
+        if (expired) {
+          getLogger().withFields({ cacheKey, ttl, status: "EXPIRED BY TAG" }).debug(`[NetlifyDefaultUseCacheHandler] get result`);
           span.setAttributes({
-            cacheStatus: "stale tag, discarded",
+            cacheStatus: "expired tag, discarded",
             ttl
           });
           return void 0;
         }
-        const [returnStream, newSaved] = entry.value.tee();
+        let { revalidate, value } = entry;
+        if (stale) {
+          revalidate = -1;
+        }
+        const [returnStream, newSaved] = value.tee();
         entry.value = newSaved;
-        getLogger().withFields({ cacheKey, ttl, status: "HIT" }).debug(`[NetlifyDefaultUseCacheHandler] get result`);
+        getLogger().withFields({ cacheKey, ttl, status: stale ? "STALE" : "HIT" }).debug(`[NetlifyDefaultUseCacheHandler] get result`);
         span.setAttributes({
-          cacheStatus: "hit",
+          cacheStatus: stale ? "stale" : "hit",
           ttl
         });
         return {
           ...entry,
+          revalidate,
           value: returnStream
         };
       }
@@ -1514,10 +1519,11 @@ var NetlifyDefaultUseCacheHandler = {
   },
   async refreshTags() {
   },
-  getExpiration: function(...tags) {
+  getExpiration: function(...notNormalizedTags) {
     return getTracer().withActiveSpan(
       "DefaultUseCacheHandler.getExpiration",
       async (span) => {
+        const tags = notNormalizedTags.flat();
         span.setAttributes({
           tags
         });
@@ -1530,6 +1536,7 @@ var NetlifyDefaultUseCacheHandler = {
       }
     );
   },
+  // this is for CacheHandlerV2
   expireTags(...tags) {
     return getTracer().withActiveSpan(
       "DefaultUseCacheHandler.expireTags",
@@ -1541,6 +1548,20 @@ var NetlifyDefaultUseCacheHandler = {
         await markTagsAsStaleAndPurgeEdgeCache(tags);
       }
     );
+  },
+  // this is for CacheHandlerV3 / Next 16
+  updateTags(tags, durations) {
+    return getTracer().withActiveSpan(
+      "DefaultUseCacheHandler.updateTags",
+      async (span) => {
+        getLogger().withFields({ tags, durations }).debug(`[NetlifyDefaultUseCacheHandler] updateTags`);
+        span.setAttributes({
+          tags,
+          durations: JSON.stringify(durations)
+        });
+        await markTagsAsStaleAndPurgeEdgeCache(tags, durations);
+      }
+    );
   }
 };
 function configureUseCacheHandlers() {

package/dist/run/storage/regional-blob-store.cjs

@@ -25,40 +25,12 @@ __export(regional_blob_store_exports, {
 });
 module.exports = __toCommonJS(regional_blob_store_exports);
 
-// node_modules/@netlify/blobs/dist/chunk-XR3MUBBK.js
-var NF_ERROR = "x-nf-error";
-var NF_REQUEST_ID = "x-nf-request-id";
-var BlobsInternalError = class extends Error {
-  constructor(res) {
-    let details = res.headers.get(NF_ERROR) || `${res.status} status code`;
-    if (res.headers.has(NF_REQUEST_ID)) {
-      details += `, ID: ${res.headers.get(NF_REQUEST_ID)}`;
-    }
-    super(`Netlify Blobs has generated an internal error (${details})`);
-    this.name = "BlobsInternalError";
-  }
-};
-var collectIterator = async (iterator) => {
-  const result = [];
-  for await (const item of iterator) {
-    result.push(item);
-  }
-  return result;
-};
-var base64Decode = (input) => {
-  const { Buffer: Buffer2 } = globalThis;
-  if (Buffer2) {
-    return Buffer2.from(input, "base64").toString();
-  }
-  return atob(input);
-};
-var base64Encode = (input) => {
-  const { Buffer: Buffer2 } = globalThis;
-  if (Buffer2) {
-    return Buffer2.from(input).toString("base64");
-  }
-  return btoa(input);
-};
+// node_modules/@netlify/blobs/node_modules/@netlify/runtime-utils/dist/main.js
+var getString = (input) => typeof input === "string" ? input : JSON.stringify(input);
+var base64Decode = globalThis.Buffer ? (input) => Buffer.from(input, "base64").toString() : (input) => atob(input);
+var base64Encode = globalThis.Buffer ? (input) => Buffer.from(getString(input)).toString("base64") : (input) => btoa(getString(input));
+
+// node_modules/@netlify/blobs/dist/chunk-HN33TXZT.js
 var getEnvironment = () => {
   const { Deno, Netlify, process: process2 } = globalThis;
   return Netlify?.env ?? Deno?.env ?? {
@@ -111,7 +83,7 @@ var encodeMetadata = (metadata) => {
   return payload;
 };
 var decodeMetadata = (header) => {
-  if (!header || !header.startsWith(BASE64_PREFIX)) {
+  if (!header?.startsWith(BASE64_PREFIX)) {
     return {};
   }
   const encodedData = header.slice(BASE64_PREFIX.length);
@@ -132,6 +104,25 @@ var getMetadataFromResponse = (response) => {
     );
   }
 };
+var NF_ERROR = "x-nf-error";
+var NF_REQUEST_ID = "x-nf-request-id";
+var BlobsInternalError = class extends Error {
+  constructor(res) {
+    let details = res.headers.get(NF_ERROR) || `${res.status} status code`;
+    if (res.headers.has(NF_REQUEST_ID)) {
+      details += `, ID: ${res.headers.get(NF_REQUEST_ID)}`;
+    }
+    super(`Netlify Blobs has generated an internal error (${details})`);
+    this.name = "BlobsInternalError";
+  }
+};
+var collectIterator = async (iterator) => {
+  const result = [];
+  for await (const item of iterator) {
+    result.push(item);
+  }
+  return result;
+};
 var BlobsConsistencyError = class extends Error {
   constructor() {
     super(
@@ -283,6 +274,7 @@ var Client = class {
   }
   async makeRequest({
     body,
+    conditions = {},
     consistency,
     headers: extraHeaders,
     key,
@@ -306,6 +298,11 @@ var Client = class {
     if (method === "put") {
       headers["cache-control"] = "max-age=0, stale-while-revalidate=60";
     }
+    if ("onlyIfMatch" in conditions && conditions.onlyIfMatch) {
+      headers["if-match"] = conditions.onlyIfMatch;
+    } else if ("onlyIfNew" in conditions && conditions.onlyIfNew) {
+      headers["if-none-match"] = "*";
+    }
     const options = {
       body,
       headers,
@@ -344,6 +341,8 @@ var getClientOptions = (options, contextOverride) => {
 var DEPLOY_STORE_PREFIX = "deploy:";
 var LEGACY_STORE_INTERNAL_PREFIX = "netlify-internal/legacy-namespace/";
 var SITE_STORE_PREFIX = "site:";
+var STATUS_OK = 200;
+var STATUS_PRE_CONDITION_FAILED = 412;
 var Store = class _Store {
   constructor(options) {
     this.client = options.client;
@@ -468,36 +467,56 @@ var Store = class _Store {
       )
     );
   }
-  async set(key, data, { metadata } = {}) {
+  async set(key, data, options = {}) {
     _Store.validateKey(key);
+    const conditions = _Store.getConditions(options);
     const res = await this.client.makeRequest({
+      conditions,
       body: data,
       key,
-      metadata,
+      metadata: options.metadata,
       method: "put",
       storeName: this.name
     });
-    if (res.status !== 200) {
-      throw new BlobsInternalError(res);
+    const etag = res.headers.get("etag") ?? "";
+    if (conditions) {
+      return res.status === STATUS_PRE_CONDITION_FAILED ? { modified: false } : { etag, modified: true };
+    }
+    if (res.status === STATUS_OK) {
+      return {
+        etag,
+        modified: true
+      };
     }
+    throw new BlobsInternalError(res);
   }
-  async setJSON(key, data, { metadata } = {}) {
+  async setJSON(key, data, options = {}) {
     _Store.validateKey(key);
+    const conditions = _Store.getConditions(options);
     const payload = JSON.stringify(data);
     const headers = {
       "content-type": "application/json"
     };
     const res = await this.client.makeRequest({
+      ...conditions,
       body: payload,
       headers,
       key,
-      metadata,
+      metadata: options.metadata,
       method: "put",
       storeName: this.name
     });
-    if (res.status !== 200) {
-      throw new BlobsInternalError(res);
+    const etag = res.headers.get("etag") ?? "";
+    if (conditions) {
+      return res.status === STATUS_PRE_CONDITION_FAILED ? { modified: false } : { etag, modified: true };
     }
+    if (res.status === STATUS_OK) {
+      return {
+        etag,
+        modified: true
+      };
+    }
+    throw new BlobsInternalError(res);
   }
   static formatListResultBlob(result) {
     if (!result.key) {
@@ -508,6 +527,31 @@ var Store = class _Store {
       key: result.key
     };
   }
+  static getConditions(options) {
+    if ("onlyIfMatch" in options && "onlyIfNew" in options) {
+      throw new Error(
+        `The 'onlyIfMatch' and 'onlyIfNew' options are mutually exclusive. Using 'onlyIfMatch' will make the write succeed only if there is an entry for the key with the given content, while 'onlyIfNew' will make the write succeed only if there is no entry for the key.`
+      );
+    }
+    if ("onlyIfMatch" in options && options.onlyIfMatch) {
+      if (typeof options.onlyIfMatch !== "string") {
+        throw new Error(`The 'onlyIfMatch' property expects a string representing an ETag.`);
+      }
+      return {
+        onlyIfMatch: options.onlyIfMatch
+      };
+    }
+    if ("onlyIfNew" in options && options.onlyIfNew) {
+      if (typeof options.onlyIfNew !== "boolean") {
+        throw new Error(
+          `The 'onlyIfNew' property expects a boolean indicating whether the write should fail if an entry for the key already exists.`
+        );
+      }
+      return {
+        onlyIfNew: true
+      };
+    }
+  }
   static validateKey(key) {
     if (key === "") {
       throw new Error("Blob key must not be empty.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "5.14.0",
+  "version": "5.14.1",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "./dist/index.js",
   "type": "module",