@whi/cf-routing - v0.7.0
    Preparing search index...

    Class WorkerRouter<E>

    Router for Cloudflare Workers with class-based handlers and middleware support

    Features:

    • Middleware with next() pattern (pre/post processing, short-circuit)
    • Context object for sharing state between middleware and handlers
    • Automatic error handling with HttpError support
    • CORS configuration at router and handler level
    const router = new WorkerRouter<Env>('my-worker')
      .use(loggingMiddleware)
      .use('/api/*', authMiddleware)
      .defineRouteHandler('/users/:id', UserHandler)
      .build();

    export default {
      async fetch(request, env, ctx) {
        return router.fetch(request, env, ctx);
      }
    };

    Type Parameters

    • E extends Env

      Environment type extending base Env interface

    Index

    Constructors

    constructor

    Properties

    name log router corsConfig?

    Methods

    use all get post put delete patch defineRouteHandler build

    Constructors

    • Create a new WorkerRouter

      Type Parameters

      Parameters

      • name: string = 'unnamed'

        Router name (default: 'unnamed')

      • Optionaloptions: WorkerRouterOptions

        Router options including CORS configuration

      • ...args: [RouterOptions<unknown, any[]>?]

        Additional arguments passed to itty-router

      Returns WorkerRouter<E>

    Properties

    name: string

    Router name for logging

    log: Logger

    Logger instance

    router: RouterType<unknown>

    Underlying itty-router instance for path matching

    corsConfig?: CorsConfig<unknown, unknown>

    CORS configuration

    Methods

    • Register global middleware or path-specific middleware

      Type Parameters

      Parameters

      • pathOrMiddleware: string | Middleware<E, P, D>

        Path pattern or middleware function

      • Optionalmiddleware: Middleware<E, P, D>

        Middleware function (if path provided)

      Returns WorkerRouter<E>

      This router instance for chaining

      // Global middleware
      router.use(loggingMiddleware);

      // Path-specific middleware
      router.use('/api/*', authMiddleware);

    post

    • Register a class-based route handler for all HTTP methods

      Type Parameters

      Parameters

      • path: string

        Route path pattern (e.g., '/users/:id')

      • handler_cls: new (
            ...args: [path: string, options?: { log?: Logger }],
        ) => RouteHandler<E, P, D>

        RouteHandler class to instantiate

      Returns WorkerRouter<E>

      This router instance for chaining

      class UserHandler extends RouteHandler<Env, { id: string }> {
        async get(ctx) {
          return { userId: ctx.params.id };
        }
      }

      router.defineRouteHandler('/users/:id', UserHandler);

    • Build the router and add 404 handler

      Returns RouterType<unknown, any[], unknown>

      The underlying itty-router instance

      const router = new WorkerRouter('my-worker')
        .defineRouteHandler('/health', HealthHandler)
        .build();

      export default {
        async fetch(request, env, ctx) {
          return router.fetch(request, env, ctx);
        }
      };

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods