@cloudflare/pages-shared 0.0.1 → 0.0.4

package/dist/asset-server/handler.js

@@ -0,0 +1,395 @@
+import {
+  FoundResponse,
+  InternalServerErrorResponse,
+  MethodNotAllowedResponse,
+  MovedPermanentlyResponse,
+  NotAcceptableResponse,
+  NotFoundResponse,
+  NotModifiedResponse,
+  OkResponse,
+  PermanentRedirectResponse,
+  SeeOtherResponse,
+  TemporaryRedirectResponse
+} from "./responses";
+import { generateRulesMatcher, replacer } from "./rulesEngine";
+export const ASSET_PRESERVATION_CACHE = "assetPreservationCache";
+const CACHE_CONTROL_PRESERVATION = "public, s-maxage=604800";
+export const CACHE_CONTROL_BROWSER = "public, max-age=0, must-revalidate";
+export const REDIRECTS_VERSION = 1;
+export const HEADERS_VERSION = 2;
+export const HEADERS_VERSION_V1 = 1;
+export const ANALYTICS_VERSION = 1;
+export function normaliseHeaders(headers) {
+  if (headers.version === HEADERS_VERSION) {
+    return headers.rules;
+  } else if (headers.version === HEADERS_VERSION_V1) {
+    return Object.keys(headers.rules).reduce(
+      (acc, key) => {
+        acc[key] = {
+          set: headers.rules[key]
+        };
+        return acc;
+      },
+      {}
+    );
+  } else {
+    return {};
+  }
+}
+export async function generateHandler({
+  request,
+  metadata,
+  xServerEnvHeader,
+  logError,
+  findAssetEntryForPath,
+  getAssetKey,
+  negotiateContent,
+  fetchAsset,
+  generateNotFoundResponse = async (notFoundRequest, notFoundFindAssetEntryForPath, notFoundServeAsset) => {
+    let assetEntry;
+    if (assetEntry = await notFoundFindAssetEntryForPath("/index.html")) {
+      return notFoundServeAsset(assetEntry, { preserve: false });
+    }
+    return new NotFoundResponse();
+  },
+  attachAdditionalHeaders = () => {
+  },
+  caches,
+  waitUntil
+}) {
+  const url = new URL(request.url);
+  const { protocol, host, search } = url;
+  let { pathname } = url;
+  const earlyHintsCache = metadata.deploymentId ? await caches?.open(`eh:${metadata.deploymentId}`) : void 0;
+  const headerRules = metadata.headers ? normaliseHeaders(metadata.headers) : {};
+  const staticRules = metadata.redirects?.version === REDIRECTS_VERSION ? metadata.redirects.staticRules || {} : {};
+  const staticRedirectsMatcher = () => {
+    const withHostMatch = staticRules[`https://${host}${pathname}`];
+    const withoutHostMatch = staticRules[pathname];
+    if (withHostMatch && withoutHostMatch) {
+      if (withHostMatch.lineNumber < withoutHostMatch.lineNumber) {
+        return withHostMatch;
+      } else {
+        return withoutHostMatch;
+      }
+    }
+    return withHostMatch || withoutHostMatch;
+  };
+  const generateRedirectsMatcher = () => generateRulesMatcher(
+    metadata.redirects?.version === REDIRECTS_VERSION ? metadata.redirects.rules : {},
+    ({ status, to }, replacements) => ({
+      status,
+      to: replacer(to, replacements)
+    })
+  );
+  let assetEntry;
+  async function generateResponse() {
+    const match = staticRedirectsMatcher() || generateRedirectsMatcher()({ request })[0];
+    if (match) {
+      const { status, to } = match;
+      const destination = new URL(to, request.url);
+      const location = destination.origin === new URL(request.url).origin ? `${destination.pathname}${destination.search || search}${destination.hash}` : `${destination.href}${destination.search ? "" : search}${destination.hash}`;
+      switch (status) {
+        case 301:
+          return new MovedPermanentlyResponse(location);
+        case 303:
+          return new SeeOtherResponse(location);
+        case 307:
+          return new TemporaryRedirectResponse(location);
+        case 308:
+          return new PermanentRedirectResponse(location);
+        case 302:
+        default:
+          return new FoundResponse(location);
+      }
+    }
+    if (!request.method.match(/^(get|head)$/i)) {
+      return new MethodNotAllowedResponse();
+    }
+    try {
+      pathname = globalThis.decodeURIComponent(pathname);
+    } catch (err) {
+    }
+    if (pathname.endsWith("/")) {
+      if (assetEntry = await findAssetEntryForPath(`${pathname}index.html`)) {
+        return serveAsset(assetEntry);
+      } else if (pathname.endsWith("/index/")) {
+        return new PermanentRedirectResponse(
+          `/${pathname.slice(1, -"index/".length)}${search}`
+        );
+      } else if (assetEntry = await findAssetEntryForPath(
+        `${pathname.replace(/\/$/, ".html")}`
+      )) {
+        return new PermanentRedirectResponse(
+          `/${pathname.slice(1, -1)}${search}`
+        );
+      } else {
+        return notFound();
+      }
+    }
+    if (assetEntry = await findAssetEntryForPath(pathname)) {
+      if (pathname.endsWith(".html")) {
+        const extensionlessPath = pathname.slice(0, -".html".length);
+        if (extensionlessPath.endsWith("/index")) {
+          return new PermanentRedirectResponse(
+            `${extensionlessPath.replace(/\/index$/, "/")}${search}`
+          );
+        } else if (await findAssetEntryForPath(extensionlessPath) || extensionlessPath === "/") {
+          return serveAsset(assetEntry);
+        } else {
+          return new PermanentRedirectResponse(`${extensionlessPath}${search}`);
+        }
+      } else {
+        return serveAsset(assetEntry);
+      }
+    } else if (pathname.endsWith("/index")) {
+      return new PermanentRedirectResponse(
+        `/${pathname.slice(1, -"index".length)}${search}`
+      );
+    } else if (assetEntry = await findAssetEntryForPath(`${pathname}.html`)) {
+      return serveAsset(assetEntry);
+    } else if (hasFileExtension(pathname)) {
+      return notFound();
+    }
+    if (assetEntry = await findAssetEntryForPath(`${pathname}/index.html`)) {
+      return new PermanentRedirectResponse(`${pathname}/${search}`);
+    } else {
+      return notFound();
+    }
+  }
+  async function attachHeaders(response) {
+    const existingHeaders = new Headers(response.headers);
+    const extraHeaders = new Headers({
+      "access-control-allow-origin": "*",
+      "referrer-policy": "strict-origin-when-cross-origin",
+      ...existingHeaders.has("content-type") ? { "x-content-type-options": "nosniff" } : {}
+    });
+    const headers = new Headers({
+      ...Object.fromEntries(existingHeaders.entries()),
+      ...Object.fromEntries(extraHeaders.entries())
+    });
+    const headersMatcher = generateRulesMatcher(
+      headerRules,
+      ({ set = {}, unset = [] }, replacements) => {
+        const replacedSet = {};
+        Object.keys(set).forEach((key) => {
+          replacedSet[key] = replacer(set[key], replacements);
+        });
+        return {
+          set: replacedSet,
+          unset
+        };
+      }
+    );
+    const matches = headersMatcher({ request });
+    const setMap = /* @__PURE__ */ new Set();
+    matches.forEach(({ set = {}, unset = [] }) => {
+      Object.keys(set).forEach((key) => {
+        if (setMap.has(key.toLowerCase())) {
+          headers.append(key, set[key]);
+        } else {
+          headers.set(key, set[key]);
+          setMap.add(key.toLowerCase());
+        }
+      });
+      unset.forEach((key) => {
+        headers.delete(key);
+      });
+    });
+    if (earlyHintsCache) {
+      const preEarlyHintsHeaders = new Headers(headers);
+      const earlyHintsCacheKey = `${protocol}//${host}${pathname}`;
+      const earlyHintsResponse = await earlyHintsCache.match(
+        earlyHintsCacheKey
+      );
+      if (earlyHintsResponse) {
+        const earlyHintsLinkHeader = earlyHintsResponse.headers.get("Link");
+        if (earlyHintsLinkHeader) {
+          headers.set("Link", earlyHintsLinkHeader);
+        }
+      }
+      const clonedResponse = response.clone();
+      if (waitUntil) {
+        waitUntil(
+          (async () => {
+            try {
+              const links = [];
+              const transformedResponse = new HTMLRewriter().on("link[rel=preconnect],link[rel=preload]", {
+                element(element) {
+                  const href = element.getAttribute("href") || void 0;
+                  const rel = element.getAttribute("rel") || void 0;
+                  const as = element.getAttribute("as") || void 0;
+                  if (href && !href.startsWith("data:") && rel) {
+                    links.push({ href, rel, as });
+                  }
+                }
+              }).transform(clonedResponse);
+              await transformedResponse.text();
+              links.forEach(({ href, rel, as }) => {
+                let link = `<${href}>; rel="${rel}"`;
+                if (as) {
+                  link += `; as=${as}`;
+                }
+                preEarlyHintsHeaders.append("Link", link);
+              });
+              const linkHeader = preEarlyHintsHeaders.get("Link");
+              if (linkHeader) {
+                await earlyHintsCache.put(
+                  earlyHintsCacheKey,
+                  new Response(null, { headers: { Link: linkHeader } })
+                );
+              }
+            } catch (err) {
+            }
+          })()
+        );
+      }
+    }
+    return new Response(
+      [101, 204, 205, 304].includes(response.status) ? null : response.body,
+      {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+      }
+    );
+  }
+  return await attachHeaders(await generateResponse());
+  async function serveAsset(servingAssetEntry, options = { preserve: true }) {
+    let content;
+    try {
+      content = negotiateContent(request, servingAssetEntry);
+    } catch (err) {
+      return new NotAcceptableResponse();
+    }
+    const assetKey = getAssetKey(servingAssetEntry, content);
+    const etag = `"${assetKey}"`;
+    const weakEtag = `W/${etag}`;
+    const ifNoneMatch = request.headers.get("if-none-match");
+    if (ifNoneMatch === weakEtag || ifNoneMatch === etag) {
+      return new NotModifiedResponse();
+    }
+    try {
+      const asset = await fetchAsset(assetKey);
+      const headers = {
+        etag,
+        "content-type": asset.contentType
+      };
+      let encodeBody = "automatic";
+      if (xServerEnvHeader) {
+        headers["x-server-env"] = xServerEnvHeader;
+      }
+      if (content.encoding) {
+        encodeBody = "manual";
+        headers["cache-control"] = "no-transform";
+        headers["content-encoding"] = content.encoding;
+      }
+      const response = new OkResponse(
+        request.method === "HEAD" ? null : asset.body,
+        {
+          headers,
+          encodeBody
+        }
+      );
+      if (isCacheable(request)) {
+        response.headers.append("cache-control", CACHE_CONTROL_BROWSER);
+      }
+      attachAdditionalHeaders(response, content, servingAssetEntry, asset);
+      if (isPreview(new URL(request.url))) {
+        response.headers.set("x-robots-tag", "noindex");
+      }
+      if (options.preserve) {
+        const preservedResponse = new Response(
+          [101, 204, 205, 304].includes(response.status) ? null : response.clone().body,
+          response
+        );
+        preservedResponse.headers.set(
+          "cache-control",
+          CACHE_CONTROL_PRESERVATION
+        );
+        preservedResponse.headers.set("x-robots-tag", "noindex");
+        if (waitUntil && caches) {
+          waitUntil(
+            caches.open(ASSET_PRESERVATION_CACHE).then(
+              (assetPreservationCache) => assetPreservationCache.put(request.url, preservedResponse)
+            ).catch((err) => {
+              logError(err);
+            })
+          );
+        }
+      }
+      if (asset.contentType.startsWith("text/html") && metadata.analytics?.version === ANALYTICS_VERSION) {
+        return new HTMLRewriter().on("body", {
+          element(e) {
+            e.append(
+              `<!-- Cloudflare Pages Analytics --><script defer src='https://static.cloudflareinsights.com/beacon.min.js' data-cf-beacon='{"token": "${metadata.analytics?.token}"}'><\/script><!-- Cloudflare Pages Analytics -->`,
+              { html: true }
+            );
+          }
+        }).transform(response);
+      }
+      return response;
+    } catch (err) {
+      logError(err);
+      return new InternalServerErrorResponse(err);
+    }
+  }
+  async function notFound() {
+    if (caches) {
+      const assetPreservationCache = await caches.open(
+        ASSET_PRESERVATION_CACHE
+      );
+      const preservedResponse = await assetPreservationCache.match(request.url);
+      if (preservedResponse) {
+        return preservedResponse;
+      }
+    }
+    let cwd = pathname;
+    while (cwd) {
+      cwd = cwd.slice(0, cwd.lastIndexOf("/"));
+      if (assetEntry = await findAssetEntryForPath(`${cwd}/404.html`)) {
+        let content;
+        try {
+          content = negotiateContent(request, assetEntry);
+        } catch (err) {
+          return new NotAcceptableResponse();
+        }
+        const assetKey = getAssetKey(assetEntry, content);
+        try {
+          const { body, contentType } = await fetchAsset(assetKey);
+          const response = new NotFoundResponse(body);
+          response.headers.set("content-type", contentType);
+          return response;
+        } catch (err) {
+          logError(err);
+          return new InternalServerErrorResponse(err);
+        }
+      }
+    }
+    return await generateNotFoundResponse(
+      request,
+      findAssetEntryForPath,
+      serveAsset
+    );
+  }
+}
+export function parseQualityWeightedList(list = "") {
+  const items = {};
+  list.replace(/\s/g, "").split(",").forEach((el) => {
+    const [item, weight] = el.split(";q=");
+    items[item] = weight ? parseFloat(weight) : 1;
+  });
+  return items;
+}
+function isCacheable(request) {
+  return !request.headers.has("authorization") && !request.headers.has("range");
+}
+function hasFileExtension(path) {
+  return /\/.+\.[a-z0-9]+$/i.test(path);
+}
+function isPreview(url) {
+  if (url.hostname.endsWith(".pages.dev")) {
+    return url.hostname.split(".").length > 3 ? true : false;
+  }
+  return false;
+}

