feat: add decompress option support with Fastly decompressGzip mapping (#81)

Implement cross-platform decompression control by mapping the @adobe/fetch
decompress option to platform-specific behavior:
- Fastly: Maps decompress to fastly.decompressGzip
- Cloudflare: Pass-through (auto-decompresses)
- Node.js: Pass-through to @adobe/fetch

The wrapper accepts decompress: true|false (default: true) and automatically
sets fastly.decompressGzip when running on Fastly Compute. Explicit fastly
options take precedence over the mapped value.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Signed-off-by: Lars Trieloff <[email protected]>

Author: claude

src/template/polyfills/fetch.js

@@ -10,11 +10,58 @@
  * governing permissions and limitations under the License.
  */
 /* eslint-env serviceworker */
+/* global Dictionary */
 
-module.exports = {
-  // replacing @adobe/fetch with the built-in APIs
-  fetch,
-  Request,
-  Response,
-  Headers,
+/**
+ * Detects if the code is running in a Fastly Compute environment.
+ * @returns {boolean} true if running on Fastly
+ */
+function isFastlyEnvironment() {
+  try {
+    // Dictionary is a Fastly-specific global used for config/secrets
+    return typeof Dictionary !== 'undefined';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Wrapper for fetch that provides cross-platform decompression support.
+ * Maps the @adobe/fetch `decompress` option to platform-specific behavior:
+ * - Fastly: Sets fastly.decompressGzip based on decompress value
+ * - Cloudflare: No-op (automatically decompresses)
+ * - Node.js: Pass through to @adobe/fetch (handles it natively)
+ *
+ * @param {RequestInfo} resource - URL or Request object
+ * @param {RequestInit & {decompress?: boolean, fastly?: object}} options - Fetch options
+ * @returns {Promise<Response>} The fetch response
+ */
+function wrappedFetch(resource, options = {}) {
+  // Extract decompress option (default: true to match @adobe/fetch behavior)
+  const { decompress = true, fastly, ...otherOptions } = options;
+
+  // On Fastly: map decompress to fastly.decompressGzip
+  if (isFastlyEnvironment()) {
+    const fastlyOptions = {
+      decompressGzip: decompress,
+      ...fastly, // explicit fastly options override
+    };
+    return fetch(resource, { ...otherOptions, fastly: fastlyOptions });
+  }
+
+  // On Cloudflare/Node.js: pass through as-is
+  // Cloudflare auto-decompresses, Node.js uses @adobe/fetch which handles decompress
+  return fetch(resource, options);
+}
+
+// Export wrapped fetch and native Web APIs
+export { wrappedFetch as fetch };
+export const { Request, Response, Headers } = globalThis;
+
+// Export for CommonJS (for compatibility with require() in bundled code)
+export default {
+  fetch: wrappedFetch,
+  Request: globalThis.Request,
+  Response: globalThis.Response,
+  Headers: globalThis.Headers,
 };

test/fetch-polyfill.test.js

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/* eslint-env mocha */
+
+import assert from 'assert';
+
+describe('Fetch Polyfill Test', () => {
+  let fetchPolyfill;
+  let originalFetch;
+  let fetchCalls;
+
+  before(async () => {
+    // Import the module once
+    fetchPolyfill = await import('../src/template/polyfills/fetch.js');
+  });
+
+  beforeEach(() => {
+    // Save original fetch
+    originalFetch = global.fetch;
+
+    // Mock fetch to capture calls
+    fetchCalls = [];
+    global.fetch = (resource, options) => {
+      fetchCalls.push({ resource, options });
+      return Promise.resolve(new Response('mocked'));
+    };
+  });
+
+  afterEach(() => {
+    // Restore original fetch
+    global.fetch = originalFetch;
+    // Clean up Dictionary if set
+    delete global.Dictionary;
+  });
+
+  describe('Fastly environment', () => {
+    beforeEach(() => {
+      global.Dictionary = true;
+    });
+
+    it('maps decompress: true to fastly.decompressGzip: true by default', async () => {
+      await fetchPolyfill.fetch('https://example.com');
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.strictEqual(fetchCalls[0].resource, 'https://example.com');
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        fastly: { decompressGzip: true },
+      });
+    });
+
+    it('maps decompress: true to fastly.decompressGzip: true explicitly', async () => {
+      await fetchPolyfill.fetch('https://example.com', { decompress: true });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        fastly: { decompressGzip: true },
+      });
+    });
+
+    it('maps decompress: false to fastly.decompressGzip: false', async () => {
+      await fetchPolyfill.fetch('https://example.com', { decompress: false });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        fastly: { decompressGzip: false },
+      });
+    });
+
+    it('passes through explicit fastly options', async () => {
+      await fetchPolyfill.fetch('https://example.com', {
+        fastly: { decompressGzip: false, backend: 'custom' },
+      });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        fastly: { decompressGzip: false, backend: 'custom' },
+      });
+    });
+
+    it('explicit fastly options override decompress mapping', async () => {
+      await fetchPolyfill.fetch('https://example.com', {
+        decompress: true,
+        fastly: { decompressGzip: false },
+      });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        fastly: { decompressGzip: false },
+      });
+    });
+
+    it('preserves other fetch options', async () => {
+      await fetchPolyfill.fetch('https://example.com', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        decompress: true,
+      });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.strictEqual(fetchCalls[0].options.method, 'POST');
+      assert.deepStrictEqual(fetchCalls[0].options.headers, {
+        'Content-Type': 'application/json',
+      });
+      assert.deepStrictEqual(fetchCalls[0].options.fastly, {
+        decompressGzip: true,
+      });
+    });
+
+    it('merges fastly options with decompress mapping', async () => {
+      await fetchPolyfill.fetch('https://example.com', {
+        decompress: true,
+        fastly: { backend: 'custom-backend' },
+      });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        fastly: {
+          decompressGzip: true,
+          backend: 'custom-backend',
+        },
+      });
+    });
+  });
+
+  describe('Non-Fastly environment (Cloudflare/Node.js)', () => {
+    it('passes through options as-is when decompress is provided', async () => {
+      await fetchPolyfill.fetch('https://example.com', {
+        decompress: true,
+        method: 'GET',
+      });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        decompress: true,
+        method: 'GET',
+      });
+    });
+
+    it('passes through options as-is when no decompress is provided', async () => {
+      await fetchPolyfill.fetch('https://example.com', {
+        method: 'POST',
+        headers: { 'Content-Type': 'text/plain' },
+      });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        method: 'POST',
+        headers: { 'Content-Type': 'text/plain' },
+      });
+    });
+
+    it('preserves fastly options in non-Fastly environment', async () => {
+      await fetchPolyfill.fetch('https://example.com', {
+        fastly: { backend: 'test' },
+      });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        fastly: { backend: 'test' },
+      });
+    });
+  });
+});