feat: drop node16

.changeset/thick-cooks-collect.md

@@ -0,0 +1,7 @@
+---
+'@edge-runtime/node-utils': major
+'@edge-runtime/primitives': major
+'@edge-runtime/vm': major
+---
+
+drop node16

.github/workflows/test.yml

@@ -16,9 +16,9 @@ jobs:
         # https://nodejs.org/en/about/releases/
         # https://pnpm.io/installation#compatibility
         version:
-          - node: 16
           - node: 18
           - node: 20
+          - node: 22
 
     name: Node.js ${{ matrix.version.node }}
     env:

package.json

@@ -124,7 +124,7 @@
     "@jest/types": "29.5.0",
     "@svitejs/changesets-changelog-github-compact": "latest",
     "@types/jest": "29.5.14",
-    "@types/node": "16",
+    "@types/node": "18",
     "c8": "latest",
     "esbuild": "0.24.0",
     "finepack": "latest",

packages/integration-tests/test/abort-controller.test.ts

@@ -1,11 +1,9 @@
-import { polyfilledOrNative, guard } from './test-if'
-
 if (!globalThis.DOMException) {
   globalThis.DOMException = require('@edge-runtime/ponyfill').DOMException
 }
 
 describe('AbortController', () => {
-  guard(it, polyfilledOrNative)('allows to abort fetch', async () => {
+  it('allows to abort fetch', async () => {
     expect.assertions(1)
     const controller = new AbortController()
     controller.abort()

packages/integration-tests/test/body.test.ts

@@ -1,6 +1,4 @@
-import { polyfilledOrNative, guard } from './test-if'
-
-guard(describe, polyfilledOrNative)('body', () => {
+describe('body', () => {
   test('throws when the body was directly consumed', async () => {
     expect.assertions(9)
 

packages/integration-tests/test/crypto.test.ts

@@ -1,5 +1,4 @@
 import { createHash } from 'crypto'
-import { polyfilledOrNative, guard } from './test-if'
 
 if (!globalThis.crypto) {
   globalThis.crypto = require('crypto')
@@ -15,20 +14,17 @@ test('crypto.randomUUID', async () => {
   expect(crypto.randomUUID()).toEqual(expect.stringMatching(/^[a-f0-9-]+$/))
 })
 
-guard(test, polyfilledOrNative)(
-  'crypto.subtle.digest returns a SHA-256 hash',
-  async () => {
-    const digest = await crypto.subtle.digest(
-      'SHA-256',
-      new Uint8Array([104, 105, 33]),
-    )
-    expect(toHex(digest)).toEqual(
-      createHash('sha256').update('hi!').digest('hex'),
-    )
-  },
-)
+test('crypto.subtle.digest returns a SHA-256 hash', async () => {
+  const digest = await crypto.subtle.digest(
+    'SHA-256',
+    new Uint8Array([104, 105, 33]),
+  )
+  expect(toHex(digest)).toEqual(
+    createHash('sha256').update('hi!').digest('hex'),
+  )
+})
 
-guard(test, polyfilledOrNative)('Ed25519', async () => {
+test('Ed25519', async () => {
   const kp = await crypto.subtle.generateKey('Ed25519', false, [
     'sign',
     'verify',
@@ -37,7 +33,7 @@ guard(test, polyfilledOrNative)('Ed25519', async () => {
   expect(kp).toHaveProperty('publicKey')
 })
 
-guard(test, polyfilledOrNative)('X25519', async () => {
+test('X25519', async () => {
   const kp = await crypto.subtle.generateKey('X25519', false, [
     'deriveBits',
     'deriveKey',

packages/integration-tests/test/fetch.test.ts

@@ -7,7 +7,7 @@ import {
 import listen from 'test-listen'
 import multer from 'multer'
 import consume from 'stream/consumers'
-import { polyfilledOrNative, guard, isEdgeRuntime } from './test-if'
+import { guard, isEdgeRuntime } from './test-if'
 import { Duplex } from 'stream'
 
 /**
@@ -43,7 +43,56 @@ afterEach(
     }),
 )
 
-guard(describe, polyfilledOrNative())('fetch', () => {
+describe('fetch', () => {
+  it.each(
+    [
+      isEdgeRuntime() && ['host', 'vercel.com'],
+      ['content-type', 'application/json'],
+      ['connection', 'keep-alive'],
+      isEdgeRuntime() && ['keep-alive', 'timeout=5'],
+      isEdgeRuntime() && ['upgrade', 'websocket'],
+    ].filter(Boolean) as [string, string][],
+  )("sets '%s' header in the constructor", async (name, value) => {
+    server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+      res.setHeader('Content-Type', 'application/json')
+      res.end(JSON.stringify(req.headers))
+    })
+
+    const serverUrl = await listen(server)
+    let response = await fetch(serverUrl, { headers: { [name]: value } })
+    expect(response.status).toBe(200)
+    let json = await response.json()
+    expect(json[name]).toBe(value)
+
+    response = await fetch(
+      new Request(serverUrl, { headers: { [name]: value } }),
+    )
+    expect(response.status).toBe(200)
+    json = await response.json()
+    expect(json[name]).toBe(value)
+
+    response = await fetch(
+      new Request(serverUrl, { headers: new Headers({ [name]: value }) }),
+    )
+    expect(response.status).toBe(200)
+    json = await response.json()
+    expect(json[name]).toBe(value)
+
+    response = await fetch(
+      new Request(serverUrl, { headers: new Headers({ [name]: value }) }),
+    )
+    expect(response.status).toBe(200)
+    json = await response.json()
+    expect(json[name]).toBe(value)
+
+    response = await fetch(
+      new Request(serverUrl, { headers: { [name]: value } }),
+    )
+    expect(response.status).toBe(200)
+    json = await response.json()
+    expect(json[name]).toBe(value)
+  })
+
   test('perform a GET', async () => {
     server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
       if (req.method !== 'GET') {
@@ -164,23 +213,7 @@ guard(describe, polyfilledOrNative())('fetch', () => {
     })
   })
 
-  test('sets header calling Headers constructor', async () => {
-    server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
-      res.end(req.headers['user-agent'])
-    })
-    const serverUrl = await listen(server)
-    const response = await fetch(serverUrl, {
-      headers: new Headers({ 'user-agent': 'vercel/edge-runtime' }),
-    })
-    expect(response.status).toBe(200)
-    const text = await response.text()
-    expect(text).toBe('vercel/edge-runtime')
-  })
-})
-
-guard(test, polyfilledOrNative() && isEdgeRuntime())(
-  'sets headers unsupported in undici',
-  async () => {
+  guard(it, isEdgeRuntime)('sets headers unsupported in undici', async () => {
     const url = new URL('/', 'https://example.vercel.sh')
     const response = await fetch(url, {
       headers: {
@@ -189,5 +222,31 @@ guard(test, polyfilledOrNative() && isEdgeRuntime())(
       },
     })
     expect(response.status).toBe(200)
-  },
-)
+  })
+
+  guard(it, isEdgeRuntime)(
+    'sets header calling Headers constructor',
+    async () => {
+      server = createServer(
+        async (req: IncomingMessage, res: ServerResponse) => {
+          res.setHeader('Content-Type', 'application/json')
+          res.end(JSON.stringify(req.headers))
+        },
+      )
+      const serverUrl = await listen(server)
+      const response = await fetch(serverUrl, {
+        headers: new Headers({
+          'user-agent': 'vercel/edge-runtime',
+          host: 'example.com',
+          'x-host': 'example.com',
+        }),
+      })
+      expect(response.status).toBe(200)
+      const headers = await response.json()
+
+      expect(headers['user-agent']).toBe('vercel/edge-runtime')
+      expect(headers.host).toBe('example.com')
+      expect(headers['x-host']).toBe('example.com')
+    },
+  )
+})

packages/integration-tests/test/headers.test.ts

@@ -1,72 +1,68 @@
-import { guard, isEdgeRuntime, polyfilledOrNative } from './test-if'
+describe('headers', () => {
+  it.each([
+    ['host', 'vercel.com'],
+    ['content-length', '1234'],
+    ['content-type', 'application/json'],
+    ['transfer-encoding', 'chunked'],
+    ['connection', 'keep-alive'],
+    ['keep-alive', 'timeout=5'],
+    ['upgrade', 'websocket'],
+    ['expect', '100-continue'],
+  ])("sets '%s' header in the constructor", async (name, value) => {
+    const headers = new Headers({ [name]: value })
+    expect(headers.get(name)).toBe(value)
+  })
 
-guard(it, polyfilledOrNative)(
-  'sets header calling Headers constructor',
-  async () => {
+  it('sets header calling Headers constructor', async () => {
     const headers = new Headers()
     headers.set('cookie', 'hello=world')
     expect(headers.get('cookie')).toBe('hello=world')
-  },
-)
-
-guard(it, polyfilledOrNative)('multiple headers', async () => {
-  const headers = new Headers()
-  headers.append('set-cookie', 'foo=chocochip')
-  headers.append('set-cookie', 'bar=chocochip')
-  expect(headers.get('set-cookie')).toBe('foo=chocochip, bar=chocochip')
-  expect([...headers]).toEqual([
-    ['set-cookie', 'foo=chocochip'],
-    ['set-cookie', 'bar=chocochip'],
-  ])
-})
-
-guard(describe, isEdgeRuntime())('getAll', () => {
-  test('on set-cookie', () => {
-    const headers = new Headers()
-    headers.append('set-cookie', 'a=1')
-    headers.append('set-cookie', 'b=2')
-    expect(headers.getSetCookie()).toEqual(['a=1', 'b=2'])
-    expect(headers.getAll?.('set-cookie')).toEqual(['a=1', 'b=2'])
   })
 
-  test('on any other name', () => {
+  it('multiple headers', async () => {
     const headers = new Headers()
-    expect(() => headers.getAll?.('other')).toThrow(/getAll can only be used/)
+    headers.append('set-cookie', 'foo=chocochip')
+    headers.append('set-cookie', 'bar=chocochip')
+    expect(headers.get('set-cookie')).toBe('foo=chocochip, bar=chocochip')
+    expect([...headers]).toEqual([
+      ['set-cookie', 'foo=chocochip'],
+      ['set-cookie', 'bar=chocochip'],
+    ])
   })
-})
 
-guard(describe, polyfilledOrNative)('iterators', () => {
-  const generate = () => {
-    const headers = new Headers()
-    headers.append('a', '1')
-    headers.append('b', '2')
-    headers.append('set-cookie', 'c=3')
-    headers.append('set-cookie', 'd=4')
-    return headers
-  }
+  describe('iterators', () => {
+    const generate = () => {
+      const headers = new Headers()
+      headers.append('a', '1')
+      headers.append('b', '2')
+      headers.append('set-cookie', 'c=3')
+      headers.append('set-cookie', 'd=4')
+      return headers
+    }
 
-  test('#Symbol.iterator', () => {
-    const entries = [...generate()]
-    expect(entries).toEqual([
-      ['a', '1'],
-      ['b', '2'],
-      ['set-cookie', 'c=3'],
-      ['set-cookie', 'd=4'],
-    ])
-  })
+    test('#Symbol.iterator', () => {
+      const entries = [...generate()]
+      expect(entries).toEqual([
+        ['a', '1'],
+        ['b', '2'],
+        ['set-cookie', 'c=3'],
+        ['set-cookie', 'd=4'],
+      ])
+    })
 
-  test('#entries', () => {
-    const entries = [...generate().entries()]
-    expect(entries).toEqual([
-      ['a', '1'],
-      ['b', '2'],
-      ['set-cookie', 'c=3'],
-      ['set-cookie', 'd=4'],
-    ])
-  })
+    test('#entries', () => {
+      const entries = [...generate().entries()]
+      expect(entries).toEqual([
+        ['a', '1'],
+        ['b', '2'],
+        ['set-cookie', 'c=3'],
+        ['set-cookie', 'd=4'],
+      ])
+    })
 
-  test('#values', () => {
-    const values = [...generate().values()]
-    expect(values).toEqual(['1', '2', 'c=3', 'd=4'])
+    test('#values', () => {
+      const values = [...generate().values()]
+      expect(values).toEqual(['1', '2', 'c=3', 'd=4'])
+    })
   })
 })

packages/integration-tests/test/request.test.ts

@@ -1,6 +1,25 @@
-import { polyfilledOrNative, guard } from './test-if'
+describe('Request', () => {
+  it.each([
+    ['host', 'vercel.com'],
+    ['content-length', '1234'],
+    ['content-type', 'application/json'],
+    ['transfer-encoding', 'chunked'],
+    ['connection', 'keep-alive'],
+    ['keep-alive', 'timeout=5'],
+    ['upgrade', 'websocket'],
+    ['expect', '100-continue'],
+  ])("sets '%s' header in the constructor", async (name, value) => {
+    const headers = new Headers({ [name]: value })
+    expect(
+      new Request('https://vercel.com', { headers }).headers.get(name),
+    ).toBe(value)
+    expect(
+      new Request('https://vercel.com', {
+        headers: { [name]: value },
+      }).headers.get(name),
+    ).toBe(value)
+  })
 
-guard(describe, polyfilledOrNative)('request', () => {
   test('evaluate promise', () => {
     const url = 'https://vercel.com/foo/bar?one=value'
     const req = new Request(url)