@netlify/plugin-nextjs 5.14.0 → 5.14.2

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

@@ -1385,7 +1385,7 @@ import {
   isAnyTagStaleOrExpired,
   markTagsAsStaleAndPurgeEdgeCache
 } from "./tags-handler.cjs";
-import { getTracer } from "./tracer.cjs";
+import { getTracer, withActiveSpan } from "./tracer.cjs";
 var LRU_CACHE_GLOBAL_KEY = Symbol.for("nf-use-cache-handler-lru-cache");
 var PENDING_SETS_GLOBAL_KEY = Symbol.for("nf-use-cache-handler-pending-sets");
 var cacheHandlersSymbol = Symbol.for("@next/cache-handlers");
@@ -1415,11 +1415,12 @@ var tmpResolvePendingBeforeCreatingAPromise = () => {
 };
 var NetlifyDefaultUseCacheHandler = {
   get(cacheKey) {
-    return getTracer().withActiveSpan(
+    return withActiveSpan(
+      getTracer(),
       "DefaultUseCacheHandler.get",
       async (span) => {
         getLogger().withFields({ cacheKey }).debug(`[NetlifyDefaultUseCacheHandler] get`);
-        span.setAttributes({
+        span?.setAttributes({
           cacheKey
         });
         const pendingPromise = getPendingSets().get(cacheKey);
@@ -1429,7 +1430,7 @@ var NetlifyDefaultUseCacheHandler = {
         const privateEntry = getLRUCache().get(cacheKey);
         if (!privateEntry) {
           getLogger().withFields({ cacheKey, status: "MISS" }).debug(`[NetlifyDefaultUseCacheHandler] get result`);
-          span.setAttributes({
+          span?.setAttributes({
             cacheStatus: "miss"
           });
           return void 0;
@@ -1438,41 +1439,47 @@ var NetlifyDefaultUseCacheHandler = {
         const ttl = (entry.timestamp + entry.revalidate * 1e3 - Date.now()) / 1e3;
         if (ttl < 0) {
           getLogger().withFields({ cacheKey, ttl, status: "STALE" }).debug(`[NetlifyDefaultUseCacheHandler] get result`);
-          span.setAttributes({
+          span?.setAttributes({
             cacheStatus: "expired, discarded",
             ttl
           });
           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`);
-          span.setAttributes({
-            cacheStatus: "stale tag, discarded",
+        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: "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`);
-        span.setAttributes({
-          cacheStatus: "hit",
+        getLogger().withFields({ cacheKey, ttl, status: stale ? "STALE" : "HIT" }).debug(`[NetlifyDefaultUseCacheHandler] get result`);
+        span?.setAttributes({
+          cacheStatus: stale ? "stale" : "hit",
           ttl
         });
         return {
           ...entry,
+          revalidate,
           value: returnStream
         };
       }
     );
   },
   set(cacheKey, pendingEntry) {
-    return getTracer().withActiveSpan(
+    return withActiveSpan(
+      getTracer(),
       "DefaultUseCacheHandler.set",
       async (span) => {
         getLogger().withFields({ cacheKey }).debug(`[NetlifyDefaultUseCacheHandler]: set`);
-        span.setAttributes({
+        span?.setAttributes({
           cacheKey
         });
         let resolvePending = tmpResolvePendingBeforeCreatingAPromise;
@@ -1482,7 +1489,7 @@ var NetlifyDefaultUseCacheHandler = {
         const pendingSets = getPendingSets();
         pendingSets.set(cacheKey, pendingPromise);
         const entry = await pendingEntry;
-        span.setAttributes({
+        span?.setAttributes({
           cacheKey
         });
         let size = 0;
@@ -1493,7 +1500,7 @@ var NetlifyDefaultUseCacheHandler = {
           for (let chunk; !(chunk = await reader.read()).done; ) {
             size += Buffer.from(chunk.value).byteLength;
           }
-          span.setAttributes({
+          span?.setAttributes({
             tags: entry.tags,
             timestamp: entry.timestamp,
             revalidate: entry.revalidate,
@@ -1514,33 +1521,52 @@ var NetlifyDefaultUseCacheHandler = {
   },
   async refreshTags() {
   },
-  getExpiration: function(...tags) {
-    return getTracer().withActiveSpan(
+  getExpiration: function(...notNormalizedTags) {
+    return withActiveSpan(
+      getTracer(),
       "DefaultUseCacheHandler.getExpiration",
       async (span) => {
-        span.setAttributes({
+        const tags = notNormalizedTags.flat();
+        span?.setAttributes({
           tags
         });
         const expiration = await getMostRecentTagExpirationTimestamp(tags);
         getLogger().withFields({ tags, expiration }).debug(`[NetlifyDefaultUseCacheHandler] getExpiration`);
-        span.setAttributes({
+        span?.setAttributes({
           expiration
         });
         return expiration;
       }
     );
   },
+  // this is for CacheHandlerV2
   expireTags(...tags) {
-    return getTracer().withActiveSpan(
+    return withActiveSpan(
+      getTracer(),
       "DefaultUseCacheHandler.expireTags",
       async (span) => {
         getLogger().withFields({ tags }).debug(`[NetlifyDefaultUseCacheHandler] expireTags`);
-        span.setAttributes({
+        span?.setAttributes({
           tags
         });
         await markTagsAsStaleAndPurgeEdgeCache(tags);
       }
     );
+  },
+  // this is for CacheHandlerV3 / Next 16
+  updateTags(tags, durations) {
+    return withActiveSpan(
+      getTracer(),
+      "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/next.cjs

@@ -545,8 +545,7 @@ ResponseCache.prototype.get = function get(...getArgs) {
 async function getMockedRequestHandler(nextConfig, ...args) {
   const initContext = { initializingServer: true };
   const initAsyncLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
-  const tracer = (0, import_tracer.getTracer)();
-  return tracer.withActiveSpan("mocked request handler", async () => {
+  return (0, import_tracer.withActiveSpan)((0, import_tracer.getTracer)(), "mocked request handler", async () => {
     const ofs = { ...import_promises.default };
     async function readFileFallbackBlobStore(...fsargs) {
       const [path, options] = fsargs;

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/dist/run/storage/storage.cjs

@@ -55,11 +55,11 @@ var getMemoizedKeyValueStoreBackedByRegionalBlobStore = (...args) => {
         return memoizedValue;
       }
       const blobKey = await encodeBlobKey(key);
-      const getPromise = tracer.withActiveSpan(otelSpanTitle, async (span) => {
-        span.setAttributes({ key, blobKey });
+      const getPromise = (0, import_tracer.withActiveSpan)(tracer, otelSpanTitle, async (span) => {
+        span?.setAttributes({ key, blobKey });
         const blob = await store.get(blobKey, { type: "json" });
         inMemoryCache.set(key, blob);
-        span.addEvent(blob ? "Hit" : "Miss");
+        span?.addEvent(blob ? "Hit" : "Miss");
         return blob;
       });
       inMemoryCache.set(key, getPromise);
@@ -69,8 +69,8 @@ var getMemoizedKeyValueStoreBackedByRegionalBlobStore = (...args) => {
       const inMemoryCache = (0, import_request_scoped_in_memory_cache.getRequestScopedInMemoryCache)();
       inMemoryCache.set(key, value);
       const blobKey = await encodeBlobKey(key);
-      return tracer.withActiveSpan(otelSpanTitle, async (span) => {
-        span.setAttributes({ key, blobKey });
+      return (0, import_tracer.withActiveSpan)(tracer, otelSpanTitle, async (span) => {
+        span?.setAttributes({ key, blobKey });
         return await store.setJSON(blobKey, value);
       });
     }

package/package.json

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