@kotodayori/fetch 0.1.0 → 0.2.0

package/README.md

@@ -86,10 +86,17 @@ function fetchAdapter<TEvent extends WebhookEvent>(
   options: {
     verifier: Verifier<TEvent>;
     onError?: (error: Error, event: TEvent) => Promise<void> | void;
+    logger?: Logger; // defaults to consoleLogger
+    createContext?: (request: Request) => TContext | Promise<TContext>; // defaults to the Request
   }
 ): (request: Request) => Promise<Response>
 ```
 
+- **verifier** — Required. Verifies the request and returns the event (e.g. `createStripeVerifier`).
+- **onError** — Optional. Called when a handler throws; errors thrown by `onError` itself are ignored and the response stays 500.
+- **logger** — Optional. Receives adapter diagnostics, currently verification failures (`logger.error('Webhook verification failed:', err)`). Defaults to `consoleLogger`, which writes to `console`.
+- **createContext** — Optional. Builds the per-request context passed to handlers as their second argument. Defaults to the `Request` itself. The types require it when the router's context is not something `Request` satisfies.
+
 The raw body is read with `request.text()` and passed to the verifier untouched, so signature verification sees the exact bytes that were signed.
 
 | Situation | Status | Body |
@@ -100,6 +107,41 @@ The raw body is read with `request.text()` and passed to the verifier untouched,
 | Handler threw | 500 | `{ "error": "Internal server error" }` |
 | Success | 200 | `{ "received": true }` |
 
+### Per-request context (Workers bindings)
+
+Handlers receive a per-request context as their second argument, so a router defined once at module scope can still reach request-scoped values such as Cloudflare Workers bindings. Create the handler inside `fetch(request, env)` and build the context from `env`:
+
+```typescript
+const router = new StripeWebhookRouter<{ db: D1Database }>();
+
+router.on('checkout.session.completed', async (event, { db }) => {
+  await db.prepare('INSERT INTO orders (id) VALUES (?)').bind(event.data.object.id).run();
+});
+
+export default {
+  fetch: (request: Request, env: Env) =>
+    fetchAdapter(router, {
+      verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),
+      createContext: () => ({ db: env.DB }),
+    })(request),
+};
+```
+
+If `createContext` throws, the adapter responds 500 and calls `onError`, like a handler error.
+
+### Custom logger
+
+Route verification failures to your own logger, or silence them:
+
+```typescript
+import { silentLogger } from '@kotodayori/core';
+
+const handle = fetchAdapter(router, {
+  verifier,
+  logger: silentLogger, // or any object with `warn` and `error` methods
+});
+```
+
 Unlike the Hono adapter, non-POST requests are rejected with 405 because the handler may be mounted directly (e.g. `export default { fetch: handle }`) with no router in front of it.
 
 ## License

package/dist/index.cjs

@@ -33,6 +33,7 @@ function jsonResponse(body, status, headers = {}) {
   });
 }
 function fetchAdapter(router, options) {
+  const { createContext } = options;
   return async (request) => {
     if (request.method !== "POST") {
       return jsonResponse({ error: "Method not allowed" }, 405, { allow: "POST" });
@@ -42,7 +43,13 @@ function fetchAdapter(router, options) {
     request.headers.forEach((value, key) => {
       headers[key] = value;
     });
-    const { status, body } = await (0, import_core.handleWebhook)(router, options, rawBody, headers);
+    const { status, body } = await (0, import_core.handleWebhook)(
+      router,
+      options,
+      rawBody,
+      headers,
+      (0, import_core.contextProvider)(createContext, [request], request)
+    );
     return jsonResponse(body, status);
   };
 }

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  handleWebhook,\n  type WebhookDispatcher,\n  type WebhookEvent,\n  type WebhookHandlerOptions,\n} from '@kotodayori/core';\n\n/**\n * Options for the fetch adapter\n */\nexport type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandlerOptions<T>;\n\nfunction jsonResponse(body: unknown, status: number, headers: Record<string, string> = {}): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'content-type': 'application/json', ...headers },\n  });\n}\n\n/**\n * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler\n *\n * Works anywhere the runtime hands you a standard `Request`: Cloudflare Workers,\n * Bun, Deno, Next.js App Router route handlers, React Router / Remix actions, etc.\n * The raw body is read with `request.text()` and passed to the verifier untouched.\n * Non-POST requests get `405 Method Not Allowed`, since the handler may be mounted\n * without a router in front of it.\n *\n * @example\n * ```typescript\n * import { fetchAdapter } from '@kotodayori/fetch';\n * import { createStripeVerifier, StripeWebhookRouter } from '@kotodayori/stripe';\n *\n * const router = new StripeWebhookRouter();\n * const handle = fetchAdapter(router, {\n *   verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),\n * });\n *\n * // Cloudflare Workers / Bun / Deno\n * export default { fetch: handle };\n *\n * // Next.js App Router (app/webhook/route.ts)\n * export const POST = handle;\n *\n * // React Router v7 / Remix\n * export const action = ({ request }) => handle(request);\n * ```\n *\n * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)\n * @param options - Adapter options including a verifier function\n * @returns Fetch handler function\n */\nexport function fetchAdapter<\n  TEvent extends WebhookEvent = WebhookEvent,\n>(\n  router: WebhookDispatcher<TEvent>,\n  options: FetchAdapterOptions<TEvent>\n): (request: Request) => Promise<Response> {\n  return async (request: Request): Promise<Response> => {\n    if (request.method !== 'POST') {\n      return jsonResponse({ error: 'Method not allowed' }, 405, { allow: 'POST' });\n    }\n\n    // Get raw body text for signature verification\n    const rawBody = await request.text();\n\n    const headers: Record<string, string> = {};\n    request.headers.forEach((value, key) => {\n      headers[key] = value;\n    });\n\n    const { status, body } = await handleWebhook(router, options, rawBody, headers);\n    return jsonResponse(body, status);\n  };\n}\n\n// Re-export core types\nexport { WebhookRouter, type WebhookDispatcher, type WebhookEvent, type EventHandler, type Middleware, type Verifier, type VerifyResult } from '@kotodayori/core';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAKO;AAwEP,IAAAA,eAA+I;AAjE/I,SAAS,aAAa,MAAe,QAAgB,UAAkC,CAAC,GAAa;AACnG,SAAO,IAAI,SAAS,KAAK,UAAU,IAAI,GAAG;AAAA,IACxC;AAAA,IACA,SAAS,EAAE,gBAAgB,oBAAoB,GAAG,QAAQ;AAAA,EAC5D,CAAC;AACH;AAmCO,SAAS,aAGd,QACA,SACyC;AACzC,SAAO,OAAO,YAAwC;AACpD,QAAI,QAAQ,WAAW,QAAQ;AAC7B,aAAO,aAAa,EAAE,OAAO,qBAAqB,GAAG,KAAK,EAAE,OAAO,OAAO,CAAC;AAAA,IAC7E;AAGA,UAAM,UAAU,MAAM,QAAQ,KAAK;AAEnC,UAAM,UAAkC,CAAC;AACzC,YAAQ,QAAQ,QAAQ,CAAC,OAAO,QAAQ;AACtC,cAAQ,GAAG,IAAI;AAAA,IACjB,CAAC;AAED,UAAM,EAAE,QAAQ,KAAK,IAAI,UAAM,2BAAc,QAAQ,SAAS,SAAS,OAAO;AAC9E,WAAO,aAAa,MAAM,MAAM;AAAA,EAClC;AACF;","names":["import_core"]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  contextProvider,\n  handleWebhook,\n  type ContextFactory,\n  type ContextFactoryOption,\n  type WebhookDispatcher,\n  type WebhookEvent,\n  type WebhookHandlerOptions,\n} from '@kotodayori/core';\n\n/**\n * Options for the fetch adapter\n */\nexport type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent, TContext = Request> =\n  WebhookHandlerOptions<T> & {\n    /**\n     * Builds the per-request context passed to handlers as their second argument.\n     * Defaults to passing the `Request` itself. Required when the router's context type\n     * is not satisfied by `Request`. On Cloudflare Workers, create the handler inside\n     * `fetch(request, env)` and read bindings from `env`. Errors are handled like handler\n     * errors.\n     */\n    createContext?: ContextFactory<[request: Request], TContext>;\n  };\n\n/**\n * Fetch adapter options for a router with context `TContext`: `createContext` is optional\n * when `Request` already satisfies `TContext`, and required otherwise.\n */\nexport type FetchAdapterOptionsFor<T extends WebhookEvent, TContext> = WebhookHandlerOptions<T> &\n  ContextFactoryOption<Request, TContext, [request: Request]>;\n\nfunction jsonResponse(body: unknown, status: number, headers: Record<string, string> = {}): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'content-type': 'application/json', ...headers },\n  });\n}\n\n/**\n * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler\n *\n * Works anywhere the runtime hands you a standard `Request`: Cloudflare Workers,\n * Bun, Deno, Next.js App Router route handlers, React Router / Remix actions, etc.\n * The raw body is read with `request.text()` and passed to the verifier untouched.\n * Non-POST requests get `405 Method Not Allowed`, since the handler may be mounted\n * without a router in front of it.\n *\n * @example\n * ```typescript\n * import { fetchAdapter } from '@kotodayori/fetch';\n * import { createStripeVerifier, StripeWebhookRouter } from '@kotodayori/stripe';\n *\n * const router = new StripeWebhookRouter();\n * const handle = fetchAdapter(router, {\n *   verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),\n * });\n *\n * // Cloudflare Workers / Bun / Deno\n * export default { fetch: handle };\n *\n * // Next.js App Router (app/webhook/route.ts)\n * export const POST = handle;\n *\n * // React Router v7 / Remix\n * export const action = ({ request }) => handle(request);\n * ```\n *\n * @example\n * ```typescript\n * // Cloudflare Workers: handlers reach bindings through the per-request context\n * const router = new StripeWebhookRouter<{ db: D1Database }>();\n * export default {\n *   fetch: (request: Request, env: Env) =>\n *     fetchAdapter(router, {\n *       verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),\n *       createContext: () => ({ db: env.DB }),\n *     })(request),\n * };\n * ```\n *\n * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)\n * @param options - Adapter options including a verifier function\n * @returns Fetch handler function\n */\nexport function fetchAdapter<\n  TEvent extends WebhookEvent = WebhookEvent,\n  TContext = unknown,\n>(\n  router: WebhookDispatcher<NoInfer<TEvent>, TContext>,\n  options: FetchAdapterOptionsFor<TEvent, NoInfer<TContext>>\n): (request: Request) => Promise<Response> {\n  const { createContext } = options as FetchAdapterOptions<TEvent, TContext>;\n\n  return async (request: Request): Promise<Response> => {\n    if (request.method !== 'POST') {\n      return jsonResponse({ error: 'Method not allowed' }, 405, { allow: 'POST' });\n    }\n\n    // Get raw body text for signature verification\n    const rawBody = await request.text();\n\n    const headers: Record<string, string> = {};\n    request.headers.forEach((value, key) => {\n      headers[key] = value;\n    });\n\n    const { status, body } = await handleWebhook(\n      router,\n      options,\n      rawBody,\n      headers,\n      contextProvider(createContext, [request], request)\n    );\n    return jsonResponse(body, status);\n  };\n}\n\n// Re-export core types\nexport { WebhookRouter, type WebhookDispatcher, type WebhookEvent, type EventHandler, type Middleware, type Verifier, type VerifyResult } from '@kotodayori/core';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAQO;AA+GP,IAAAA,eAA+I;AAvF/I,SAAS,aAAa,MAAe,QAAgB,UAAkC,CAAC,GAAa;AACnG,SAAO,IAAI,SAAS,KAAK,UAAU,IAAI,GAAG;AAAA,IACxC;AAAA,IACA,SAAS,EAAE,gBAAgB,oBAAoB,GAAG,QAAQ;AAAA,EAC5D,CAAC;AACH;AAgDO,SAAS,aAId,QACA,SACyC;AACzC,QAAM,EAAE,cAAc,IAAI;AAE1B,SAAO,OAAO,YAAwC;AACpD,QAAI,QAAQ,WAAW,QAAQ;AAC7B,aAAO,aAAa,EAAE,OAAO,qBAAqB,GAAG,KAAK,EAAE,OAAO,OAAO,CAAC;AAAA,IAC7E;AAGA,UAAM,UAAU,MAAM,QAAQ,KAAK;AAEnC,UAAM,UAAkC,CAAC;AACzC,YAAQ,QAAQ,QAAQ,CAAC,OAAO,QAAQ;AACtC,cAAQ,GAAG,IAAI;AAAA,IACjB,CAAC;AAED,UAAM,EAAE,QAAQ,KAAK,IAAI,UAAM;AAAA,MAC7B;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,UACA,6BAAgB,eAAe,CAAC,OAAO,GAAG,OAAO;AAAA,IACnD;AACA,WAAO,aAAa,MAAM,MAAM;AAAA,EAClC;AACF;","names":["import_core"]}

