feat: add Blobs context to edge functions

src/commands/dev/dev.mjs

@@ -210,6 +210,7 @@ const dev = async (options, command) => {
 
   await startProxyServer({
     addonsUrls,
+    blobsContext,
     config,
     configPath: configPathOverride,
     debug: options.debug,

src/lib/blobs/blobs.mjs

@@ -22,7 +22,7 @@ import { getPathInProject } from '../settings.mjs'
  * @param {boolean} options.debug
  * @param {string} options.projectRoot
  * @param {string} options.siteID
- * @returns {BlobsContext}
+ * @returns {Promise<BlobsContext>}
  */
 export const getBlobsContext = async ({ debug, projectRoot, siteID }) => {
   const token = uuidv4()

src/lib/edge-functions/bootstrap.mjs

@@ -1,5 +1,5 @@
 import { env } from 'process'
 
-const latestBootstrapURL = 'https://650bfd807b21ed000893e25c--edge.netlify.com/bootstrap/index-combined.ts'
+const latestBootstrapURL = 'https://6539213a19a93a000876a033--edge.netlify.com/bootstrap/index-combined.ts'
 
 export const getBootstrapURL = () => env.NETLIFY_EDGE_BOOTSTRAP || latestBootstrapURL

src/lib/edge-functions/headers.mjs

@@ -2,6 +2,7 @@
 import { Buffer } from 'buffer'
 
 export const headers = {
+  BlobsInfo: 'x-nf-blobs-info',
   DeployID: 'x-nf-deploy-id',
   FeatureFlags: 'x-nf-feature-flags',
   ForwardedHost: 'x-forwarded-host',

src/lib/edge-functions/proxy.mjs

@@ -66,6 +66,7 @@ export const createAccountInfoHeader = (accountInfo = {}) => {
  *
  * @param {object} config
  * @param {*} config.accountId
+ * @param {import("../blobs/blobs.mjs").BlobsContext} config.blobsContext
  * @param {*} config.config
  * @param {*} config.configPath
  * @param {*} config.debug
@@ -85,6 +86,7 @@ export const createAccountInfoHeader = (accountInfo = {}) => {
  */
 export const initializeProxy = async ({
   accountId,
+  blobsContext,
   config,
   configPath,
   debug,
@@ -151,6 +153,12 @@ export const initializeProxy = async ({
     req.headers[headers.Site] = createSiteInfoHeader(siteInfo)
     req.headers[headers.Account] = createAccountInfoHeader({ id: accountId })
 
+    if (blobsContext?.edgeURL && blobsContext?.token) {
+      req.headers[headers.BlobsInfo] = Buffer.from(
+        JSON.stringify({ url: blobsContext.edgeURL, token: blobsContext.token }),
+      ).toString('base64')
+    }
+
     await registry.initialize()
 
     const url = new URL(req.url, `http://${LOCAL_HOST}:${mainPort}`)

src/lib/functions/netlify-function.mjs

@@ -195,22 +195,14 @@ export default class NetlifyFunction {
     const environment = {}
 
     if (this.blobsContext) {
-      if (this.runtimeAPIVersion === 2) {
-        // For functions using the v2 API, we inject the context object into an
-        // environment variable.
-        environment.NETLIFY_BLOBS_CONTEXT = Buffer.from(JSON.stringify(this.blobsContext)).toString('base64')
-      } else {
-        const payload = JSON.stringify({
-          url: this.blobsContext.edgeURL,
-          token: this.blobsContext.token,
-        })
-
-        // For functions using the Lambda compatibility mode, we pass the
-        // context as part of the `clientContext` property.
-        context.custom = {
-          ...context?.custom,
-          blobs: Buffer.from(payload).toString('base64'),
-        }
+      const payload = JSON.stringify({
+        url: this.blobsContext.edgeURL,
+        token: this.blobsContext.token,
+      })
+
+      context.custom = {
+        ...context?.custom,
+        blobs: Buffer.from(payload).toString('base64'),
       }
     }
 

src/lib/functions/server.mjs

@@ -137,6 +137,7 @@ export const createHandler = function (options) {
       'client-ip': [remoteAddress],
       'x-nf-client-connection-ip': [remoteAddress],
       'x-nf-account-id': [options.accountId],
+      'x-nf-site-id': [options?.siteInfo?.id],
       [efHeaders.Geo]: Buffer.from(JSON.stringify(geoLocation)).toString('base64'),
     }).reduce((prev, [key, value]) => ({ ...prev, [key]: Array.isArray(value) ? value : [value] }), {})
     const rawQuery = new URLSearchParams(requestQuery).toString()

src/utils/proxy-server.mjs

@@ -38,6 +38,7 @@ export const generateInspectSettings = (edgeInspect, edgeInspectBrk) => {
  * @param {object} params
  * @param {string=} params.accountId
  * @param {*} params.addonsUrls
+ * @param {import("../lib/blobs/blobs.mjs").BlobsContext} blobsContext
  * @param {import('../commands/types.js').NetlifyOptions["config"]} params.config
  * @param {string} [params.configPath] An override for the Netlify config path
  * @param {boolean} params.debug
@@ -58,6 +59,7 @@ export const generateInspectSettings = (edgeInspect, edgeInspectBrk) => {
 export const startProxyServer = async ({
   accountId,
   addonsUrls,
+  blobsContext,
   config,
   configPath,
   debug,
@@ -76,6 +78,7 @@ export const startProxyServer = async ({
 }) => {
   const url = await startProxy({
     addonsUrls,
+    blobsContext,
     config,
     configPath: configPath || site.configPath,
     debug,

src/utils/proxy.mjs

@@ -675,6 +675,7 @@ export const getProxyUrl = function (settings) {
 export const startProxy = async function ({
   accountId,
   addonsUrls,
+  blobsContext,
   config,
   configPath,
   debug,
@@ -693,6 +694,7 @@ export const startProxy = async function ({
   const secondaryServerPort = settings.https ? await getAvailablePort() : null
   const functionsServer = settings.functionsPort ? `http://127.0.0.1:${settings.functionsPort}` : null
   const edgeFunctionsProxy = await initializeEdgeFunctionsProxy({
+    blobsContext,
     config,
     configPath,
     debug,

tests/integration/__fixtures__/dev-server-with-edge-functions-and-npm-modules/netlify.toml

@@ -0,0 +1,2 @@
+[build]
+publish = "public"

tests/integration/__fixtures__/dev-server-with-edge-functions-and-npm-modules/netlify/edge-functions/blobs.ts

@@ -0,0 +1,22 @@
+import { getStore } from '@netlify/blobs'
+
+export default async () => {
+  const store = getStore('my-store')
+  const metadata = {
+    name: 'Netlify',
+    features: {
+      blobs: true,
+      functions: true,
+    },
+  }
+
+  await store.set('my-key', 'hello world', { metadata })
+
+  const entry = await store.getWithMetadata('my-key')
+
+  return Response.json(entry)
+}
+
+export const config = {
+  path: '/blobs',
+}

tests/integration/__fixtures__/dev-server-with-edge-functions-and-npm-modules/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "@netlify/blobs": "^4.0.0"
+  }
+}

tests/integration/__fixtures__/dev-server-with-edge-functions-and-npm-modules/public/ordertest.html

@@ -0,0 +1 @@
+origin

tests/integration/commands/dev/edge-functions.test.ts

@@ -1,5 +1,6 @@
 import process from 'process'
 
+import execa from 'execa'
 import { describe, expect, expectTypeOf, test } from 'vitest'
 
 import { FixtureTestContext, setupFixtureTests } from '../../utils/fixture.js'
@@ -30,6 +31,10 @@ const routes = [
   },
 ]
 
+const setup = async ({ fixture }) => {
+  await execa('npm', ['install'], { cwd: fixture.directory })
+}
+
 describe.skipIf(isWindows)('edge functions', () => {
   setupFixtureTests('dev-server-with-edge-functions', { devServer: true, mockApi: { routes } }, () => {
     test<FixtureTestContext>('should run edge functions in correct order', async ({ devServer }) => {
@@ -115,17 +120,6 @@ describe.skipIf(isWindows)('edge functions', () => {
 
       expect(res2.body).toContain('<p>An unhandled error in the function code triggered the following message:</p>')
     })
-
-    test<FixtureTestContext>('should run an edge function that imports an npm module', async ({ devServer }) => {
-      const res = await got(`http://localhost:${devServer.port}/with-npm-module`, {
-        method: 'GET',
-        throwHttpErrors: false,
-        retry: { limit: 0 },
-      })
-
-      expect(res.statusCode).toBe(200)
-      expect(res.body).toBe('Hello from an npm module!')
-    })
   })
 
   setupFixtureTests('dev-server-with-edge-functions', { devServer: true, mockApi: { routes } }, () => {
@@ -146,4 +140,25 @@ describe.skipIf(isWindows)('edge functions', () => {
       expect(devServer.output).not.toContain('Removed edge function')
     })
   })
+
+  setupFixtureTests(
+    'dev-server-with-edge-functions-and-npm-modules',
+    { devServer: true, mockApi: { routes }, setup },
+    () => {
+      test<FixtureTestContext>('should run an edge function that uses the Blobs npm module', async ({ devServer }) => {
+        const res = await got(`http://localhost:${devServer.port}/blobs`, {
+          method: 'GET',
+          throwHttpErrors: false,
+          retry: { limit: 0 },
+        })
+
+        expect(res.statusCode).toBe(200)
+        expect(JSON.parse(res.body)).toEqual({
+          data: 'hello world',
+          fresh: false,
+          metadata: { name: 'Netlify', features: { blobs: true, functions: true } },
+        })
+      })
+    },
+  )
 })

tests/integration/utils/fixture.ts

@@ -144,6 +144,8 @@ export async function setupFixtureTests(
       if (options.mockApi) mockApi = await startMockApi(options.mockApi)
       fixture = await Fixture.create(fixturePath, { apiUrl: mockApi?.apiUrl })
 
+      await options.setup?.({ fixture, mockApi })
+
       if (options.devServer) {
         devServer = await startDevServer({
           cwd: fixture.directory,
@@ -156,8 +158,6 @@ export async function setupFixtureTests(
           },
         })
       }
-
-      await options.setup?.({ devServer, fixture, mockApi })
     }, HOOK_TIMEOUT)
 
     beforeEach<FixtureTestContext>((context) => {