package/dist/asset-server/patchUrl.js

@@ -0,0 +1,15 @@
+globalThis.URL = function(globalURL) {
+  PatchedURL.prototype = globalURL.prototype;
+  PatchedURL.createObjectURL = globalURL.createObjectURL;
+  PatchedURL.revokeObjectURL = globalURL.revokeObjectURL;
+  return PatchedURL;
+  function PatchedURL(input, base) {
+    const url = new URL(encodeURI(input), base);
+    return new Proxy(url, {
+      get(target, prop) {
+        return globalThis.decodeURIComponent(target[prop]);
+      }
+    });
+  }
+}(URL);
+export {};

package/dist/asset-server/responses.js

@@ -0,0 +1,123 @@
+function mergeHeaders(base, extra) {
+  base = new Headers(base ?? {});
+  extra = new Headers(extra ?? {});
+  return new Headers({
+    ...Object.fromEntries(base.entries()),
+    ...Object.fromEntries(extra.entries())
+  });
+}
+export class OkResponse extends Response {
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: 200,
+      statusText: "OK"
+    });
+  }
+}
+export class MovedPermanentlyResponse extends Response {
+  constructor(location, init) {
+    super(`Redirecting to ${location}`, {
+      ...init,
+      status: 301,
+      statusText: "Moved Permanently",
+      headers: mergeHeaders(init?.headers, {
+        location
+      })
+    });
+  }
+}
+export class FoundResponse extends Response {
+  constructor(location, init) {
+    super(`Redirecting to ${location}`, {
+      ...init,
+      status: 302,
+      statusText: "Found",
+      headers: mergeHeaders(init?.headers, {
+        location
+      })
+    });
+  }
+}
+export class NotModifiedResponse extends Response {
+  constructor(...[_body, _init]) {
+    super(void 0, {
+      status: 304,
+      statusText: "Not Modified"
+    });
+  }
+}
+export class PermanentRedirectResponse extends Response {
+  constructor(location, init) {
+    super(void 0, {
+      ...init,
+      status: 308,
+      statusText: "Permanent Redirect",
+      headers: mergeHeaders(init?.headers, {
+        location
+      })
+    });
+  }
+}
+export class NotFoundResponse extends Response {
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: 404,
+      statusText: "Not Found"
+    });
+  }
+}
+export class MethodNotAllowedResponse extends Response {
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: 405,
+      statusText: "Method Not Allowed"
+    });
+  }
+}
+export class NotAcceptableResponse extends Response {
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: 406,
+      statusText: "Not Acceptable"
+    });
+  }
+}
+export class InternalServerErrorResponse extends Response {
+  constructor(err, init) {
+    let body = void 0;
+    if (globalThis.DEBUG) {
+      body = `${err.message}
+
+${err.stack}`;
+    }
+    super(body, {
+      ...init,
+      status: 500,
+      statusText: "Internal Server Error"
+    });
+  }
+}
+export class SeeOtherResponse extends Response {
+  constructor(location, init) {
+    super(`Redirecting to ${location}`, {
+      ...init,
+      status: 303,
+      statusText: "See Other",
+      headers: mergeHeaders(init?.headers, { location })
+    });
+  }
+}
+export class TemporaryRedirectResponse extends Response {
+  constructor(location, init) {
+    super(`Redirecting to ${location}`, {
+      ...init,
+      status: 307,
+      statusText: "Temporary Redirect",
+      headers: mergeHeaders(init?.headers, { location })
+    });
+  }
+}

