@just-be/wildcard 0.4.0 → 0.6.0

package/README.md

@@ -4,14 +4,14 @@ Portable wildcard subdomain routing library with pluggable storage backends. Rou
 
 ## Features
 
-- 🔌 **Pluggable storage backends** - Use any file storage (R2, S3, filesystem, etc.)
-- 🔒 **Security built-in** - SSRF protection, path traversal prevention, safe header filtering
-- 📦 **Three routing modes**:
+- **Pluggable storage backends** - Use any file storage (R2, S3, filesystem, etc.)
+- **Security built-in** - SSRF protection, path traversal prevention, safe header filtering
+- **Three routing modes**:
   - **Static** - Serve files from any storage backend with SPA mode and custom 404s
   - **Redirect** - 301/302 redirects to external URLs
   - **Rewrite** - Proxy requests to external services
-- 🏗️ **Framework-agnostic** - Works with Cloudflare Workers, Node.js, Deno, Bun, etc.
-- ✅ **Type-safe** - Full TypeScript support with Zod validation
+- **Framework-agnostic** - Works with Cloudflare Workers, Node.js, Deno, Bun, etc.
+- **Type-safe** - Full TypeScript support with Zod validation
 
 ## Installation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@just-be/wildcard",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Portable wildcard subdomain routing with pluggable storage backends",
   "type": "module",
   "main": "./src/index.ts",

package/src/handlers/redirect.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "bun:test";
+import { handleRedirect } from "./redirect";
+import type { RedirectConfig } from "../schemas";
+
+function makeRequest(url: string): Request {
+  return new Request(url);
+}
+
+describe("handleRedirect", () => {
+  it("should redirect with 302 by default", async () => {
+    const config: RedirectConfig = { type: "redirect", url: "https://example.com" };
+    const response = await handleRedirect(makeRequest("https://sub.just-be.dev/"), config);
+    expect(response.status).toBe(302);
+    expect(response.headers.get("location")).toBe("https://example.com");
+  });
+
+  it("should redirect with 301 when permanent is true", async () => {
+    const config: RedirectConfig = {
+      type: "redirect",
+      url: "https://example.com",
+      permanent: true,
+    };
+    const response = await handleRedirect(makeRequest("https://sub.just-be.dev/"), config);
+    expect(response.status).toBe(301);
+    expect(response.headers.get("location")).toBe("https://example.com");
+  });
+
+  it("should redirect with 302 when permanent is false", async () => {
+    const config: RedirectConfig = {
+      type: "redirect",
+      url: "https://example.com",
+      permanent: false,
+    };
+    const response = await handleRedirect(makeRequest("https://sub.just-be.dev/"), config);
+    expect(response.status).toBe(302);
+  });
+
+  describe("preservePath", () => {
+    it("should append path to target URL", async () => {
+      const config: RedirectConfig = {
+        type: "redirect",
+        url: "https://github.com/just-be-dev",
+        permanent: true,
+        preservePath: true,
+      };
+      const response = await handleRedirect(makeRequest("https://git.just-be.dev/pds"), config);
+      expect(response.status).toBe(301);
+      expect(response.headers.get("location")).toBe("https://github.com/just-be-dev/pds");
+    });
+
+    it("should preserve query string", async () => {
+      const config: RedirectConfig = {
+        type: "redirect",
+        url: "https://github.com/just-be-dev",
+        preservePath: true,
+      };
+      const response = await handleRedirect(
+        makeRequest("https://git.just-be.dev/pds?tab=readme"),
+        config
+      );
+      expect(response.headers.get("location")).toBe(
+        "https://github.com/just-be-dev/pds?tab=readme"
+      );
+    });
+
+    it("should handle root path request", async () => {
+      const config: RedirectConfig = {
+        type: "redirect",
+        url: "https://github.com/just-be-dev",
+        preservePath: true,
+      };
+      const response = await handleRedirect(makeRequest("https://git.just-be.dev/"), config);
+      expect(response.headers.get("location")).toBe("https://github.com/just-be-dev/");
+    });
+
+    it("should handle target URL with trailing slash", async () => {
+      const config: RedirectConfig = {
+        type: "redirect",
+        url: "https://github.com/just-be-dev/",
+        preservePath: true,
+      };
+      const response = await handleRedirect(makeRequest("https://git.just-be.dev/pds"), config);
+      expect(response.headers.get("location")).toBe("https://github.com/just-be-dev/pds");
+    });
+
+    it("should not preserve path when preservePath is not set", async () => {
+      const config: RedirectConfig = {
+        type: "redirect",
+        url: "https://example.com",
+      };
+      const response = await handleRedirect(
+        makeRequest("https://sub.just-be.dev/some/path"),
+        config
+      );
+      expect(response.headers.get("location")).toBe("https://example.com");
+    });
+  });
+});

package/src/handlers/redirect.ts

@@ -1,7 +1,16 @@
 import type { Handler } from "../types";
 import type { RedirectConfig } from "../schemas";
 
-export const handleRedirect: Handler<RedirectConfig> = async (_request, config) => {
+export const handleRedirect: Handler<RedirectConfig> = async (request, config) => {
   const status = config.permanent ? 301 : 302;
+
+  if (config.preservePath) {
+    const originalUrl = new URL(request.url);
+    const targetUrl = new URL(config.url);
+    targetUrl.pathname = targetUrl.pathname.replace(/\/$/, "") + originalUrl.pathname;
+    targetUrl.search = originalUrl.search;
+    return Response.redirect(targetUrl.toString(), status);
+  }
+
   return Response.redirect(config.url, status);
 };

package/src/handlers/static.ts

@@ -22,14 +22,15 @@ export const handleStatic: Handler<StaticConfig, { fileLoader: FileLoader }> = a
   const basePath = subdomain;
 
   return spa
-    ? handleSpaMode(fileLoader, basePath, url.pathname)
-    : handleStaticMode(fileLoader, basePath, url.pathname, fallback);
+    ? handleSpaMode(fileLoader, basePath, url.pathname, request)
+    : handleStaticMode(fileLoader, basePath, url.pathname, request, fallback);
 };
 
 async function handleSpaMode(
   fileLoader: FileLoader,
   basePath: string,
-  pathname: string
+  pathname: string,
+  request: Request
 ): Promise<Response> {
   // Sanitize paths to prevent directory traversal
   const sanitizedBase = sanitizePath(basePath);
@@ -53,7 +54,7 @@ async function handleSpaMode(
     const fileObject = await fileLoader.loadFile(key);
 
     if (fileObject) {
-      return buildFileResponse(fileObject, key);
+      return buildFileResponse(fileObject, key, request);
     }
   }
 
@@ -70,13 +71,14 @@ async function handleSpaMode(
     return new Response("File not found", { status: 404 });
   }
 
-  return buildFileResponse(indexFile, indexKey);
+  return buildFileResponse(indexFile, indexKey, request);
 }
 
 async function handleStaticMode(
   fileLoader: FileLoader,
   basePath: string,
   pathname: string,
+  request: Request,
   fallback?: string
 ): Promise<Response> {
   // Sanitize paths to prevent directory traversal
@@ -99,7 +101,7 @@ async function handleStaticMode(
   const fileObject = await fileLoader.loadFile(key);
 
   if (fileObject) {
-    return buildFileResponse(fileObject, key);
+    return buildFileResponse(fileObject, key, request);
   }
 
   // Try fallback if configured
@@ -113,14 +115,14 @@ async function handleStaticMode(
     const fallbackObject = await fileLoader.loadFile(fallbackKey);
 
     if (fallbackObject) {
-      return buildFileResponse(fallbackObject, fallbackKey);
+      return buildFileResponse(fallbackObject, fallbackKey, request);
     }
   }
 
   return new Response("File not found", { status: 404 });
 }
 
-function buildFileResponse(fileObject: FileObject, key: string): Response {
+function buildFileResponse(fileObject: FileObject, key: string, request: Request): Response {
   const headers = new Headers(fileObject.headers);
 
   if (fileObject.etag) {
@@ -148,8 +150,16 @@ function buildFileResponse(fileObject: FileObject, key: string): Response {
   }
 
   // Cache control with Vary header for cache poisoning prevention
-  headers.set("Cache-Control", "public, max-age=3600");
+  headers.set("Cache-Control", "public, max-age=3600"); // 1 hour browser cache
+  headers.set("CDN-Cache-Control", "public, max-age=604800"); // 7 days edge cache
   headers.set("Vary", "Accept-Encoding");
 
+  // Handle conditional requests (If-None-Match)
+  const ifNoneMatch = request.headers.get("If-None-Match");
+  if (ifNoneMatch && fileObject.etag && ifNoneMatch === fileObject.etag) {
+    // Return 304 Not Modified with headers but no body
+    return new Response(null, { status: 304, headers });
+  }
+
   return new Response(fileObject.body, { headers });
 }

package/src/schemas.ts

@@ -46,6 +46,7 @@ export const RedirectConfigSchema = z.object({
   type: z.literal("redirect"),
   url: safeUrl(),
   permanent: z.boolean().optional(),
+  preservePath: z.boolean().optional(),
 });
 
 export const RewriteConfigSchema = z.object({