feat: support for more CDNs (#11)

Author: ascorbic

.changeset/afraid-kings-glow.md

@@ -0,0 +1,5 @@
+---
+"cdn-cache-control": minor
+---
+
+Adds support for Vercel, Akamai and Cloudflare headers

.changeset/dry-roses-flow.md

@@ -0,0 +1,5 @@
+---
+"cdn-cache-control": patch
+---
+
+Fix detection on Netlify

.changeset/mighty-guests-play.md

@@ -0,0 +1,5 @@
+---
+"cdn-cache-control": minor
+---
+
+Adds support for setting CDN via constructor argument

README.md

@@ -1,9 +1,8 @@
 <h1 align="center">cdn-cache-control</h1>
-<p align="center"> 
+<p align="center">
   <img alt="cdn-cache-control" src="https://github.com/user-attachments/assets/62464d67-cbd5-48b5-a36d-800678ae22bb" />
 </p>
 
-
 Easy, opinionated CDN cache header handling.
 
 Modern CDNs allow very fine-grained control over the cache. This is particularly useful for server-side rendering of web content, as it allows you to manually handle the invalidation of content, ensuring it stays fast and fresh. This package provides a subclass of the `Headers` class that makes it easier to set cache control headers for content served through a modern CDN. It provides a simple, chainable API with sensible defaults for common use cases. It works by setting the `Cache-Control` and `CDN-Cache-Control` headers to the appropriate values. If run on a supported platform it will use the more specific header for that CDN. e.g. on Netlify it will use the `Netlify-CDN-Cache-Control` header.
@@ -33,6 +32,8 @@ The module exports a single class, `CacheHeaders`, which is a subclass of the fe
 
 It can be instantiated with a `HeadersInit` value, which lets you base it on an existing `Headers` object, or an object or array with existing header values. In that case it will default to using existing `s-maxage` directives if present.
 
+You can pass a `cdn` value as the second argument to set the CDN cache control header. In some cases this will enable targeted cache header names. e.g. for Netlify it will use the `Netlify-CDN-Cache-Control` header. Currently supported values are `netlify`, `vercel`, `cloudflare` and `akamai`. If you don't pass a value, or pass an unsupported one it will use the generic `CDN-Cache-Control` header. It will also attempt to detect the platform automatically on Vercel and Netlify.
+
 ### Use cases
 
 If you have content that you want to have the CDN cache until it is manually revalidated or purged with a new deploy, you can use the default values:
@@ -178,18 +179,34 @@ Number of seconds in one year
 
 ### Methods
 
-- [tag](#gear-tag)
-- [swr](#gear-swr)
-- [immutable](#gear-immutable)
-- [ttl](#gear-ttl)
-- [toObject](#gear-toobject)
-- [copyTo](#gear-copyto)
-- [getCdnCacheControl](#gear-getcdncachecontrol)
-- [setCdnCacheControl](#gear-setcdncachecontrol)
-- [getCacheControl](#gear-getcachecontrol)
-- [setCacheControl](#gear-setcachecontrol)
-- [getCacheTags](#gear-getcachetags)
-- [setCacheTags](#gear-setcachetags)
+- [Installation](#installation)
+- [Usage](#usage)
+	- [Use cases](#use-cases)
+		- [stale-while-revalidate](#stale-while-revalidate)
+		- [Immutable content](#immutable-content)
+		- [Cache tags](#cache-tags)
+		- [Using the generated headers](#using-the-generated-headers)
+- [API](#api)
+- [:wrench: Constants](#wrench-constants)
+	- [:gear: ONE\_MINUTE](#gear-one_minute)
+	- [:gear: ONE\_HOUR](#gear-one_hour)
+	- [:gear: ONE\_DAY](#gear-one_day)
+	- [:gear: ONE\_WEEK](#gear-one_week)
+	- [:gear: ONE\_YEAR](#gear-one_year)
+- [:factory: CacheHeaders](#factory-cacheheaders)
+	- [Methods](#methods)
+		- [:gear: tag](#gear-tag)
+		- [:gear: swr](#gear-swr)
+		- [:gear: immutable](#gear-immutable)
+		- [:gear: ttl](#gear-ttl)
+		- [:gear: toObject](#gear-toobject)
+		- [:gear: copyTo](#gear-copyto)
+		- [:gear: getCdnCacheControl](#gear-getcdncachecontrol)
+		- [:gear: setCdnCacheControl](#gear-setcdncachecontrol)
+		- [:gear: getCacheControl](#gear-getcachecontrol)
+		- [:gear: setCacheControl](#gear-setcachecontrol)
+		- [:gear: getCacheTags](#gear-getcachetags)
+		- [:gear: setCacheTags](#gear-setcachetags)
 
 #### :gear: tag
 
@@ -300,15 +317,3 @@ The parsed content of the cache tags header.
 | `setCacheTags` | `(tags: string[]) => void` |
 
 <!-- TSDOC_END -->
-
-```
-
-```
-
-```
-
-```
-
-```
-
-```

netlify.test.js

@@ -3,19 +3,16 @@ import { before, describe, it } from "node:test";
 import { CacheHeaders } from "./dist/index.js";
 
 describe("Netlify", () => {
-  before(() => {
-    process.env.NETLIFY = "true";
-  });
   it("sets tiered header on Netlify", () => {
-    const headers = new CacheHeaders().swr();
+    const headers = new CacheHeaders(undefined, "netlify").swr();
     assert.strictEqual(
       headers.get("Netlify-CDN-Cache-Control"),
       "public,s-maxage=0,durable,stale-while-revalidate=604800",
     );
   });
 
   it("should detect Netlify CDN", () => {
-    const headers = new CacheHeaders().immutable();
+    const headers = new CacheHeaders(undefined, "netlify").immutable();
     assert(headers.has("Netlify-CDN-Cache-Control"));
   });
 });

src/index.ts

@@ -1,8 +1,13 @@
 import process from "node:process";
 
 // TODO: Add more CDNs
-/** The CDN that the cache headers are being used with. WIll work with other CDNs, but may miss platform-specific headers and directives. */
-export type CDN = "netlify";
+/** The CDN that the cache headers are being used with. Will work with other CDNs, but may miss platform-specific headers and directives. */
+export type CDN =
+  | "netlify"
+  | "cloudflare"
+  | "akamai"
+  | "vercel"
+  | (string & {});
 
 /** Number of seconds in one minute */
 export const ONE_MINUTE = 60;
@@ -18,13 +23,28 @@ export const ONE_YEAR = 31536000;
 // The tiered directive is used by Netlify to indicate that it should use a tiered cache, with a central cache shared by all edge nodes.
 const tieredDirective = "durable";
 
+const cdnCacheControlHeaderNames = new Map<CDN, string>([
+  ["netlify", "Netlify-CDN-Cache-Control"],
+  ["cloudflare", "Cloudflare-CDN-Cache-Control"],
+  ["akamai", "Akamai-Cache-Control"],
+  ["vercel", "Vercel-CDN-Cache-Control"],
+]);
+
 function detectCDN(): CDN | undefined {
-  if (process.env.NETLIFY || process.env.NETLIFY_LOCAL) {
-    return "netlify";
-  }
   if (process.env.CDN) {
     return process.env.CDN as CDN;
   }
+  if (process.env.VERCEL) {
+    return "vercel";
+  }
+  if (
+    process.env.NETLIFY ||
+    process.env.NETLIFY_LOCAL ||
+    process.env.NETLIFY_BLOBS_CONTEXT
+  ) {
+    return "netlify";
+  }
+
   return undefined;
 }
 
@@ -57,9 +77,9 @@ function serializeCacheControlHeader(
 export class CacheHeaders extends Headers {
   #cdn?: CDN;
 
-  public constructor(init?: HeadersInit) {
+  public constructor(init?: HeadersInit, cdn?: CDN) {
     super(init);
-    this.#cdn = detectCDN();
+    this.#cdn = cdn ?? detectCDN();
     const cdnDirectives = parseCacheControlHeader(
       this.get(this.cdnCacheControlHeaderName),
     );
@@ -194,12 +214,9 @@ export class CacheHeaders extends Headers {
   }
 
   private get cdnCacheControlHeaderName(): string {
-    switch (this.#cdn) {
-      case "netlify":
-        return "Netlify-CDN-Cache-Control";
-      default:
-        return "CDN-Cache-Control";
-    }
+    return (
+      cdnCacheControlHeaderNames.get(this.#cdn ?? "") ?? "CDN-Cache-Control"
+    );
   }
 
   /**