@aryanbansal-launch/edge-utils 0.1.0

package/dist/auth/basic-auth.js

@@ -0,0 +1,29 @@
+export function protectWithBasicAuth(request, options) {
+    const url = new URL(request.url);
+    if (!url.hostname.includes(options.hostnameIncludes)) {
+        return null;
+    }
+    const authHeader = request.headers.get("Authorization");
+    if (!authHeader || !authHeader.startsWith("Basic ")) {
+        return Promise.resolve(new Response("Authentication Required", {
+            status: 401,
+            headers: {
+                "WWW-Authenticate": `Basic realm="${options.realm ?? "Protected Area"}"`,
+                "Content-Type": "text/html"
+            }
+        }));
+    }
+    try {
+        const base64Credentials = authHeader.split(" ")[1];
+        const credentials = atob(base64Credentials);
+        const [username, password] = credentials.split(":");
+        if (username === options.username &&
+            password === options.password) {
+            return fetch(request);
+        }
+        return Promise.resolve(new Response("Unauthorized - Invalid credentials", { status: 401 }));
+    }
+    catch {
+        return Promise.resolve(new Response("Unauthorized - Invalid auth format", { status: 401 }));
+    }
+}

package/dist/geo/geo-headers.js

@@ -0,0 +1,9 @@
+export function getGeoHeaders(request) {
+    return {
+        country: request.headers.get("x-country-code"),
+        region: request.headers.get("x-region-code"),
+        city: request.headers.get("x-city"),
+        latitude: request.headers.get("x-latitude"),
+        longitude: request.headers.get("x-longitude")
+    };
+}

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./response/json.js";
+export * from "./response/passthrough.js";
+export * from "./redirect/redirect.js";
+export * from "./auth/basic-auth.js";
+export * from "./security/ip-access.js";
+export * from "./security/block-bots.js";
+export * from "./geo/geo-headers.js";

package/dist/redirect/redirect.js

@@ -0,0 +1,9 @@
+export function redirectIfMatch(request, options) {
+    const url = new URL(request.url);
+    if (url.pathname === options.path &&
+        (!options.method || request.method === options.method)) {
+        url.pathname = options.to;
+        return Response.redirect(url, options.status ?? 301);
+    }
+    return null;
+}

package/dist/response/json.js

@@ -0,0 +1,6 @@
+export function jsonResponse(body, init) {
+    return new Response(JSON.stringify(body), {
+        headers: { "Content-Type": "application/json" },
+        ...init
+    });
+}

package/dist/response/passthrough.js

@@ -0,0 +1,3 @@
+export function passThrough(request) {
+    return fetch(request);
+}

package/dist/security/block-bots.js

@@ -0,0 +1,19 @@
+const DEFAULT_BOTS = [
+    "claudebot",
+    "gptbot",
+    "googlebot",
+    "bingbot",
+    "ahrefsbot",
+    "yandexbot",
+    "semrushbot",
+    "mj12bot",
+    "facebookexternalhit",
+    "twitterbot"
+];
+export function blockAICrawlers(request, bots = DEFAULT_BOTS) {
+    const ua = (request.headers.get("user-agent") || "").toLowerCase();
+    if (bots.some(bot => ua.includes(bot))) {
+        return new Response("Forbidden: AI crawlers are not allowed.", { status: 403 });
+    }
+    return null;
+}

package/dist/security/ip-access.js

@@ -0,0 +1,13 @@
+import { getClientIP } from "../utils/ip.js";
+export function ipAccessControl(request, options) {
+    const ip = getClientIP(request);
+    if (!ip)
+        return null;
+    if (options.deny?.includes(ip)) {
+        return new Response("Forbidden", { status: 403 });
+    }
+    if (options.allow && !options.allow.includes(ip)) {
+        return new Response("Forbidden", { status: 403 });
+    }
+    return null;
+}

package/dist/utils/ip.js

