@jango-blockchained/hoox-shared 1.0.8

package/dist/middleware/index.js

@@ -0,0 +1,375 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/errors.ts
+function toError(err, fallback = "Unknown error") {
+  if (err instanceof Error)
+    return err.message;
+  if (typeof err === "string")
+    return err;
+  if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
+    return err.message;
+  }
+  if (err === null || err === undefined)
+    return fallback;
+  try {
+    return JSON.stringify(err) || fallback;
+  } catch {
+    return fallback;
+  }
+}
+function sanitizeOutput(data) {
+  if (data instanceof Error) {
+    return { name: data.name, message: data.message };
+  }
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    const sanitized = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (k === "stack" || k === "cause")
+        continue;
+      sanitized[k] = v instanceof Error ? { name: v.name, message: v.message } : sanitizeOutput(v);
+    }
+    return sanitized;
+  }
+  if (Array.isArray(data)) {
+    return data.map(sanitizeOutput);
+  }
+  return data;
+}
+function createJsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(sanitizeOutput(data)), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function createSuccessResponse(result) {
+  return createJsonResponse({ success: true, result }, 200);
+}
+function createErrorResponse(error, status) {
+  const message = typeof error === "string" ? error : error.message;
+  const statusCode = typeof error === "string" ? status ?? 500 : error.status ?? 500;
+  const body = { success: false, error: message };
+  if (typeof error !== "string" && error.code)
+    body.code = error.code;
+  if (typeof error !== "string" && error.details !== undefined)
+    body.details = error.details;
+  return new Response(JSON.stringify(body), {
+    status: statusCode,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+var Errors = {
+  badRequest: (message) => createErrorResponse({ message, status: 400, code: "BAD_REQUEST" }),
+  unauthorized: (message = "Unauthorized") => createErrorResponse({ message, status: 401, code: "UNAUTHORIZED" }),
+  forbidden: (message = "Forbidden") => createErrorResponse({ message, status: 403, code: "FORBIDDEN" }),
+  notFound: (message = "Not found") => createErrorResponse({ message, status: 404, code: "NOT_FOUND" }),
+  methodNotAllowed: (message = "Method not allowed") => createErrorResponse({ message, status: 405, code: "METHOD_NOT_ALLOWED" }),
+  rateLimited: (retryAfter) => {
+    const res = createErrorResponse({
+      message: "Rate limit exceeded",
+      status: 429,
+      code: "RATE_LIMITED"
+    });
+    if (retryAfter)
+      res.headers.set("Retry-After", String(retryAfter));
+    return res;
+  },
+  internal: (err) => {
+    const message = err ? toError(err, "Internal server error") : "Internal server error";
+    return createErrorResponse({
+      message,
+      status: 500,
+      code: "INTERNAL_ERROR"
+    });
+  }
+};
+
+// src/middleware/logger.ts
+function createLogger(ctx) {
+  const base = { service: ctx.service, module: ctx.module };
+  function emit(level, message, context) {
+    const entry = {
+      level,
+      timestamp: new Date().toISOString(),
+      ...base,
+      message,
+      ...context && { context }
+    };
+    const line = JSON.stringify(entry);
+    if (level === "error")
+      console.error(line);
+    else if (level === "warn")
+      console.warn(line);
+    else
+      console.info(line);
+  }
+  return {
+    info: (msg, ctx2) => emit("info", msg, ctx2),
+    warn: (msg, ctx2) => emit("warn", msg, ctx2),
+    error: (msg, ctx2) => emit("error", msg, ctx2)
+  };
+}
+function withRequestLog(handler, logCtx) {
+  return async (request, env, ctx) => {
+    const start = Date.now();
+    const logger = createLogger(logCtx);
+    try {
+      const response = await handler(request, env, ctx);
+      const duration = Date.now() - start;
+      const url = new URL(request.url);
+      logger.info(`${request.method} ${url.pathname}`, {
+        method: request.method,
+        path: url.pathname,
+        status: response.status,
+        durationMs: duration
+      });
+      return response;
+    } catch (error) {
+      const duration = Date.now() - start;
+      logger.error("Request failed", {
+        method: request.method,
+        path: new URL(request.url).pathname,
+        durationMs: duration,
+        error: toError(error)
+      });
+      throw error;
+    }
+  };
+}
+// src/middleware/auth.ts
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  const encoder = new TextEncoder;
+  const aBuf = encoder.encode(a);
+  const bBuf = encoder.encode(b);
+  let result = 0;
+  for (let i = 0;i < aBuf.length; i++) {
+    result |= aBuf[i] ^ bBuf[i];
+  }
+  return result === 0;
+}
+async function requireAuth(request, env) {
+  const apiKey = env.INTERNAL_API_KEY;
+  if (!apiKey) {
+    return new Response(JSON.stringify({ error: "Internal API key not configured" }), { status: 401, headers: { "Content-Type": "application/json" } });
+  }
+  const authHeader = request.headers.get("Authorization");
+  const expectedHeader = `Bearer ${apiKey}`;
+  if (!authHeader || !timingSafeEqual(authHeader, expectedHeader)) {
+    return new Response(JSON.stringify({ error: "Unauthorized" }), {
+      status: 401,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  return null;
+}
+function requireInternalAuth(request, env, keyName = "INTERNAL_KEY_BINDING") {
+  const expectedKey = env[keyName];
+  if (!expectedKey) {
+    return new Response(JSON.stringify({
+      success: false,
+      error: `Internal auth key ${keyName} not configured`
+    }), { status: 401, headers: { "Content-Type": "application/json" } });
+  }
+  const providedKey = request.headers.get("X-Internal-Auth-Key");
+  if (!providedKey || !timingSafeEqual(providedKey, expectedKey)) {
+    return new Response(JSON.stringify({ success: false, error: "Unauthorized" }), { status: 401, headers: { "Content-Type": "application/json" } });
+  }
+  return null;
+}
+function createInternalAuthMiddleware(keyName = "INTERNAL_KEY_BINDING") {
+  return (request, env) => {
+    const result = requireInternalAuth(request, env, keyName);
+    if (result)
+      return result;
+  };
+}
+function checkInternalAuth(request, env, keyName = "INTERNAL_KEY_BINDING") {
+  const expectedKey = env[keyName];
+  if (!expectedKey) {
+    return { authorized: false, error: `${keyName} not configured` };
+  }
+  const providedKey = request.headers.get("X-Internal-Auth-Key");
+  if (!providedKey || !timingSafeEqual(providedKey, expectedKey)) {
+    return { authorized: false, error: "Unauthorized" };
+  }
+  return { authorized: true };
+}
+// src/middleware/rate-limit.ts
+function createRateLimiter(kv, config) {
+  const prefix = config.keyPrefix ?? "rate-limit";
+  function getClientIp(request) {
+    return request.headers.get("CF-Connecting-IP") ?? "unknown";
+  }
+  function getWindowKey(ip) {
+    const windowStart = Math.floor(Date.now() / (config.windowSeconds * 1000));
+    return `${prefix}:${ip}:${windowStart}`;
+  }
+  async function check(request) {
+    const ip = getClientIp(request);
+    const key = getWindowKey(ip);
+    const current = await kv.get(key);
+    const count = current ? parseInt(current, 10) : 0;
+    if (count >= config.maxRequests) {
+      const retryAfter = config.windowSeconds - Date.now() % (config.windowSeconds * 1000) / 1000;
+      return {
+        allowed: false,
+        remaining: 0,
+        retryAfter: Math.ceil(retryAfter)
+      };
+    }
+    await kv.put(key, String(count + 1), {
+      expirationTtl: config.windowSeconds
+    });
+    return { allowed: true, remaining: config.maxRequests - count - 1 };
+  }
+  async function enforce(request) {
+    const result = await check(request);
+    if (!result.allowed) {
+      return new Response(JSON.stringify({
+        error: "Rate limit exceeded",
+        retryAfter: result.retryAfter
+      }), {
+        status: 429,
+        headers: {
+          "Content-Type": "application/json",
+          "Retry-After": String(result.retryAfter ?? config.windowSeconds)
+        }
+      });
+    }
+    return null;
+  }
+  return { check, enforce };
+}
+// src/middleware/validate.ts
+function validateJson(schema, data) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    return {
+      ok: false,
+      error: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")
+    };
+  }
+  return { ok: true, value: result.data };
+}
+async function validateJsonLegacy(request) {
+  try {
+    const body = await request.json();
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+      return { ok: false, error: "Request body must be a JSON object" };
+    }
+    return { ok: true, value: body };
+  } catch {
+    return { ok: false, error: "Invalid JSON in request body" };
+  }
+}
+function requireField(body, field) {
+  if (!(field in body)) {
+    return { ok: false, error: `Missing required field: ${field}` };
+  }
+  return { ok: true, value: body[field] };
+}
+function optionalField(body, field, defaultValue) {
+  if (!(field in body))
+    return defaultValue;
+  return body[field];
+}
+// src/middleware/cors.ts
+var DEFAULT_OPTIONS = {
+  allowOrigin: "*",
+  allowMethods: "GET, POST, OPTIONS, PUT, DELETE",
+  allowHeaders: "Content-Type, Authorization, X-Request-ID, X-Internal-Auth-Key",
+  allowCredentials: false,
+  maxAge: 86400
+};
+function corsHeaders(options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const headers = {
+    "Access-Control-Allow-Origin": opts.allowOrigin,
+    "Access-Control-Allow-Methods": opts.allowMethods,
+    "Access-Control-Allow-Headers": opts.allowHeaders,
+    "Access-Control-Max-Age": String(opts.maxAge)
+  };
+  if (opts.allowCredentials) {
+    headers["Access-Control-Allow-Credentials"] = "true";
+  }
+  return headers;
+}
+function handleCorsPreflightRequest(request, options) {
+  if (request.method !== "OPTIONS")
+    return null;
+  return new Response(null, {
+    status: 204,
+    headers: corsHeaders(options)
+  });
+}
+// src/middleware/security-headers.ts
+var SECURITY_HEADERS_DEFAULTS = {
+  xContentTypeOptions: "nosniff",
+  xFrameOptions: "DENY",
+  xXssProtection: "1; mode=block",
+  referrerPolicy: "strict-origin-when-cross-origin",
+  permissionsPolicy: "accelerometer=(), camera=(), geolocation=(), gyroscope=(), magnetometer=(), microphone=(), payment=(), usb=()",
+  strictTransportSecurity: "max-age=31536000; includeSubDomains",
+  contentSecurityPolicy: "default-src 'self'"
+};
+function secureHeaders(options) {
+  const opts = { ...SECURITY_HEADERS_DEFAULTS, ...options };
+  const headers = {
+    "X-Content-Type-Options": opts.xContentTypeOptions,
+    "X-Frame-Options": opts.xFrameOptions,
+    "X-XSS-Protection": opts.xXssProtection,
+    "Referrer-Policy": opts.referrerPolicy,
+    "Permissions-Policy": opts.permissionsPolicy,
+    "Strict-Transport-Security": opts.strictTransportSecurity
+  };
+  if (opts.contentSecurityPolicy) {
+    headers["Content-Security-Policy"] = opts.contentSecurityPolicy;
+  }
+  return headers;
+}
+function wrapWithSecurityHeaders(response, options) {
+  const headers = new Headers(response.headers);
+  for (const [key, value] of Object.entries(secureHeaders(options))) {
+    headers.set(key, value);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+export {
+  wrapWithSecurityHeaders,
+  withRequestLog,
+  validateJsonLegacy,
+  validateJson,
+  timingSafeEqual,
+  secureHeaders,
+  requireInternalAuth,
+  requireField,
+  requireAuth,
+  optionalField,
+  handleCorsPreflightRequest,
+  createRateLimiter,
+  createLogger,
+  createInternalAuthMiddleware,
+  corsHeaders,
+  checkInternalAuth,
+  SECURITY_HEADERS_DEFAULTS
+};

package/dist/middleware/logger.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Logger middleware for Cloudflare Workers
+ * Adapted from workers/agent-worker/src/middleware/logger.ts
+ */
+export interface LogContext {
+    service: string;
+    module?: string;
+}
+export interface Logger {
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+}
+export declare function createLogger(ctx: LogContext): Logger;
+export declare function withRequestLog<E extends Record<string, unknown>>(handler: (request: Request, env: E, ctx: ExecutionContext) => Promise<Response>, logCtx: LogContext): (request: Request, env: E, ctx: ExecutionContext) => Promise<Response>;
+//# sourceMappingURL=logger.d.ts.map

package/dist/middleware/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/middleware/logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAWD,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACjE;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CA0BpD;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9D,OAAO,EAAE,CACP,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,CAAC,EACN,GAAG,EAAE,gBAAgB,KAClB,OAAO,CAAC,QAAQ,CAAC,EACtB,MAAM,EAAE,UAAU,GACjB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,CAAC,CA2BxE"}

package/dist/middleware/rate-limit.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Rate limiting middleware for Cloudflare Workers
+ * Adapted from workers/agent-worker/src/middleware/rate-limit.ts
+ *
+ * @available — Available for consumer use. Import from "@jango-blockchained/hoox-shared/middleware".
+ */
+import type { Env } from "../types";
+export interface RateLimitConfig {
+    maxRequests: number;
+    windowSeconds: number;
+    keyPrefix?: string;
+}
+interface RateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    retryAfter?: number;
+}
+export interface RateLimiter {
+    check(request: Request): Promise<RateLimitResult>;
+    enforce(request: Request): Promise<Response | null>;
+}
+export declare function createRateLimiter(kv: Env["CONFIG_KV"], config: RateLimitConfig): RateLimiter;
+export {};
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/middleware/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/middleware/rate-limit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEpC,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAClD,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC;CACrD;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,GAAG,CAAC,WAAW,CAAC,EACpB,MAAM,EAAE,eAAe,GACtB,WAAW,CA0Db"}

package/dist/middleware/security-headers.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Security Headers middleware for Cloudflare Workers
+ * Provides standardized security headers for all worker responses
+ *
+ * @available — Available for consumer use. Import from "@jango-blockchained/hoox-shared/middleware".
+ */
+export interface SecurityHeadersOptions {
+    /** X-Content-Type-Options (default: "nosniff") */
+    xContentTypeOptions?: string;
+    /** X-Frame-Options (default: "DENY") */
+    xFrameOptions?: string;
+    /** X-XSS-Protection (default: "1; mode=block") */
+    xXssProtection?: string;
+    /** Referrer-Policy (default: "strict-origin-when-cross-origin") */
+    referrerPolicy?: string;
+    /** Permissions-Policy (default: restrictive — all disabled) */
+    permissionsPolicy?: string;
+    /** Strict-Transport-Security (default: "max-age=31536000; includeSubDomains") */
+    strictTransportSecurity?: string;
+    /** Content-Security-Policy (default: "default-src 'self'") */
+    contentSecurityPolicy?: string;
+}
+export declare const SECURITY_HEADERS_DEFAULTS: Required<SecurityHeadersOptions>;
+/**
+ * Create security headers object for use in responses.
+ * Merges provided options over defaults.
+ */
+export declare function secureHeaders(options?: SecurityHeadersOptions): Record<string, string>;
+/**
+ * Wrap an existing Response with security headers.
+ * Preserves existing response headers (security headers take precedence).
+ *
+ * @example
+ *   return wrapWithSecurityHeaders(
+ *     createJsonResponse({ success: true }, 200)
+ *   );
+ */
+export declare function wrapWithSecurityHeaders(response: Response, options?: SecurityHeadersOptions): Response;
+//# sourceMappingURL=security-headers.d.ts.map

package/dist/middleware/security-headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-headers.d.ts","sourceRoot":"","sources":["../../src/middleware/security-headers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,sBAAsB;IACrC,kDAAkD;IAClD,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,wCAAwC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kDAAkD;IAClD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mEAAmE;IACnE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+DAA+D;IAC/D,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iFAAiF;IACjF,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,8DAA8D;IAC9D,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,sBAAsB,CAStE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,CAAC,EAAE,sBAAsB,GAC/B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,QAAQ,CAUV"}

package/dist/middleware/validate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Validation middleware for Cloudflare Workers
+ * Uses Zod for runtime schema validation.
+ *
+ * @available — Available for consumer use. Import from "@jango-blockchained/hoox-shared/middleware".
+ */
+import { z } from "zod";
+import type { Result } from "../types";
+/**
+ * Validate unknown data against a Zod schema, returning a Result type.
+ * Provides structured error messages from Zod issue paths.
+ */
+export declare function validateJson<T extends z.ZodTypeAny>(schema: T, data: unknown): Result<z.infer<T>>;
+/**
+ * Legacy signature: parse request body as JSON object.
+ * Kept for backward compatibility with existing workers.
+ */
+export declare function validateJsonLegacy(request: Request): Promise<Result<Record<string, unknown>>>;
+export declare function requireField<T>(body: Record<string, unknown>, field: string): Result<T>;
+export declare function optionalField<T>(body: Record<string, unknown>, field: string, defaultValue: T): T;
+//# sourceMappingURL=validate.d.ts.map

package/dist/middleware/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/middleware/validate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACjD,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,OAAO,GACZ,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAWpB;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAU1C;AAED,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,CAAC,CAAC,CAKX;AAED,wBAAgB,aAAa,CAAC,CAAC,EAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,CAAC,GACd,CAAC,CAGH"}

package/dist/router.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Router implementation for Cloudflare Workers
+ * Provides standardized routing across all workers with path parameter support
+ *
+ * Supports exact matching (fast path) and pattern matching for `:param` segments.
+ * Path parameters are extracted and passed as the 4th argument to handlers.
+ */
+import type { Router } from "./types/router";
+export type { Handler, RouteParams } from "./types/router";
+export declare function createRouter<TEnv = Record<string, unknown>>(): Router<TEnv>;
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAIV,MAAM,EACP,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE3D,wBAAgB,YAAY,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,CAsL3E"}

package/dist/router.js

@@ -0,0 +1,123 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/router.ts
+function createRouter() {
+  const routes = [];
+  function extractParams(pattern) {
+    const params = [];
+    const regex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+    let match;
+    while ((match = regex.exec(pattern)) !== null) {
+      params.push(match[1]);
+    }
+    return params;
+  }
+  function patternToRegex(pattern) {
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regexStr = escaped.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "([^/]+)");
+    return new RegExp(`^${regexStr}$`);
+  }
+  function matchPattern(path, regex, paramNames) {
+    const m = path.match(regex);
+    if (!m)
+      return null;
+    const params = {};
+    for (let i = 0;i < paramNames.length; i++) {
+      params[paramNames[i]] = m[i + 1];
+    }
+    return params;
+  }
+  function addRoute(path, method, handler, middleware) {
+    const paramNames = extractParams(path);
+    const route = { path, method, handler, middleware };
+    if (paramNames.length > 0) {
+      route.params = paramNames;
+      route.regex = patternToRegex(path);
+    }
+    routes.push(route);
+  }
+  function matchRoute(path, method) {
+    const exact = routes.findLast ? routes.findLast((r) => r.path === path && r.method === method) : [...routes].reverse().find((r) => r.path === path && r.method === method);
+    if (exact)
+      return { route: exact };
+    for (let i = routes.length - 1;i >= 0; i--) {
+      const route = routes[i];
+      if (route.params && route.params.length > 0 && route.regex) {
+        const matched = matchPattern(path, route.regex, route.params);
+        if (matched && route.method === method) {
+          return { route, params: matched };
+        }
+      }
+    }
+    return null;
+  }
+  return {
+    get(path, handler, middleware) {
+      addRoute(path, "GET", handler, middleware);
+    },
+    post(path, handler, middleware) {
+      addRoute(path, "POST", handler, middleware);
+    },
+    put(path, handler, middleware) {
+      addRoute(path, "PUT", handler, middleware);
+    },
+    delete(path, handler, middleware) {
+      addRoute(path, "DELETE", handler, middleware);
+    },
+    async handle(request, env, ctx) {
+      const url = new URL(request.url);
+      const path = url.pathname;
+      const method = request.method;
+      const match = matchRoute(path, method);
+      if (!match) {
+        const pathExists = routes.some((r) => {
+          if (r.path === path)
+            return true;
+          if (r.params && r.params.length > 0 && r.regex) {
+            return r.regex.test(path);
+          }
+          return false;
+        });
+        if (pathExists) {
+          return new Response(JSON.stringify({
+            success: false,
+            error: `Method ${method} not allowed for ${path}`
+          }), {
+            status: 405,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        return new Response(JSON.stringify({ success: false, error: "Not found" }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      if (match.route.middleware) {
+        for (const mw of match.route.middleware) {
+          const result = await mw(request, env, ctx);
+          if (result instanceof Response)
+            return result;
+        }
+      }
+      return match.route.handler(request, env, ctx, match.params);
+    }
+  };
+}
+export {
+  createRouter
+};

package/dist/schemas/index.d.ts

@@ -0,0 +1,4 @@
+export type { WorkerManifest, VarDef, ServiceBindingDef, InfraBindings, KVBindingDef, D1BindingDef, R2BindingDef, QueueBindingDef, VectorizeBindingDef, DOBindingDef, ValidationError, ValidationReport, } from "./types.js";
+export { WORKER_MANIFESTS, WORKER_NAMES, CALLED_BY } from "./registry.js";
+export { validateWranglerJsonc, validateRootSecrets, validateDevVars, validateAll, generateWranglerJsonc, generateDevVars, } from "./validators.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,MAAM,EACN,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1E,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,WAAW,EACX,qBAAqB,EACrB,eAAe,GAChB,MAAM,iBAAiB,CAAC"}