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 <noreply@anthropic.com>

Signed-off-by: Lars Trieloff <lars@trieloff.net>

Author: claude

src/template/polyfills/fetch.js

@@ -11,10 +11,56 @@
  */
 /* eslint-env serviceworker */
 
-module.exports = {
-  // replacing @adobe/fetch with the built-in APIs
-  fetch,
-  Request,
-  Response,
-  Headers,
+/**
+ * Detects if the code is running in a Cloudflare Workers environment.
+ * @returns {boolean} true if running on Cloudflare
+ */
+function isCloudflareEnvironment() {
+  try {
+    // caches is a Cloudflare-specific global (CacheStorage API)
+    return typeof caches !== 'undefined' && caches.default !== 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 Cloudflare: pass through as-is (auto-decompresses)
+  if (isCloudflareEnvironment()) {
+    return fetch(resource, options);
+  }
+
+  // On Fastly/Node.js: map decompress to fastly.decompressGzip
+  // This will be used on Fastly and ignored on Node.js
+  const fastlyOptions = {
+    decompressGzip: decompress,
+    ...fastly, // explicit fastly options override
+  };
+  return fetch(resource, { ...otherOptions, fastly: fastlyOptions });
+}
+
+// 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,176 @@
+/*
+ * 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 originalCaches;
+  let fetchCalls;
+
+  before(async () => {
+    // Import the module once
+    fetchPolyfill = await import('../src/template/polyfills/fetch.js');
+  });
+
+  beforeEach(() => {
+    // Save original fetch and caches
+    originalFetch = global.fetch;
+    originalCaches = global.caches;
+
+    // Mock fetch to capture calls
+    fetchCalls = [];
+    global.fetch = (resource, options) => {
+      fetchCalls.push({ resource, options });
+      return Promise.resolve(new Response('mocked'));
+    };
+  });
+
+  afterEach(() => {
+    // Restore original fetch and caches
+    global.fetch = originalFetch;
+    global.caches = originalCaches;
+  });
+
+  describe('Cloudflare environment', () => {
+    beforeEach(() => {
+      // Mock Cloudflare's caches global
+      global.caches = { default: {} };
+    });
+
+    it('passes through options as-is with decompress: true', async () => {
+      await fetchPolyfill.fetch('https://example.com', { decompress: true });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        decompress: true,
+      });
+    });
+
+    it('passes through options as-is with decompress: false', async () => {
+      await fetchPolyfill.fetch('https://example.com', { decompress: false });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        decompress: false,
+      });
+    });
+
+    it('passes through fastly options without modification', async () => {
+      await fetchPolyfill.fetch('https://example.com', {
+        fastly: { backend: 'custom' },
+      });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        fastly: { backend: 'custom' },
+      });
+    });
+
+    it('preserves all options unchanged', async () => {
+      await fetchPolyfill.fetch('https://example.com', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        decompress: true,
+      });
+
+      assert.strictEqual(fetchCalls.length, 1);
+      assert.deepStrictEqual(fetchCalls[0].options, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        decompress: true,
+      });
+    });
+  });
+
+  describe('Non-Cloudflare environment (Fastly/Node.js)', () => {
+    beforeEach(() => {
+      // Ensure no Cloudflare caches global
+      delete global.caches;
+    });
+
+    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('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',
+        },
+      });
+    });
+  });
+});