package/dist/asset-server/rulesEngine.js

@@ -0,0 +1,44 @@
+const ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
+const escapeRegex = (str) => {
+  return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
+};
+const HOST_PLACEHOLDER_REGEX = /(?<=^https:\\\/\\\/[^/]*?):([^\\]+)(?=\\)/g;
+const PLACEHOLDER_REGEX = /:(\w+)/g;
+export const replacer = (str, replacements) => {
+  for (const [replacement, value] of Object.entries(replacements)) {
+    str = str.replaceAll(`:${replacement}`, value);
+  }
+  return str;
+};
+export const generateRulesMatcher = (rules, replacerFn = (match) => match) => {
+  if (!rules)
+    return () => [];
+  const compiledRules = Object.entries(rules).map(([rule, match]) => {
+    const crossHost = rule.startsWith("https://");
+    rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
+    const host_matches = rule.matchAll(HOST_PLACEHOLDER_REGEX);
+    for (const host_match of host_matches) {
+      rule = rule.split(host_match[0]).join(`(?<${host_match[1]}>[^/.]+)`);
+    }
+    const path_matches = rule.matchAll(PLACEHOLDER_REGEX);
+    for (const path_match of path_matches) {
+      rule = rule.split(path_match[0]).join(`(?<${path_match[1]}>[^/]+)`);
+    }
+    rule = "^" + rule + "$";
+    try {
+      const regExp = new RegExp(rule);
+      return [{ crossHost, regExp }, match];
+    } catch {
+    }
+  }).filter((value) => value !== void 0);
+  return ({ request }) => {
+    const { pathname, host } = new URL(request.url);
+    return compiledRules.map(([{ crossHost, regExp }, match]) => {
+      const test = crossHost ? `https://${host}${pathname}` : pathname;
+      const result = regExp.exec(test);
+      if (result) {
+        return replacerFn(match, result.groups || {});
+      }
+    }).filter((value) => value !== void 0);
+  };
+};

