@netlify/plugin-nextjs 4.40.1 → 4.41.0-alpha-isr-blobs.0

package/lib/constants.js

@@ -38,6 +38,7 @@ exports.HIDDEN_PATHS = (0, destr_1.default)(process.env.NEXT_KEEP_METADATA_FILES
         '/prerender-manifest.js',
         '/required-server-files.json',
         '/static-manifest.json',
+        '/blobs-manifest.json',
     ];
 exports.ODB_FUNCTION_PATH = `/.netlify/builders/${exports.ODB_FUNCTION_NAME}`;
 exports.HANDLER_FUNCTION_PATH = `/.netlify/functions/${exports.HANDLER_FUNCTION_NAME}`;

package/lib/helpers/edge.js

@@ -210,6 +210,7 @@ const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, constants: {
     const nextConfigFile = await (0, config_1.getRequiredServerFiles)(publish);
     const nextConfig = nextConfigFile.config;
     const usesAppDir = (_a = nextConfig.experimental) === null || _a === void 0 ? void 0 : _a.appDir;
+    await (0, fs_extra_1.copy)(getEdgeTemplatePath('../vendor'), (0, path_1.join)(edgeFunctionRoot, 'vendor'));
     await (0, fs_extra_1.copy)(getEdgeTemplatePath('../edge-shared'), (0, path_1.join)(edgeFunctionRoot, 'edge-shared'));
     await (0, fs_extra_1.writeJSON)((0, path_1.join)(edgeFunctionRoot, 'edge-shared', 'nextConfig.json'), nextConfig);
     await (0, fs_extra_1.copy)((0, path_1.join)(publish, 'prerender-manifest.json'), (0, path_1.join)(edgeFunctionRoot, 'edge-shared', 'prerender-manifest.json'));

package/lib/helpers/files.js

@@ -13,6 +13,7 @@ const p_limit_1 = __importDefault(require("p-limit"));
 const pathe_1 = require("pathe");
 const slash_1 = __importDefault(require("slash"));
 const constants_1 = require("../constants");
+const blobStorage_1 = require("../templates/blobStorage");
 const edge_1 = require("./edge");
 const utils_1 = require("./utils");
 const TEST_ROUTE = /(|\/)\[[^/]+?](\/|\.html|$)/;
@@ -66,7 +67,8 @@ const getMiddleware = async (publish) => {
 };
 exports.getMiddleware = getMiddleware;
 // eslint-disable-next-line max-lines-per-function
-const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
+const moveStaticPages = async ({ netlifyConfig, target, nextConfig, netliBlob, }) => {
+    const { i18n, basePath } = nextConfig;
     console.log('Moving static page files to serve from CDN...');
     const outputDir = (0, pathe_1.join)(netlifyConfig.build.publish, target === 'serverless' ? 'serverless' : 'server');
     const buildId = (0, fs_extra_1.readFileSync)((0, pathe_1.join)(netlifyConfig.build.publish, 'BUILD_ID'), 'utf8').trim();
@@ -93,15 +95,24 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
         }
     });
     let fileCount = 0;
+    let blobCount = 0;
     const filesManifest = {};
-    const moveFile = async (file) => {
+    const blobsManifest = new Set();
+    const getSourceAndTargetPath = (file) => {
+        const source = (0, pathe_1.join)(outputDir, file);
         // Strip the initial 'app' or 'pages' directory from the output path
         const pathname = file.split('/').slice(1).join('/');
         // .rsc data files go next to the html file
         const isData = file.endsWith('.json');
-        const source = (0, pathe_1.join)(outputDir, file);
         const targetFile = isData ? (0, pathe_1.join)(dataDir, pathname) : pathname;
         const targetPath = basePath ? (0, pathe_1.join)(basePath, targetFile) : targetFile;
+        return {
+            targetPath,
+            source,
+        };
+    };
+    const moveFile = async (file) => {
+        const { source, targetPath } = getSourceAndTargetPath(file);
         fileCount += 1;
         filesManifest[file] = targetPath;
         const dest = (0, pathe_1.join)(netlifyConfig.build.publish, targetPath);
@@ -112,6 +123,14 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
             console.warn('Error moving file', source, error);
         }
     };
+    const uploadFileToBlobStorageAndDelete = async (file) => {
+        const { source } = getSourceAndTargetPath(file);
+        blobsManifest.add(file);
+        const content = await (0, fs_extra_1.readFile)(source, 'utf8');
+        blobCount += 1;
+        await netliBlob.set((0, blobStorage_1.getNormalizedBlobKey)(file), content);
+        await (0, fs_extra_1.remove)(source);
+    };
     // Move all static files, except nft manifests
     const pages = await (0, globby_1.default)(['{app,pages}/**/*.{html,json,rsc}', '!**/*.js.nft.{html,json}'], {
         cwd: outputDir,
@@ -128,8 +147,13 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
         const filePath = (0, slash_1.default)(rawPath);
         // Remove the initial 'app' or 'pages' directory from the output path
         const pagePath = filePath.split('/').slice(1).join('/');
-        // Don't move ISR files, as they're used for the first request
         if (isrFiles.has(pagePath)) {
+            if (netliBlob) {
+                // if netliblob is enabled, we will move ISR assets to blob store and delete files after that
+                // to minimize the number of files needed in lambda
+                return limit(uploadFileToBlobStorageAndDelete, filePath);
+            }
+            // Don't move ISR files, as they're used for the first request
             return;
         }
         if ((0, exports.isDynamicRoute)(pagePath)) {
@@ -155,7 +179,10 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
         return limit(moveFile, filePath);
     });
     await Promise.all(promises);
-    console.log(`Moved ${fileCount} files`);
+    console.log(`Moved ${fileCount} files to CDN`);
+    if (netliBlob) {
+        console.log(`Moved ${blobCount} files to Blob Storage`);
+    }
     if (matchedPages.size !== 0) {
         console.log((0, chalk_1.yellowBright)((0, outdent_1.outdent) `
         Skipped moving ${matchedPages.size} ${matchedPages.size === 1 ? 'file because it matches' : 'files because they match'} middleware, so cannot be deployed to the CDN and will be served from the origin instead.
@@ -198,8 +225,9 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
         `);
         }
     }
-    // Write the manifest for use in the serverless functions
+    // Write the manifests for use in the serverless functions
     await (0, fs_extra_1.writeJson)((0, pathe_1.join)(netlifyConfig.build.publish, 'static-manifest.json'), Object.entries(filesManifest));
+    await (0, fs_extra_1.writeJson)((0, pathe_1.join)(netlifyConfig.build.publish, 'blobs-manifest.json'), [...blobsManifest]);
     if (i18n === null || i18n === void 0 ? void 0 : i18n.defaultLocale) {
         const rootPath = basePath ? (0, pathe_1.join)(netlifyConfig.build.publish, basePath) : netlifyConfig.build.publish;
         // Copy the default locale into the root

package/lib/helpers/functions.js

@@ -80,6 +80,8 @@ const generateFunctions = async ({ INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR, PACKAGE_
         await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'server.js'), (0, pathe_1.join)(functionsDir, functionName, 'server.js'));
         await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'requireHooks.js'), (0, pathe_1.join)(functionsDir, functionName, 'requireHooks.js'));
         await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), (0, pathe_1.join)(functionsDir, functionName, 'handlerUtils.js'));
+        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'blob.js'), (0, pathe_1.join)(functionsDir, functionName, 'blob.js'));
+        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'blobStorage.js'), (0, pathe_1.join)(functionsDir, functionName, 'blobStorage.js'));
         await (0, functionsMetaData_1.writeFunctionConfiguration)({ functionName, functionTitle, functionsDir });
         const nfInternalFiles = await (0, tiny_glob_1.default)((0, pathe_1.join)(functionsDir, functionName, '**'));
         const lambda = ssrLambdas.find((l) => l.functionName === functionName);
@@ -257,6 +259,7 @@ const getSSRDependencies = async (publish) => {
         }),
         (0, pathe_1.join)(publish, '**', '*.html'),
         (0, pathe_1.join)(publish, 'static-manifest.json'),
+        (0, pathe_1.join)(publish, 'blobs-manifest.json'),
     ];
 };
 const getSSRLambdas = async (publish) => {

package/lib/index.js

@@ -19,6 +19,7 @@ const functions_1 = require("./helpers/functions");
 const redirects_1 = require("./helpers/redirects");
 const utils_1 = require("./helpers/utils");
 const verification_1 = require("./helpers/verification");
+const blobStorage_1 = require("./templates/blobStorage");
 const plugin = {
     async onPreBuild({ constants, netlifyConfig, utils: { build: { failBuild }, cache, }, }) {
         var _a;
@@ -108,7 +109,17 @@ const plugin = {
         });
         await (0, files_1.movePublicFiles)({ appDir, outdir, publish, basePath });
         if (!(0, destr_1.default)(process.env.SERVE_STATIC_FILES_FROM_ORIGIN)) {
-            await (0, files_1.moveStaticPages)({ target, netlifyConfig, i18n, basePath });
+            const { NETLIFY_API_HOST, NETLIFY_API_TOKEN, SITE_ID } = constants;
+            const testBlobStorage = new blobStorage_1.Blobs({
+                authentication: {
+                    apiURL: `https://${NETLIFY_API_HOST}`,
+                    token: NETLIFY_API_TOKEN,
+                },
+                context: `deploy:${process.env.DEPLOY_ID}`,
+                siteID: SITE_ID,
+            });
+            const netliBlob = (await (0, blobStorage_1.isBlobStorageAvailable)(testBlobStorage)) ? testBlobStorage : undefined;
+            await (0, files_1.moveStaticPages)({ target, netlifyConfig, nextConfig: { basePath, i18n }, netliBlob });
         }
         await (0, redirects_1.generateStaticRedirects)({
             netlifyConfig,

package/lib/templates/blob.js

@@ -0,0 +1,341 @@
+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/templates/netliblob.mts
+var netliblob_exports = {};
+__export(netliblob_exports, {
+    Blobs: () => Blobs
+});
+module.exports = __toCommonJS(netliblob_exports);
+// ../../node_modules/@netlify/blobs/dist/src/main.js
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_stream = require("stream");
+var AbortError = class extends Error {
+    constructor(message) {
+        super();
+        this.name = "AbortError";
+        this.message = message;
+    }
+};
+var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new AbortError(errorMessage) : new DOMException(errorMessage);
+var getAbortedReason = (signal) => {
+    const reason = signal.reason === void 0 ? getDOMException("This operation was aborted.") : signal.reason;
+    return reason instanceof Error ? reason : getDOMException(reason);
+};
+async function pMap(iterable, mapper, { concurrency = Number.POSITIVE_INFINITY, stopOnError = true, signal } = {}) {
+    return new Promise((resolve, reject_) => {
+        if (iterable[Symbol.iterator] === void 0 && iterable[Symbol.asyncIterator] === void 0) {
+            throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
+        }
+        if (typeof mapper !== "function") {
+            throw new TypeError("Mapper function is required");
+        }
+        if (!((Number.isSafeInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency >= 1)) {
+            throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+        }
+        const result = [];
+        const errors = [];
+        const skippedIndexesMap = /* @__PURE__ */ new Map();
+        let isRejected = false;
+        let isResolved = false;
+        let isIterableDone = false;
+        let resolvingCount = 0;
+        let currentIndex = 0;
+        const iterator = iterable[Symbol.iterator] === void 0 ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+        const reject = (reason) => {
+            isRejected = true;
+            isResolved = true;
+            reject_(reason);
+        };
+        if (signal) {
+            if (signal.aborted) {
+                reject(getAbortedReason(signal));
+            }
+            signal.addEventListener("abort", () => {
+                reject(getAbortedReason(signal));
+            });
+        }
+        const next = async () => {
+            if (isResolved) {
+                return;
+            }
+            const nextItem = await iterator.next();
+            const index = currentIndex;
+            currentIndex++;
+            if (nextItem.done) {
+                isIterableDone = true;
+                if (resolvingCount === 0 && !isResolved) {
+                    if (!stopOnError && errors.length > 0) {
+                        reject(new AggregateError(errors));
+                        return;
+                    }
+                    isResolved = true;
+                    if (skippedIndexesMap.size === 0) {
+                        resolve(result);
+                        return;
+                    }
+                    const pureResult = [];
+                    for (const [index2, value] of result.entries()) {
+                        if (skippedIndexesMap.get(index2) === pMapSkip) {
+                            continue;
+                        }
+                        pureResult.push(value);
+                    }
+                    resolve(pureResult);
+                }
+                return;
+            }
+            resolvingCount++;
+            (async () => {
+                try {
+                    const element = await nextItem.value;
+                    if (isResolved) {
+                        return;
+                    }
+                    const value = await mapper(element, index);
+                    if (value === pMapSkip) {
+                        skippedIndexesMap.set(index, value);
+                    }
+                    result[index] = value;
+                    resolvingCount--;
+                    await next();
+                }
+                catch (error) {
+                    if (stopOnError) {
+                        reject(error);
+                    }
+                    else {
+                        errors.push(error);
+                        resolvingCount--;
+                        try {
+                            await next();
+                        }
+                        catch (error2) {
+                            reject(error2);
+                        }
+                    }
+                }
+            })();
+        };
+        (async () => {
+            for (let index = 0; index < concurrency; index++) {
+                try {
+                    await next();
+                }
+                catch (error) {
+                    reject(error);
+                    break;
+                }
+                if (isIterableDone || isRejected) {
+                    break;
+                }
+            }
+        })();
+    });
+}
+var pMapSkip = Symbol("skip");
+var DEFAULT_RETRY_DELAY = 5e3;
+var MIN_RETRY_DELAY = 1e3;
+var MAX_RETRY = 5;
+var RATE_LIMIT_HEADER = "X-RateLimit-Reset";
+var fetchAndRetry = async (fetcher, url, options, attemptsLeft = MAX_RETRY) => {
+    try {
+        const res = await fetcher(url, options);
+        if (attemptsLeft > 0 && (res.status === 429 || res.status >= 500)) {
+            const delay = getDelay(res.headers.get(RATE_LIMIT_HEADER));
+            await sleep(delay);
+            return fetchAndRetry(fetcher, url, options, attemptsLeft - 1);
+        }
+        return res;
+    }
+    catch (error) {
+        if (attemptsLeft === 0) {
+            throw error;
+        }
+        const delay = getDelay();
+        await sleep(delay);
+        return fetchAndRetry(fetcher, url, options, attemptsLeft - 1);
+    }
+};
+var getDelay = (rateLimitReset) => {
+    if (!rateLimitReset) {
+        return DEFAULT_RETRY_DELAY;
+    }
+    return Math.max(Number(rateLimitReset) * 1e3 - Date.now(), MIN_RETRY_DELAY);
+};
+var sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+var EXPIRY_HEADER = "x-nf-expires-at";
+var Blobs = class _Blobs {
+    constructor({ authentication, context, fetcher, siteID }) {
+        var _a;
+        this.context = context !== null && context !== void 0 ? context : "production";
+        this.fetcher = fetcher !== null && fetcher !== void 0 ? fetcher : globalThis.fetch;
+        this.siteID = siteID;
+        if ("contextURL" in authentication) {
+            this.authentication = authentication;
+        }
+        else {
+            this.authentication = {
+                apiURL: (_a = authentication.apiURL) !== null && _a !== void 0 ? _a : "https://api.netlify.com",
+                token: authentication.token
+            };
+        }
+        if (fetcher) {
+            this.fetcher = fetcher;
+        }
+        else if (globalThis.fetch) {
+            this.fetcher = globalThis.fetch;
+        }
+        else {
+            throw new Error("You must specify a fetch-compatible `fetcher` parameter when `fetch` is not available globally");
+        }
+    }
+    async getFinalRequest(key, method) {
+        const encodedKey = encodeURIComponent(key);
+        if ("contextURL" in this.authentication) {
+            return {
+                headers: {
+                    authorization: `Bearer ${this.authentication.token}`
+                },
+                url: `${this.authentication.contextURL}/${this.siteID}/${this.context}/${encodedKey}`
+            };
+        }
+        const apiURL = `${this.authentication.apiURL}/api/v1/sites/${this.siteID}/blobs/${encodedKey}?context=${this.context}`;
+        const headers = { authorization: `Bearer ${this.authentication.token}` };
+        const res = await this.fetcher(apiURL, { headers, method });
+        if (res.status !== 200) {
+            throw new Error(`${method} operation has failed: API returned a ${res.status} response`);
+        }
+        const { url } = await res.json();
+        return {
+            url
+        };
+    }
+    static getExpirationHeaders(expiration) {
+        if (typeof expiration === "number") {
+            return {
+                [EXPIRY_HEADER]: (Date.now() + expiration).toString()
+            };
+        }
+        if (expiration instanceof Date) {
+            return {
+                [EXPIRY_HEADER]: expiration.getTime().toString()
+            };
+        }
+        if (expiration === void 0) {
+            return {};
+        }
+        throw new TypeError(`'expiration' value must be a number or a Date, ${typeof expiration} found.`);
+    }
+    isConfigured() {
+        var _a;
+        return Boolean((_a = this.authentication) === null || _a === void 0 ? void 0 : _a.token) && Boolean(this.siteID);
+    }
+    async makeStoreRequest(key, method, extraHeaders, body) {
+        if (!this.isConfigured()) {
+            throw new Error("The blob store is unavailable because it's missing required configuration properties");
+        }
+        const { headers: baseHeaders = {}, url } = await this.getFinalRequest(key, method);
+        const headers = {
+            ...baseHeaders,
+            ...extraHeaders
+        };
+        if (method === "put") {
+            headers["cache-control"] = "max-age=0, stale-while-revalidate=60";
+        }
+        const options = {
+            body,
+            headers,
+            method
+        };
+        if (body instanceof ReadableStream) {
+            options.duplex = "half";
+        }
+        const res = await fetchAndRetry(this.fetcher, url, options);
+        if (res.status === 404 && method === "get") {
+            return null;
+        }
+        if (res.status !== 200) {
+            throw new Error(`${method} operation has failed: store returned a ${res.status} response`);
+        }
+        return res;
+    }
+    async delete(key) {
+        await this.makeStoreRequest(key, "delete");
+    }
+    async get(key, options) {
+        const { type } = options !== null && options !== void 0 ? options : {};
+        const res = await this.makeStoreRequest(key, "get");
+        const expiration = res === null || res === void 0 ? void 0 : res.headers.get(EXPIRY_HEADER);
+        if (typeof expiration === "string") {
+            const expirationTS = Number.parseInt(expiration);
+            if (!Number.isNaN(expirationTS) && expirationTS <= Date.now()) {
+                return null;
+            }
+        }
+        if (res === null) {
+            return res;
+        }
+        if (type === void 0 || type === "text") {
+            return res.text();
+        }
+        if (type === "arrayBuffer") {
+            return res.arrayBuffer();
+        }
+        if (type === "blob") {
+            return res.blob();
+        }
+        if (type === "json") {
+            return res.json();
+        }
+        if (type === "stream") {
+            return res.body;
+        }
+        throw new Error(`Invalid 'type' property: ${type}. Expected: arrayBuffer, blob, json, stream, or text.`);
+    }
+    async set(key, data, { expiration } = {}) {
+        const headers = _Blobs.getExpirationHeaders(expiration);
+        await this.makeStoreRequest(key, "put", headers, data);
+    }
+    async setFile(key, path, { expiration } = {}) {
+        const { size } = await (0, import_promises.stat)(path);
+        const file = import_node_stream.Readable.toWeb((0, import_node_fs.createReadStream)(path));
+        const headers = {
+            ..._Blobs.getExpirationHeaders(expiration),
+            "content-length": size.toString()
+        };
+        await this.makeStoreRequest(key, "put", headers, file);
+    }
+    setFiles(files, { concurrency = 5 } = {}) {
+        return pMap(files, ({ key, path, ...options }) => this.setFile(key, path, options), { concurrency });
+    }
+    async setJSON(key, data, { expiration } = {}) {
+        const payload = JSON.stringify(data);
+        const headers = {
+            ..._Blobs.getExpirationHeaders(expiration),
+            "content-type": "application/json"
+        };
+        await this.makeStoreRequest(key, "put", headers, payload);
+    }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+    Blobs
+});

package/lib/templates/blobStorage.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blobs = exports.getNormalizedBlobKey = exports.getBlobInit = exports.setBlobInit = exports.isBlobStorageAvailable = void 0;
+const buffer_1 = require("buffer");
+const blob_1 = require("./blob");
+const Blobs = blob_1.Blobs;
+exports.Blobs = Blobs;
+const isBlobStorageAvailable = async (netliBlob) => {
+    try {
+        // request a key that is not present. If it returns `null` then the blob storage is available
+        // if it throws it's not available.
+        await netliBlob.get('any-key');
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isBlobStorageAvailable = isBlobStorageAvailable;
+let blobInit;
+const setBlobInit = (init) => {
+    blobInit = init;
+};
+exports.setBlobInit = setBlobInit;
+const getBlobInit = () => blobInit;
+exports.getBlobInit = getBlobInit;
+/**
+ * @netlify/blobs ATM has some limitation to keys, so we need to normalize it for now (they will be resolved so we will be able to remove this code)
+ */
+const getNormalizedBlobKey = (key) => buffer_1.Buffer.from(key).toString('base64url');
+exports.getNormalizedBlobKey = getNormalizedBlobKey;

package/lib/templates/getHandler.js

@@ -4,18 +4,20 @@ exports.getHandler = void 0;
 // Aliasing like this means the editor may be able to syntax-highlight the string
 const outdent_1 = require("outdent");
 /* eslint-disable @typescript-eslint/no-var-requires */
+const { Buffer } = require('buffer');
 const { promises } = require('fs');
 const { Server } = require('http');
 const path = require('path');
 // eslint-disable-next-line n/prefer-global/url, n/prefer-global/url-search-params
 const { URLSearchParams, URL } = require('url');
 const { Bridge } = require('@vercel/node-bridge/bridge');
-const { augmentFsModule, getMaxAge, getMultiValueHeaders, getPrefetchResponse, normalizePath, } = require('./handlerUtils');
+const { setBlobInit } = require('./blobStorage');
+const { augmentFsModule, getMaxAge, getMultiValueHeaders, getPrefetchResponse, normalizePath } = require('./handlerUtils');
 const { overrideRequireHooks, applyRequireHooks } = require('./requireHooks');
 const { getNetlifyNextServer } = require('./server');
 // We return a function and then call `toString()` on it to serialise it as the launcher function
 // eslint-disable-next-line max-lines-per-function
-const makeHandler = ({ conf, app, pageRoot, NextServer, staticManifest = [], mode = 'ssr' }) => {
+const makeHandler = ({ conf, app, pageRoot, NextServer, staticManifest = [], blobsManifest = new Set(), mode = 'ssr', }) => {
     var _a;
     // Change working directory into the site root, unless using Nx, which moves the
     // dist directory and handles this itself
@@ -42,7 +44,7 @@ const makeHandler = ({ conf, app, pageRoot, NextServer, staticManifest = [], mod
     }
     // Set during the request as it needs to get it from the request URL. Defaults to the URL env var
     let base = process.env.URL;
-    augmentFsModule({ promises, staticManifest, pageRoot, getBase: () => base });
+    augmentFsModule({ promises, staticManifest, blobsManifest, pageRoot, getBase: () => base });
     // We memoize this because it can be shared between requests, but don't instantiate it until
     // the first request because we need the host and port.
     let bridge;
@@ -77,7 +79,7 @@ const makeHandler = ({ conf, app, pageRoot, NextServer, staticManifest = [], mod
         return bridge;
     };
     return async function handler(event, context) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         let requestMode = mode;
         const prefetchResponse = getPrefetchResponse(event, mode);
         if (prefetchResponse) {
@@ -96,6 +98,18 @@ const makeHandler = ({ conf, app, pageRoot, NextServer, staticManifest = [], mod
             // 'x-next-just-first-accept-language' header is escape hatch to be able to hit this code for tests (both automated and manual)
             event.headers['accept-language'] = event.headers['accept-language'].replace(/\s*,.*$/, '');
         }
+        if ((_b = (_a = context === null || context === void 0 ? void 0 : context.clientContext) === null || _a === void 0 ? void 0 : _a.custom) === null || _b === void 0 ? void 0 : _b.blobs) {
+            const rawData = Buffer.from(context.clientContext.custom.blobs, 'base64');
+            const data = JSON.parse(rawData.toString('ascii'));
+            setBlobInit({
+                authentication: {
+                    contextURL: data.url,
+                    token: data.token,
+                },
+                context: `deploy:${event.headers['x-nf-deploy-id']}`,
+                siteID: event.headers['x-nf-site-id'],
+            });
+        }
         const { headers, ...result } = await getBridge(event, context).launcher(event, context);
         // Convert all headers to multiValueHeaders
         const multiValueHeaders = getMultiValueHeaders(headers);
@@ -106,12 +120,12 @@ const makeHandler = ({ conf, app, pageRoot, NextServer, staticManifest = [], mod
             };
             console.log('Next server response:', JSON.stringify(response, null, 2));
         }
-        if ((_b = (_a = multiValueHeaders['set-cookie']) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.includes('__prerender_bypass')) {
+        if ((_d = (_c = multiValueHeaders['set-cookie']) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.includes('__prerender_bypass')) {
             delete multiValueHeaders.etag;
             multiValueHeaders['cache-control'] = ['no-cache'];
         }
         // Sending SWR headers causes undefined behaviour with the Netlify CDN
-        const cacheHeader = (_c = multiValueHeaders['cache-control']) === null || _c === void 0 ? void 0 : _c[0];
+        const cacheHeader = (_e = multiValueHeaders['cache-control']) === null || _e === void 0 ? void 0 : _e[0];
         if (cacheHeader === null || cacheHeader === void 0 ? void 0 : cacheHeader.includes('stale-while-revalidate')) {
             if (requestMode === 'odb') {
                 const ttl = getMaxAge(cacheHeader);
@@ -153,8 +167,10 @@ const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '..
 
   process.env.NODE_ENV = 'production';
 
+  const { Buffer } = require('buffer')
   const { Server } = require("http");
   const { promises } = require("fs");
+  const { setBlobInit } = require('./blobStorage')
   // We copy the file here rather than requiring from the node module
   const { Bridge } = require("./bridge");
   const { augmentFsModule, getMaxAge, getMultiValueHeaders, getPrefetchResponse, normalizePath } = require('./handlerUtils')
@@ -167,10 +183,14 @@ const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '..
   try {
     staticManifest = require("${publishDir}/static-manifest.json")
   } catch {}
+  let blobsManifest
+  try {
+    blobsManifest = new Set(require("${publishDir}/blobs-manifest.json"))
+  } catch {}
   const path = require("path");
   const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", "server"));
   exports.handler = ${isODB
-    ? `builder((${makeHandler.toString()})({ conf: config, app: "${appDir}", pageRoot, NextServer, staticManifest, mode: 'odb' }));`
-    : `(${makeHandler.toString()})({ conf: config, app: "${appDir}", pageRoot, NextServer, staticManifest, mode: 'ssr' });`}
+    ? `builder((${makeHandler.toString()})({ conf: config, app: "${appDir}", pageRoot, NextServer, staticManifest, blobsManifest, mode: 'odb' }));`
+    : `(${makeHandler.toString()})({ conf: config, app: "${appDir}", pageRoot, NextServer, staticManifest, blobsManifest, mode: 'ssr' });`}
 `;
 exports.getHandler = getHandler;