@@ -0,0 +1,6 @@
+export function getClientIP(request) {
+    const xff = request.headers.get("x-forwarded-for");
+    if (!xff)
+        return null;
+    return xff.split(",")[0].trim();
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@aryanbansal-launch/edge-utils",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc"
+  }
+}

package/readme.md

@@ -0,0 +1,109 @@
+# Edge Utils
+
+A collection of high-performance utilities designed for Edge Computing environments (like Cloudflare Workers, Vercel Edge Functions, or Contentstack Launch). These utilities help you handle common tasks like authentication, security, redirection, and geo-location directly at the edge.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage Example](#usage-example)
+- [API Reference](#api-reference)
+  - [Security](#security)
+  - [Authentication](#authentication)
+  - [Redirection](#redirection)
+  - [Geo Location](#geo-location)
+  - [Responses](#responses)
+
+## Installation
+
+Install the package via npm:
+
+```bash
+npm install @launch/edge-utils
+```
+
+## Usage Example
+
+Here is a comprehensive example of how to use multiple utilities in a single edge handler:
+
+```typescript
+import {
+  jsonResponse,
+  passThrough,
+  redirectIfMatch,
+  protectWithBasicAuth,
+  ipAccessControl,
+  blockAICrawlers,
+  getGeoHeaders
+} from "@launch/edge-utils";
+
+export default async function handler(request: Request) {
+  // 1. Block known AI crawlers and bots
+  const botResponse = blockAICrawlers(request);
+  if (botResponse) return botResponse;
+
+  // 2. IP-based access control
+  const ipResponse = ipAccessControl(request, { allow: ["203.0.113.10"] });
+  if (ipResponse) return ipResponse;
+
+  // 3. Basic Authentication for specific hostnames
+  const authResponse = await protectWithBasicAuth(request, {
+    hostnameIncludes: "test-protected-domain.dev",
+    username: "admin",
+    password: "securepassword"
+  });
+  if (authResponse && authResponse.status === 401) return authResponse;
+
+  // 4. Conditional Redirection
+  const redirectResponse = redirectIfMatch(request, {
+    path: "/old-page",
+    method: "GET",
+    to: "/new-page"
+  });
+  if (redirectResponse) return redirectResponse;
+
+  // 5. Handle specific routes
+  if (new URL(request.url).pathname === "/api/status") {
+    return jsonResponse({ status: "ok", timestamp: new Date() });
+  }
+
+  // 6. Access Geo-location headers
+  const geo = getGeoHeaders(request);
+  console.log("Request from country:", geo.country);
+
+  // 7. Pass through the request if no utility intercepted it
+  return passThrough(request);
+}
+```
+
+## API Reference
+
+### Security
+
+#### `blockAICrawlers(request: Request, bots?: string[]): Response | null`
+Blocks common AI crawlers (like GPTBot, ClaudeBot) based on the `User-Agent` header. Returns a `403 Forbidden` response if a bot is detected, otherwise returns `null`.
+
+#### `ipAccessControl(request: Request, options: { allow?: string[], deny?: string[] }): Response | null`
+Restricts access based on the client's IP address. You can provide an `allow` list or a `deny` list.
+
+### Authentication
+
+#### `protectWithBasicAuth(request: Request, options: AuthOptions): Promise<Response> | null`
+Implements HTTP Basic Authentication. If the hostname matches `hostnameIncludes` and credentials are missing or invalid, it returns a `401 Unauthorized` response with the appropriate headers.
+
+### Redirection
+
+#### `redirectIfMatch(request: Request, options: RedirectOptions): Response | null`
+Redirects the request if the URL path and HTTP method match the provided options.
+
+### Geo Location
+
+#### `getGeoHeaders(request: Request): Record<string, string | null>`
+Extracts geo-location information (country, city, region, etc.) from the request headers typically provided by edge platforms.
+
+### Responses
+
+#### `jsonResponse(data: any, init?: ResponseInit): Response`
+A helper to return a JSON response with the correct `Content-Type` header.
+
+#### `passThrough(request: Request): Response`
+Continues the request processing by calling `fetch(request)`. Useful at the end of an edge function.