package/dist/index.d.cts

@@ -1,10 +1,24 @@
-import { WebhookEvent, WebhookHandlerOptions, WebhookDispatcher } from '@kotodayori/core';
+import { WebhookEvent, WebhookHandlerOptions, ContextFactory, ContextFactoryOption, WebhookDispatcher } from '@kotodayori/core';
 export { EventHandler, Middleware, Verifier, VerifyResult, WebhookDispatcher, WebhookEvent, WebhookRouter } from '@kotodayori/core';
 
 /**
  * Options for the fetch adapter
  */
-type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandlerOptions<T>;
+type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent, TContext = Request> = WebhookHandlerOptions<T> & {
+    /**
+     * Builds the per-request context passed to handlers as their second argument.
+     * Defaults to passing the `Request` itself. Required when the router's context type
+     * is not satisfied by `Request`. On Cloudflare Workers, create the handler inside
+     * `fetch(request, env)` and read bindings from `env`. Errors are handled like handler
+     * errors.
+     */
+    createContext?: ContextFactory<[request: Request], TContext>;
+};
+/**
+ * Fetch adapter options for a router with context `TContext`: `createContext` is optional
+ * when `Request` already satisfies `TContext`, and required otherwise.
+ */
+type FetchAdapterOptionsFor<T extends WebhookEvent, TContext> = WebhookHandlerOptions<T> & ContextFactoryOption<Request, TContext, [request: Request]>;
 /**
  * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler
  *
@@ -34,10 +48,23 @@ type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandler
  * export const action = ({ request }) => handle(request);
  * ```
  *
+ * @example
+ * ```typescript
+ * // Cloudflare Workers: handlers reach bindings through the per-request context
+ * const router = new StripeWebhookRouter<{ db: D1Database }>();
+ * export default {
+ *   fetch: (request: Request, env: Env) =>
+ *     fetchAdapter(router, {
+ *       verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),
+ *       createContext: () => ({ db: env.DB }),
+ *     })(request),
+ * };
+ * ```
+ *
  * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)
  * @param options - Adapter options including a verifier function
  * @returns Fetch handler function
  */
