@edgeone/nuxt-pages 1.0.0

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

@@ -0,0 +1,220 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  getTracer
+} from "../../esm-chunks/chunk-UOPC2N5A.js";
+import "../../esm-chunks/chunk-V2LFVP3C.js";
+import {
+  LRUCache,
+  getLogger,
+  getRequestContext
+} from "../../esm-chunks/chunk-KGYBHZC3.js";
+import "../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/run/handlers/use-cache-handler.ts
+import { Buffer } from "node:buffer";
+
+// package.json
+var name = "@edgeone/nuxt-pages";
+var version = "1.0.0";
+
+// src/run/handlers/tags-handler.cts
+var purgeCacheUserAgent = `${name}@${version}`;
+function getCacheTagsFromTagOrTags(tagOrTags) {
+  return (Array.isArray(tagOrTags) ? tagOrTags : [tagOrTags]).flatMap((tag) => tag.split(/,|%2c/gi)).filter(Boolean);
+}
+async function purgeEdgeCache(tagOrTags) {
+  const tags = getCacheTagsFromTagOrTags(tagOrTags).map((tag) => {
+    return tag.replace(/^_N_T_/, "").replace(/\/page|\/layout$/, "");
+  });
+  if (tags.length === 0) {
+    return Promise.resolve();
+  }
+  getLogger().debug(`[NuxtRuntime] Purging CDN cache for: [${tags.join(", ")}]`);
+  const baseUrl = process.env.IS_MAINLAND === "true" ? "https://pages-api.cloud.tencent.com" : "https://pages-api.edgeone.ai";
+  const token = process.env.PURGE_TOKEN;
+  const requestBody = {
+    path: [...tags]
+  };
+  const res = await fetch(`${baseUrl}/eo/purge`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(requestBody)
+  });
+  const data = await res.json();
+  if (data?.error) {
+    console.log(`Failed to purge CDN cache: ${data?.error.message}`);
+  }
+}
+async function doRevalidateTagAndPurgeEdgeCache(tags) {
+  getLogger().withFields({ tags }).debug("doRevalidateTagAndPurgeEdgeCache");
+  if (tags.length === 0) {
+    return;
+  }
+  const tagManifest = {
+    revalidatedAt: Date.now()
+  };
+  await purgeEdgeCache(tags);
+}
+function markTagsAsStaleAndPurgeEdgeCache(tagOrTags) {
+  const tags = getCacheTagsFromTagOrTags(tagOrTags);
+  const revalidateTagPromise = doRevalidateTagAndPurgeEdgeCache(tags);
+  const requestContext = getRequestContext();
+  if (requestContext) {
+    requestContext.trackBackgroundWork(revalidateTagPromise);
+  }
+  return revalidateTagPromise;
+}
+
+// src/run/handlers/use-cache-handler.ts
+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");
+var extendedGlobalThis = globalThis;
+function getLRUCache() {
+  if (extendedGlobalThis[LRU_CACHE_GLOBAL_KEY]) {
+    return extendedGlobalThis[LRU_CACHE_GLOBAL_KEY];
+  }
+  const lruCache = new LRUCache({
+    max: 1e3,
+    maxSize: 50 * 1024 * 1024,
+    // same as hardcoded default
+    sizeCalculation: (value) => value.size
+  });
+  extendedGlobalThis[LRU_CACHE_GLOBAL_KEY] = lruCache;
+  return lruCache;
+}
+function getPendingSets() {
+  if (extendedGlobalThis[PENDING_SETS_GLOBAL_KEY]) {
+    return extendedGlobalThis[PENDING_SETS_GLOBAL_KEY];
+  }
+  const pendingSets = /* @__PURE__ */ new Map();
+  extendedGlobalThis[PENDING_SETS_GLOBAL_KEY] = pendingSets;
+  return pendingSets;
+}
+var tmpResolvePendingBeforeCreatingAPromise = () => {
+};
+var EdgeoneDefaultUseCacheHandler = {
+  get(cacheKey) {
+    return getTracer().withActiveSpan(
+      "DefaultUseCacheHandler.get",
+      async (span) => {
+        getLogger().withFields({ cacheKey });
+        span.setAttributes({
+          cacheKey
+        });
+        const pendingPromise = getPendingSets().get(cacheKey);
+        if (pendingPromise) {
+          await pendingPromise;
+        }
+        const privateEntry = getLRUCache().get(cacheKey);
+        if (!privateEntry) {
+          getLogger().withFields({ cacheKey, status: "MISS" });
+          span.setAttributes({
+            cacheStatus: "miss"
+          });
+          return void 0;
+        }
+        const { entry } = privateEntry;
+        const ttl = (entry.timestamp + entry.revalidate * 1e3 - Date.now()) / 1e3;
+        if (ttl < 0) {
+          getLogger().withFields({ cacheKey, ttl, status: "STALE" });
+          span.setAttributes({
+            cacheStatus: "expired, discarded",
+            ttl
+          });
+          return void 0;
+        }
+        const [returnStream, newSaved] = entry.value.tee();
+        entry.value = newSaved;
+        getLogger().withFields({ cacheKey, ttl, status: "HIT" });
+        span.setAttributes({
+          cacheStatus: "hit",
+          ttl
+        });
+        return {
+          ...entry,
+          value: returnStream
+        };
+      }
+    );
+  },
+  set(cacheKey, pendingEntry) {
+    return getTracer().withActiveSpan(
+      "DefaultUseCacheHandler.set",
+      async (span) => {
+        getLogger().withFields({ cacheKey });
+        span.setAttributes({
+          cacheKey
+        });
+        let resolvePending = tmpResolvePendingBeforeCreatingAPromise;
+        const pendingPromise = new Promise((resolve) => {
+          resolvePending = resolve;
+        });
+        const pendingSets = getPendingSets();
+        pendingSets.set(cacheKey, pendingPromise);
+        const entry = await pendingEntry;
+        span.setAttributes({
+          cacheKey
+        });
+        let size = 0;
+        try {
+          const [value, clonedValue] = entry.value.tee();
+          entry.value = value;
+          const reader = clonedValue.getReader();
+          for (let chunk; !(chunk = await reader.read()).done; ) {
+            size += Buffer.from(chunk.value).byteLength;
+          }
+          span.setAttributes({
+            tags: entry.tags,
+            timestamp: entry.timestamp,
+            revalidate: entry.revalidate,
+            expire: entry.expire
+          });
+          getLRUCache().set(cacheKey, {
+            entry,
+            size
+          });
+        } catch (error) {
+          getLogger().withError(error).error("[EdgeoneDefaultUseCacheHandler.set] error");
+        } finally {
+          resolvePending();
+          pendingSets.delete(cacheKey);
+        }
+      }
+    );
+  },
+  async refreshTags() {
+  },
+  getExpiration: function(...tags) {
+    return Promise.resolve(0);
+  },
+  expireTags(...tags) {
+    return getTracer().withActiveSpan(
+      "DefaultUseCacheHandler.expireTags",
+      async (span) => {
+        getLogger().withFields({ tags });
+        span.setAttributes({
+          tags
+        });
+        await markTagsAsStaleAndPurgeEdgeCache(tags);
+      }
+    );
+  }
+};
+function configureUseCacheHandlers() {
+  extendedGlobalThis[cacheHandlersSymbol] = {
+    DefaultCache: EdgeoneDefaultUseCacheHandler
+  };
+}
+export {
+  EdgeoneDefaultUseCacheHandler,
+  configureUseCacheHandlers
+};

package/dist/run/handlers/wait-until.cjs

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/handlers/wait-until.cts
+var wait_until_exports = {};
+__export(wait_until_exports, {
+  setupWaitUntil: () => setupWaitUntil
+});
+module.exports = __toCommonJS(wait_until_exports);
+
+// src/run/handlers/request-context.cts
+var import_node_async_hooks = require("node:async_hooks");
+
+// node_modules/@netlify/functions/dist/internal.js
+var import_process = require("process");
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var SystemLogger = class _SystemLogger {
+  fields;
+  logLevel;
+  constructor(fields = {}, logLevel = 2) {
+    this.fields = fields;
+    this.logLevel = logLevel;
+  }
+  doLog(logger, message) {
+    if (import_process.env.NETLIFY_DEV && !import_process.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+      return;
+    }
+    logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    if (this.logLevel > 2) {
+      return;
+    }
+    this.doLog(console.log, message);
+  }
+  debug(message) {
+    if (this.logLevel > 1) {
+      return;
+    }
+    this.doLog(console.debug, message);
+  }
+  error(message) {
+    if (this.logLevel > 3) {
+      return;
+    }
+    this.doLog(console.error, message);
+  }
+  withLogLevel(level) {
+    return new _SystemLogger(this.fields, level);
+  }
+  withFields(fields) {
+    return new _SystemLogger(
+      {
+        ...this.fields,
+        ...fields
+      },
+      this.logLevel
+    );
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+};
+var systemLogger = new SystemLogger();
+
+// src/run/handlers/request-context.cts
+var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
+var REQUEST_COUNTER_KEY = Symbol.for("nf-request-counter");
+var extendedGlobalThis = globalThis;
+var requestContextAsyncLocalStorage;
+function getRequestContextAsyncLocalStorage() {
+  if (requestContextAsyncLocalStorage) {
+    return requestContextAsyncLocalStorage;
+  }
+  if (extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY]) {
+    return extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY];
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  requestContextAsyncLocalStorage = storage;
+  extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY] = storage;
+  return storage;
+}
+var getRequestContext = () => getRequestContextAsyncLocalStorage().getStore();
+
+// src/run/handlers/wait-until.cts
+var NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for("@next/request-context");
+function setupWaitUntil() {
+  ;
+  globalThis[NEXT_REQUEST_CONTEXT_SYMBOL] = {
+    get() {
+      return { waitUntil: getRequestContext()?.trackBackgroundWork };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupWaitUntil
+});

package/dist/run/headers.js

@@ -0,0 +1,17 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  setCacheControlHeaders,
+  setCacheStatusHeader,
+  setCacheTagsHeaders
+} from "../esm-chunks/chunk-5YBUNNZ4.js";
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+export {
+  setCacheControlHeaders,
+  setCacheStatusHeader,
+  setCacheTagsHeaders
+};