package/dist/environment-polyfills/index.js

@@ -0,0 +1,10 @@
+export const polyfill = (environment) => {
+  Object.entries(environment).map(([name, value]) => {
+    Object.defineProperty(globalThis, name, {
+      value,
+      configurable: true,
+      enumerable: true,
+      writable: true
+    });
+  });
+};

package/dist/environment-polyfills/miniflare.js

@@ -0,0 +1,13 @@
+import {
+  fetch as miniflareFetch,
+  Headers as MiniflareHeaders,
+  Request as MiniflareRequest,
+  Response as MiniflareResponse
+} from "@miniflare/core";
+import { polyfill } from ".";
+polyfill({
+  fetch: miniflareFetch,
+  Headers: MiniflareHeaders,
+  Request: MiniflareRequest,
+  Response: MiniflareResponse
+});

package/dist/environment-polyfills/types.js

@@ -0,0 +1 @@
+export {};

package/dist/metadata-generator/createMetadataObject.js

@@ -10,7 +10,7 @@ export function createMetadataObject({
   headers,
   webAnalyticsToken,
   deploymentId,
-  logger = () => {
+  logger = (_message) => {
   }
 }) {
   return {

package/package.json

@@ -1,8 +1,9 @@
 {
 	"name": "@cloudflare/pages-shared",
-	"version": "0.0.1",
+	"version": "0.0.4",
 	"files": [
 		"tsconfig.json",
+		"src/**/*",
 		"dist/**/*"
 	],
 	"scripts": {
@@ -34,9 +35,15 @@
 			"node_modules/(?!find-up|locate-path|p-locate|p-limit|p-timeout|p-queue|yocto-queue|path-exists|execa|strip-final-newline|npm-run-path|path-key|onetime|mimic-fn|human-signals|is-stream|get-port|supports-color|pretty-bytes)"
 		]
 	},
+	"dependencies": {
+		"@miniflare/core": "2.8.1"
+	},
 	"devDependencies": {
-		"@cloudflare/workers-types": "^3.16.0",
+		"@miniflare/cache": "2.8.1",
+		"@miniflare/html-rewriter": "2.8.1",
+		"@types/service-worker-mock": "^2.0.1",
 		"concurrently": "^7.3.0",
-		"glob": "^8.0.3"
+		"glob": "^8.0.3",
+		"service-worker-mock": "^2.0.5"
 	}
 }