-declare function fetchAdapter<TEvent extends WebhookEvent = WebhookEvent>(router: WebhookDispatcher<TEvent>, options: FetchAdapterOptions<TEvent>): (request: Request) => Promise<Response>;
+declare function fetchAdapter<TEvent extends WebhookEvent = WebhookEvent, TContext = unknown>(router: WebhookDispatcher<NoInfer<TEvent>, TContext>, options: FetchAdapterOptionsFor<TEvent, NoInfer<TContext>>): (request: Request) => Promise<Response>;
 
-export { type FetchAdapterOptions, fetchAdapter };
+export { type FetchAdapterOptions, type FetchAdapterOptionsFor, fetchAdapter };

package/dist/index.d.ts

@@ -1,10 +1,24 @@
-import { WebhookEvent, WebhookHandlerOptions, WebhookDispatcher } from '@kotodayori/core';
+import { WebhookEvent, WebhookHandlerOptions, ContextFactory, ContextFactoryOption, WebhookDispatcher } from '@kotodayori/core';
 export { EventHandler, Middleware, Verifier, VerifyResult, WebhookDispatcher, WebhookEvent, WebhookRouter } from '@kotodayori/core';
 
 /**
  * Options for the fetch adapter
  */
-type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandlerOptions<T>;
+type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent, TContext = Request> = WebhookHandlerOptions<T> & {
+    /**
+     * Builds the per-request context passed to handlers as their second argument.
+     * Defaults to passing the `Request` itself. Required when the router's context type
+     * is not satisfied by `Request`. On Cloudflare Workers, create the handler inside
+     * `fetch(request, env)` and read bindings from `env`. Errors are handled like handler
+     * errors.
+     */
+    createContext?: ContextFactory<[request: Request], TContext>;
+};
+/**
+ * Fetch adapter options for a router with context `TContext`: `createContext` is optional
+ * when `Request` already satisfies `TContext`, and required otherwise.
+ */
+type FetchAdapterOptionsFor<T extends WebhookEvent, TContext> = WebhookHandlerOptions<T> & ContextFactoryOption<Request, TContext, [request: Request]>;
 /**
  * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler
  *
@@ -34,10 +48,23 @@ type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandler
  * export const action = ({ request }) => handle(request);
  * ```
  *
+ * @example
+ * ```typescript
+ * // Cloudflare Workers: handlers reach bindings through the per-request context
+ * const router = new StripeWebhookRouter<{ db: D1Database }>();
+ * export default {
+ *   fetch: (request: Request, env: Env) =>
+ *     fetchAdapter(router, {
+ *       verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),
+ *       createContext: () => ({ db: env.DB }),
+ *     })(request),
+ * };
+ * ```
+ *
  * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)
  * @param options - Adapter options including a verifier function
  * @returns Fetch handler function
  */