package/dist/run/revalidate.js

@@ -0,0 +1,34 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/run/revalidate.ts
+import { isPromise } from "node:util/types";
+function isRevalidateMethod(key, nextResponseField) {
+  return key === "revalidate" && typeof nextResponseField === "function";
+}
+var nextResponseProxy = (response, requestContext) => {
+  return new Proxy(response, {
+    get(target, key) {
+      const originalValue = Reflect.get(target, key);
+      if (isRevalidateMethod(key, originalValue)) {
+        return function newRevalidate(...args) {
+          requestContext.didPagesRouterOnDemandRevalidate = true;
+          const result = originalValue.apply(target, args);
+          if (result && isPromise(result)) {
+            requestContext.trackBackgroundWork(result);
+          }
+          return result;
+        };
+      }
+      return originalValue;
+    }
+  });
+};
+export {
+  nextResponseProxy
+};

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

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/storage/regional-blob-store.cts
+var regional_blob_store_exports = {};
+__export(regional_blob_store_exports, {
+  getRegionalBlobStore: () => getRegionalBlobStore,
+  setFetchBeforeNuxtPatchedIt: () => setFetchBeforeNuxtPatchedIt
+});
+module.exports = __toCommonJS(regional_blob_store_exports);
+var FETCH_BEFORE_NUXT_PATCHED_IT = Symbol.for("nf-not-patched-fetch");
+var extendedGlobalThis = globalThis;
+function attemptToGetOriginalFetch(fetch) {
+  return fetch._nuxtOriginalFetch ?? fetch;
+}
+function forceOptOutOfUsingDataCache(fetch) {
+  return (input, init) => {
+    return fetch(input, {
+      ...init,
+      next: {
+        ...init?.next,
+        // setting next.internal = true should prevent from trying to use data cache
+        // https://github.com/vercel/next.js/blob/fa214c74c1d8023098c0e94e57f917ef9f1afd1a/packages/next/src/server/lib/patch-fetch.ts#L174
+        // https://github.com/vercel/next.js/blob/fa214c74c1d8023098c0e94e57f917ef9f1afd1a/packages/next/src/server/lib/patch-fetch.ts#L210-L213
+        // this is last line of defense in case we didn't manage to get unpatched fetch that will not affect
+        // fetch if it's unpatched so it should be safe to apply always if we aren't sure if we use patched fetch
+        // @ts-expect-error - this is an internal field that Next.js doesn't add to its global
+        // type overrides for RequestInit type (like `next.revalidate` or `next.tags`)
+        internal: true
+      }
+    });
+  };
+}
+var setFetchBeforeNuxtPatchedIt = (fetch) => {
+  extendedGlobalThis[FETCH_BEFORE_NUXT_PATCHED_IT] = forceOptOutOfUsingDataCache(
+    attemptToGetOriginalFetch(fetch)
+  );
+};
+var fetchBeforeNuxtPatchedItFallback = forceOptOutOfUsingDataCache(
+  attemptToGetOriginalFetch(globalThis.fetch)
+);
+var getRegionalBlobStore = (args = {}) => {
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRegionalBlobStore,
+  setFetchBeforeNuxtPatchedIt
+});