digivalt-uworker 0.1.0

package/.dev.vars.example

@@ -0,0 +1,3 @@
+# Copy to .dev.vars for `npm run dev`
+ORIGIN=https://example.pages.dev
+BASE_PATH=/landing-page

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog – digivalt-uworker
+
+High-level log of notable work for this Worker.
+
+---
+
+## 2026-07
+
+### v0.1.0 — initial path proxy
+
+- Configurable `ORIGIN` + `BASE_PATH` reverse proxy to DigiValt Cloudflare Pages.
+- Strips public base path on upstream requests; rewrites `Location` and light HTML `href`/`src`/`action`.
+- Pass-through for Pages Functions (`/api/*`, sitemap, static assets) after path mapping.
+- Docs: consumer Vite `base` + router `basename` + digivalt-core `withBasePath` checklist.

package/README.md

@@ -0,0 +1,63 @@
+# digivalt-uworker
+
+Thin Cloudflare Worker that mounts a **DigiValt Cloudflare Pages** origin under a path on another hostname (typically a public WordPress site).
+
+Example: DigiValt on `https://my-landing.pages.dev` served at `https://domain.tld/landing-page`.
+
+## Why
+
+Cloudflare Pages custom domains are hostname-only. This worker adds path-based publishing without migrating DigiValt to Workers.
+
+## Environment
+
+| Variable | Example | Notes |
+|----------|---------|--------|
+| `ORIGIN` | `https://my-landing.pages.dev` | Pages origin, no trailing slash |
+| `BASE_PATH` | `/landing-page` | Public path, leading slash, no trailing slash |
+
+Set via Wrangler `[vars]`, dashboard, or `.dev.vars` locally (see `.dev.vars.example`).
+
+## DigiValt consumer checklist
+
+The worker strips/prefixes paths and lightly rewrites HTML `href`/`src`/`action`. It does **not** fix React Router or Vite asset URLs inside JS bundles. The DigiValt app must be built for the same path:
+
+1. Vite: `base: '/landing-page/'` (e.g. from `VITE_BASE_PATH`)
+2. React Router: `BrowserRouter basename="/landing-page"`
+3. SEO: `VITE_SEO_SITE_URL=https://domain.tld/landing-page`
+4. Forms / Pages Functions: use `@marvalt/digivalt-core` **≥ 0.2.27** so `/api/*` calls use `import.meta.env.BASE_URL` (`withBasePath`)
+
+One Pages build = one base path. Visiting the Pages apex (`*.pages.dev/`) will look blank; `*.pages.dev/landing-page/` usually works. Treat Pages as a private origin.
+
+`digivalt-landing` stays root-hosted; use a separate DigiValt project for path mounts.
+
+## Cloudflare route
+
+On the customer zone (proxied):
+
+- Route: `domain.tld/landing-page*` → this Worker
+- Apex / other paths → WordPress (or existing origin)
+
+## Develop
+
+```bash
+cp .dev.vars.example .dev.vars
+# edit ORIGIN + BASE_PATH
+npm install
+npm run dev
+```
+
+Open `http://127.0.0.1:8787/landing-page` (port may vary).
+
+## Deploy
+
+```bash
+npm install
+npx wrangler secret / vars  # or set [vars] in wrangler.toml per env
+npm run deploy
+```
+
+Then attach the zone route in the Cloudflare dashboard (or `routes` in `wrangler.toml`).
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md).

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "digivalt-uworker",
+  "version": "0.1.0",
+  "description": "Universal Cloudflare Worker: mount a DigiValt Pages origin under a path prefix",
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "types": "wrangler types"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^5.20260714.1",
+    "typescript": "^5.8.3",
+    "wrangler": "^4.24.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,170 @@
+/**
+ * digivalt-uworker — reverse-proxy a DigiValt (Cloudflare Pages) origin under a path.
+ *
+ * Env:
+ *   ORIGIN     — Pages origin, no trailing slash (e.g. https://my-app.pages.dev)
+ *   BASE_PATH  — public path prefix, leading slash, no trailing slash (e.g. /landing-page)
+ */
+
+export interface Env {
+  ORIGIN: string;
+  BASE_PATH: string;
+}
+
+const HOP_BY_HOP = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailers",
+  "transfer-encoding",
+  "upgrade",
+  "host",
+  "cf-connecting-ip",
+  "cf-ray",
+  "cf-visitor",
+  "cf-ipcountry",
+  "x-forwarded-proto",
+  "x-forwarded-for",
+  "x-real-ip",
+]);
+
+function normalizeBasePath(raw: string): string {
+  let p = (raw || "").trim();
+  if (!p) return "";
+  if (!p.startsWith("/")) p = `/${p}`;
+  if (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
+  return p;
+}
+
+function normalizeOrigin(raw: string): string {
+  return (raw || "").trim().replace(/\/+$/, "");
+}
+
+/** Map public pathname to origin pathname, or null if outside BASE_PATH. */
+function toOriginPath(pathname: string, basePath: string): string | null {
+  if (pathname === basePath) return "/";
+  if (pathname.startsWith(`${basePath}/`)) {
+    const rest = pathname.slice(basePath.length);
+    return rest || "/";
+  }
+  return null;
+}
+
+function filterRequestHeaders(src: Headers, originHost: string): Headers {
+  const out = new Headers();
+  src.forEach((value, key) => {
+    if (HOP_BY_HOP.has(key.toLowerCase())) return;
+    out.set(key, value);
+  });
+  out.set("Host", originHost);
+  return out;
+}
+
+function rewriteLocation(
+  location: string,
+  requestUrl: URL,
+  origin: string,
+  basePath: string,
+): string {
+  try {
+    const resolved = new URL(location, origin);
+    const originUrl = new URL(origin);
+    if (resolved.origin !== originUrl.origin) {
+      return location;
+    }
+    const prefixed = `${basePath}${resolved.pathname === "/" ? "" : resolved.pathname}${resolved.search}${resolved.hash}`;
+    return new URL(prefixed || basePath, requestUrl.origin).toString();
+  } catch {
+    return location;
+  }
+}
+
+/** Light HTML rewrite: root-absolute href/src/action under the public base path. */
+function rewriteHtml(html: string, basePath: string): string {
+  const prefix = (path: string) => {
+    if (path.startsWith("//") || path.startsWith("http:") || path.startsWith("https:")) {
+      return path;
+    }
+    if (path === basePath || path.startsWith(`${basePath}/`)) {
+      return path;
+    }
+    if (path.startsWith("/")) {
+      return `${basePath}${path}`;
+    }
+    return path;
+  };
+
+  return html.replace(
+    /\b(href|src|action)=(["'])(\/[^"']*)\2/gi,
+    (_m, attr: string, quote: string, path: string) =>
+      `${attr}=${quote}${prefix(path)}${quote}`,
+  );
+}
+
+async function proxy(request: Request, env: Env): Promise<Response> {
+  const origin = normalizeOrigin(env.ORIGIN);
+  const basePath = normalizeBasePath(env.BASE_PATH);
+
+  if (!origin || !basePath) {
+    return new Response("digivalt-uworker: ORIGIN and BASE_PATH must be set", { status: 500 });
+  }
+
+  const reqUrl = new URL(request.url);
+  const originPath = toOriginPath(reqUrl.pathname, basePath);
+  if (originPath === null) {
+    return new Response("Not Found", { status: 404 });
+  }
+
+  const originUrl = new URL(origin);
+  const target = new URL(originPath + reqUrl.search, origin);
+
+  const headers = filterRequestHeaders(request.headers, originUrl.host);
+  const init: RequestInit & { duplex?: "half" } = {
+    method: request.method,
+    headers,
+    redirect: "manual",
+  };
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    init.body = request.body;
+    init.duplex = "half";
+  }
+
+  const upstream = await fetch(target.toString(), init);
+  const outHeaders = new Headers(upstream.headers);
+
+  const loc = outHeaders.get("Location");
+  if (loc) {
+    outHeaders.set("Location", rewriteLocation(loc, reqUrl, origin, basePath));
+  }
+
+  const contentType = outHeaders.get("Content-Type") || "";
+  if (contentType.includes("text/html") && request.method === "GET") {
+    const html = await upstream.text();
+    const rewritten = rewriteHtml(html, basePath);
+    outHeaders.delete("content-length");
+    return new Response(rewritten, {
+      status: upstream.status,
+      statusText: upstream.statusText,
+      headers: outHeaders,
+    });
+  }
+
+  return new Response(upstream.body, {
+    status: upstream.status,
+    statusText: upstream.statusText,
+    headers: outHeaders,
+  });
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    try {
+      return await proxy(request, env);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return new Response(`digivalt-uworker proxy error: ${message}`, { status: 502 });
+    }
+  },
+};

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "types": ["@cloudflare/workers-types"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/wrangler.toml

@@ -0,0 +1,9 @@
+name = "digivalt-uworker"
+main = "src/index.ts"
+compatibility_date = "2025-07-01"
+
+# Set per environment / dashboard (do not commit secrets).
+# Example:
+# [vars]
+# ORIGIN = "https://my-landing.pages.dev"
+# BASE_PATH = "/landing-page"