-declare function fetchAdapter<TEvent extends WebhookEvent = WebhookEvent>(router: WebhookDispatcher<TEvent>, options: FetchAdapterOptions<TEvent>): (request: Request) => Promise<Response>;
+declare function fetchAdapter<TEvent extends WebhookEvent = WebhookEvent, TContext = unknown>(router: WebhookDispatcher<NoInfer<TEvent>, TContext>, options: FetchAdapterOptionsFor<TEvent, NoInfer<TContext>>): (request: Request) => Promise<Response>;
 
-export { type FetchAdapterOptions, fetchAdapter };
+export { type FetchAdapterOptions, type FetchAdapterOptionsFor, fetchAdapter };

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/index.ts
 import {
+  contextProvider,
   handleWebhook
 } from "@kotodayori/core";
 import { WebhookRouter } from "@kotodayori/core";
@@ -10,6 +11,7 @@ function jsonResponse(body, status, headers = {}) {
   });
 }
 function fetchAdapter(router, options) {
+  const { createContext } = options;
   return async (request) => {
     if (request.method !== "POST") {
       return jsonResponse({ error: "Method not allowed" }, 405, { allow: "POST" });
@@ -19,7 +21,13 @@ function fetchAdapter(router, options) {
     request.headers.forEach((value, key) => {
       headers[key] = value;
     });
-    const { status, body } = await handleWebhook(router, options, rawBody, headers);
+    const { status, body } = await handleWebhook(
+      router,
+      options,
+      rawBody,
+      headers,
+      contextProvider(createContext, [request], request)
+    );
     return jsonResponse(body, status);
   };
 }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  handleWebhook,\n  type WebhookDispatcher,\n  type WebhookEvent,\n  type WebhookHandlerOptions,\n} from '@kotodayori/core';\n\n/**\n * Options for the fetch adapter\n */\nexport type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandlerOptions<T>;\n\nfunction jsonResponse(body: unknown, status: number, headers: Record<string, string> = {}): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'content-type': 'application/json', ...headers },\n  });\n}\n\n/**\n * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler\n *\n * Works anywhere the runtime hands you a standard `Request`: Cloudflare Workers,\n * Bun, Deno, Next.js App Router route handlers, React Router / Remix actions, etc.\n * The raw body is read with `request.text()` and passed to the verifier untouched.\n * Non-POST requests get `405 Method Not Allowed`, since the handler may be mounted\n * without a router in front of it.\n *\n * @example\n * ```typescript\n * import { fetchAdapter } from '@kotodayori/fetch';\n * import { createStripeVerifier, StripeWebhookRouter } from '@kotodayori/stripe';\n *\n * const router = new StripeWebhookRouter();\n * const handle = fetchAdapter(router, {\n *   verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),\n * });\n *\n * // Cloudflare Workers / Bun / Deno\n * export default { fetch: handle };\n *\n * // Next.js App Router (app/webhook/route.ts)\n * export const POST = handle;\n *\n * // React Router v7 / Remix\n * export const action = ({ request }) => handle(request);\n * ```\n *\n * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)\n * @param options - Adapter options including a verifier function\n * @returns Fetch handler function\n */\nexport function fetchAdapter<\n  TEvent extends WebhookEvent = WebhookEvent,\n>(\n  router: WebhookDispatcher<TEvent>,\n  options: FetchAdapterOptions<TEvent>\n): (request: Request) => Promise<Response> {\n  return async (request: Request): Promise<Response> => {\n    if (request.method !== 'POST') {\n      return jsonResponse({ error: 'Method not allowed' }, 405, { allow: 'POST' });\n    }\n\n    // Get raw body text for signature verification\n    const rawBody = await request.text();\n\n    const headers: Record<string, string> = {};\n    request.headers.forEach((value, key) => {\n      headers[key] = value;\n    });\n\n    const { status, body } = await handleWebhook(router, options, rawBody, headers);\n    return jsonResponse(body, status);\n  };\n}\n\n// Re-export core types\nexport { WebhookRouter, type WebhookDispatcher, type WebhookEvent, type EventHandler, type Middleware, type Verifier, type VerifyResult } from '@kotodayori/core';\n"],"mappings":";AAAA;AAAA,EACE;AAAA,OAIK;AAwEP,SAAS,qBAAsI;AAjE/I,SAAS,aAAa,MAAe,QAAgB,UAAkC,CAAC,GAAa;AACnG,SAAO,IAAI,SAAS,KAAK,UAAU,IAAI,GAAG;AAAA,IACxC;AAAA,IACA,SAAS,EAAE,gBAAgB,oBAAoB,GAAG,QAAQ;AAAA,EAC5D,CAAC;AACH;AAmCO,SAAS,aAGd,QACA,SACyC;AACzC,SAAO,OAAO,YAAwC;AACpD,QAAI,QAAQ,WAAW,QAAQ;AAC7B,aAAO,aAAa,EAAE,OAAO,qBAAqB,GAAG,KAAK,EAAE,OAAO,OAAO,CAAC;AAAA,IAC7E;AAGA,UAAM,UAAU,MAAM,QAAQ,KAAK;AAEnC,UAAM,UAAkC,CAAC;AACzC,YAAQ,QAAQ,QAAQ,CAAC,OAAO,QAAQ;AACtC,cAAQ,GAAG,IAAI;AAAA,IACjB,CAAC;AAED,UAAM,EAAE,QAAQ,KAAK,IAAI,MAAM,cAAc,QAAQ,SAAS,SAAS,OAAO;AAC9E,WAAO,aAAa,MAAM,MAAM;AAAA,EAClC;AACF;","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  contextProvider,\n  handleWebhook,\n  type ContextFactory,\n  type ContextFactoryOption,\n  type WebhookDispatcher,\n  type WebhookEvent,\n  type WebhookHandlerOptions,\n} from '@kotodayori/core';\n\n/**\n * Options for the fetch adapter\n */\nexport type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent, TContext = Request> =\n  WebhookHandlerOptions<T> & {\n    /**\n     * Builds the per-request context passed to handlers as their second argument.\n     * Defaults to passing the `Request` itself. Required when the router's context type\n     * is not satisfied by `Request`. On Cloudflare Workers, create the handler inside\n     * `fetch(request, env)` and read bindings from `env`. Errors are handled like handler\n     * errors.\n     */\n    createContext?: ContextFactory<[request: Request], TContext>;\n  };\n\n/**\n * Fetch adapter options for a router with context `TContext`: `createContext` is optional\n * when `Request` already satisfies `TContext`, and required otherwise.\n */\nexport type FetchAdapterOptionsFor<T extends WebhookEvent, TContext> = WebhookHandlerOptions<T> &\n  ContextFactoryOption<Request, TContext, [request: Request]>;\n\nfunction jsonResponse(body: unknown, status: number, headers: Record<string, string> = {}): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'content-type': 'application/json', ...headers },\n  });\n}\n\n/**\n * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler\n *\n * Works anywhere the runtime hands you a standard `Request`: Cloudflare Workers,\n * Bun, Deno, Next.js App Router route handlers, React Router / Remix actions, etc.\n * The raw body is read with `request.text()` and passed to the verifier untouched.\n * Non-POST requests get `405 Method Not Allowed`, since the handler may be mounted\n * without a router in front of it.\n *\n * @example\n * ```typescript\n * import { fetchAdapter } from '@kotodayori/fetch';\n * import { createStripeVerifier, StripeWebhookRouter } from '@kotodayori/stripe';\n *\n * const router = new StripeWebhookRouter();\n * const handle = fetchAdapter(router, {\n *   verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),\n * });\n *\n * // Cloudflare Workers / Bun / Deno\n * export default { fetch: handle };\n *\n * // Next.js App Router (app/webhook/route.ts)\n * export const POST = handle;\n *\n * // React Router v7 / Remix\n * export const action = ({ request }) => handle(request);\n * ```\n *\n * @example\n * ```typescript\n * // Cloudflare Workers: handlers reach bindings through the per-request context\n * const router = new StripeWebhookRouter<{ db: D1Database }>();\n * export default {\n *   fetch: (request: Request, env: Env) =>\n *     fetchAdapter(router, {\n *       verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),\n *       createContext: () => ({ db: env.DB }),\n *     })(request),\n * };\n * ```\n *\n * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)\n * @param options - Adapter options including a verifier function\n * @returns Fetch handler function\n */\nexport function fetchAdapter<\n  TEvent extends WebhookEvent = WebhookEvent,\n  TContext = unknown,\n>(\n  router: WebhookDispatcher<NoInfer<TEvent>, TContext>,\n  options: FetchAdapterOptionsFor<TEvent, NoInfer<TContext>>\n): (request: Request) => Promise<Response> {\n  const { createContext } = options as FetchAdapterOptions<TEvent, TContext>;\n\n  return async (request: Request): Promise<Response> => {\n    if (request.method !== 'POST') {\n      return jsonResponse({ error: 'Method not allowed' }, 405, { allow: 'POST' });\n    }\n\n    // Get raw body text for signature verification\n    const rawBody = await request.text();\n\n    const headers: Record<string, string> = {};\n    request.headers.forEach((value, key) => {\n      headers[key] = value;\n    });\n\n    const { status, body } = await handleWebhook(\n      router,\n      options,\n      rawBody,\n      headers,\n      contextProvider(createContext, [request], request)\n    );\n    return jsonResponse(body, status);\n  };\n}\n\n// Re-export core types\nexport { WebhookRouter, type WebhookDispatcher, type WebhookEvent, type EventHandler, type Middleware, type Verifier, type VerifyResult } from '@kotodayori/core';\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,OAMK;AA+GP,SAAS,qBAAsI;AAvF/I,SAAS,aAAa,MAAe,QAAgB,UAAkC,CAAC,GAAa;AACnG,SAAO,IAAI,SAAS,KAAK,UAAU,IAAI,GAAG;AAAA,IACxC;AAAA,IACA,SAAS,EAAE,gBAAgB,oBAAoB,GAAG,QAAQ;AAAA,EAC5D,CAAC;AACH;AAgDO,SAAS,aAId,QACA,SACyC;AACzC,QAAM,EAAE,cAAc,IAAI;AAE1B,SAAO,OAAO,YAAwC;AACpD,QAAI,QAAQ,WAAW,QAAQ;AAC7B,aAAO,aAAa,EAAE,OAAO,qBAAqB,GAAG,KAAK,EAAE,OAAO,OAAO,CAAC;AAAA,IAC7E;AAGA,UAAM,UAAU,MAAM,QAAQ,KAAK;AAEnC,UAAM,UAAkC,CAAC;AACzC,YAAQ,QAAQ,QAAQ,CAAC,OAAO,QAAQ;AACtC,cAAQ,GAAG,IAAI;AAAA,IACjB,CAAC;AAED,UAAM,EAAE,QAAQ,KAAK,IAAI,MAAM;AAAA,MAC7B;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,gBAAgB,eAAe,CAAC,OAAO,GAAG,OAAO;AAAA,IACnD;AACA,WAAO,aAAa,MAAM,MAAM;AAAA,EAClC;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kotodayori/fetch",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Web-standard fetch (Request/Response) adapter for Kotodayori Webhook Router",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -22,14 +22,14 @@
     "dist"
   ],
   "dependencies": {
-    "@kotodayori/core": "^1.4.0"
+    "@kotodayori/core": "^1.5.0"
   },
   "devDependencies": {
     "stripe": "^23.0.0",
     "tsup": "^8.5.1",
     "typescript": "^6.0.0",
     "vitest": "^4.1.8",
-    "@kotodayori/stripe": "^1.5.0"
+    "@kotodayori/stripe": "^1.6.0"
   },
   "keywords": [
     "webhook",
@@ -60,6 +60,6 @@
   "scripts": {
     "build": "tsup",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json"
   }
 }