@rdlabo/workers-hono-kit 0.3.7 → 0.4.0

package/src/middleware/validation.ts

@@ -1,158 +0,0 @@
-import { zValidator } from '@hono/zod-validator';
-import type { Context } from 'hono';
-import type { ZodType } from 'zod';
-
-/**
- * Minimal structural shape that accepts either a zod v3 `ZodError` or a zod v4 core `$ZodError`.
- *
- * @remarks
- * Declaring only the `issues` array (with `path` and `message`) keeps the kit independent of a
- * specific zod major version while still exposing enough to format human-readable messages.
- */
-export interface ZodErrorLike {
-  /** The validation issues reported by zod, each with a property path and a message. */
-  issues: readonly { path: PropertyKey[]; message: string }[];
-}
-
-/** Request part that a validator inspects, mirroring the targets supported by `@hono/zod-validator`. */
-export type ValidationTarget = 'json' | 'query' | 'param' | 'header' | 'cookie' | 'form';
-
-/** Options controlling the optional side effects of {@link validate}. */
-export interface ValidateOptions {
-  /**
-   * Hook invoked when validation fails (e.g. to report to Sentry).
-   *
-   * @remarks
-   * This never changes validation behavior — the response is always a NestJS `ValidationPipe`-shaped
-   * 400. Exceptions thrown by the hook are swallowed. The default is a no-op (4xx errors are not
-   * reported); pass a hook to forward failures to an error tracker.
-   *
-   * @param error - The zod error describing the failed validation.
-   * @param c - The Hono context for the failing request.
-   */
-  onValidationError?: (error: ZodErrorLike, c: Context) => void;
-}
-
-/**
- * Convert a {@link ZodErrorLike} into NestJS `ValidationPipe`-style message strings.
- *
- * Each issue becomes `"<dotted.path>: <message>"`, or just `"<message>"` when the path is empty.
- *
- * @param error - The zod error to flatten.
- * @returns One message string per issue.
- */
-function zodToMessages(error: ZodErrorLike): string[] {
-  return error.issues.map((issue) => {
-    const path = issue.path.map(String).join('.');
-    return path ? `${path}: ${issue.message}` : issue.message;
-  });
-}
-
-/**
- * Create a zod validation middleware that returns a NestJS `ValidationPipe`-shaped 400 on failure.
- *
- * On success the parsed value is made available through `@hono/zod-validator` as usual. On failure
- * the response body is `{ statusCode: 400, message: string[], error: 'Bad Request' }`, the failing
- * field paths are logged via `console.warn` (so 400s are visible in `wrangler dev`/Workers logs),
- * and {@link ValidateOptions.onValidationError} is invoked if provided.
- *
- * @remarks
- * The exact message strings differ from class-validator because they are produced by zod, but the
- * envelope shape matches NestJS so clients can parse failures identically.
- *
- * @typeParam T - The type produced by the zod schema.
- * @param target - The request part to validate.
- * @param schema - The zod schema to validate the target against.
- * @param options - Optional hooks; see {@link ValidateOptions}.
- * @returns A Hono middleware that validates `target` and short-circuits with a 400 on failure.
- *
- * @example
- * ```ts
- * import { z } from 'zod';
- * import { validate } from '@rdlabo/workers-hono-kit';
- *
- * app.post('/users', validate('json', z.object({ name: z.string() })), (c) => {
- *   const { name } = c.req.valid('json');
- *   return c.json({ name });
- * });
- * ```
- */
-export function validate<T>(target: ValidationTarget, schema: ZodType<T>, options?: ValidateOptions) {
-  return zValidator(target, schema, (result, c) => {
-    if (!result.success) {
-      const messages = zodToMessages(result.error);
-      // Surface the failing fields in the runtime log. Without this the 400 is
-      // invisible in `wrangler dev`/Workers logs (Sentry is the only sink, and
-      // it is not visible locally), so a field-level type mismatch — e.g. a
-      // string sent to `z.number()` — dies silently and is painful to diagnose.
-      // Paths + zod messages only; no request values are logged.
-      console.warn(`[validation] ${c.req.method} ${c.req.path} (${target}) → 400: ${messages.join('; ')}`);
-      try {
-        options?.onValidationError?.(result.error, c);
-      } catch {
-        // Reporting must never change validation error behavior.
-      }
-      return c.json({ statusCode: 400, message: messages, error: 'Bad Request' }, 400);
-    }
-    return undefined;
-  });
-}
-
-/**
- * Minimal structural shape of a Sentry scope, covering only the methods this kit calls.
- *
- * @remarks
- * Declaring the shape structurally avoids a direct dependency on `@sentry/cloudflare`; any object
- * exposing these methods (such as the real Sentry scope) is accepted.
- */
-export interface SentryScopeLike {
-  /** Attach a string tag to the current scope. */
-  setTag(key: string, value: string): void;
-  /** Attach (or clear, with `null`) a structured context entry on the current scope. */
-  setContext(key: string, context: Record<string, unknown> | null): void;
-}
-
-/**
- * Minimal structural shape of the Sentry client, covering only the methods this kit calls.
- *
- * @remarks
- * Like {@link SentryScopeLike}, this avoids a hard dependency on `@sentry/cloudflare`.
- */
-export interface SentryLike {
-  /** Run a callback with an isolated scope, restoring the previous scope afterward. */
-  withScope(callback: (scope: SentryScopeLike) => void): void;
-  /** Report an exception to Sentry. */
-  captureException(error: unknown): void;
-}
-
-/**
- * Create a {@link validate}-like factory that additionally reports DTO validation 400s to Sentry.
- *
- * The returned function has the same signature and behavior as {@link validate}; reporting is a pure
- * side effect that does not alter validation behavior or the response. Each report is tagged with
- * `error.type=dto_validation` and carries a `validation` context of `{ errorCount, errors }`.
- *
- * @param sentry - A Sentry-like client used to capture validation failures; see {@link SentryLike}.
- * @returns A function `(target, schema) => MiddlewareHandler` mirroring {@link validate}.
- *
- * @example
- * ```ts
- * import * as Sentry from '@sentry/cloudflare';
- * import { z } from 'zod';
- * import { createSentryValidate } from '@rdlabo/workers-hono-kit';
- *
- * const validate = createSentryValidate(Sentry);
- * app.post('/users', validate('json', z.object({ name: z.string() })), handler);
- * ```
- */
-export function createSentryValidate(sentry: SentryLike) {
-  const onValidationError = (error: ZodErrorLike): void => {
-    const messages = zodToMessages(error);
-    sentry.withScope((scope) => {
-      scope.setTag('error.type', 'dto_validation');
-      scope.setContext('validation', { errorCount: messages.length, errors: messages });
-      sentry.captureException(error);
-    });
-  };
-  return <T>(target: ValidationTarget, schema: ZodType<T>) => validate(target, schema, { onValidationError });
-}

package/src/middleware/zod-coerce.ts

@@ -1,124 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Zod preprocessors that coerce string path/query parameters into numbers.
- *
- * @remarks
- * These mirror a class-transformer `@Transform(() => Number)` coercion: path and query parameters
- * always arrive as strings, so they must be forced to numbers before number validation. Whitespace-only
- * strings are mapped to `NaN` so the downstream number schema rejects them (matching class-validator's
- * `@IsInt`/`@IsNumber`, which reject `NaN`; zod v4's `z.number()` also rejects `NaN` by default).
- */
-
-/** Return `true` when `value` is a string that is empty or contains only whitespace. */
-const isBlankString = (value: unknown): value is string => typeof value === 'string' && value.trim() === '';
-
-// toNumber: blank string → NaN, otherwise → Number(value).
-const rawToNumber = (value: unknown): unknown => (isBlankString(value) ? Number(undefined) : Number(value));
-
-// toNumberWithDefault: undefined/'' → default, blank → NaN, else Number.
-const rawToNumberWithDefault =
-  (defaultValue: number) =>
-  (value: unknown): unknown => {
-    if (value === undefined || value === '') {
-      return defaultValue;
-    }
-    if (isBlankString(value)) {
-      return Number(undefined);
-    }
-    return Number(value);
-  };
-
-// toOptionalNumber: undefined/null/'' → undefined, blank → NaN, else Number.
-const rawToOptionalNumber = (value: unknown): unknown => {
-  if (value === undefined || value === null || value === '') {
-    return undefined;
-  }
-  if (isBlankString(value)) {
-    return Number(undefined);
-  }
-  return Number(value);
-};
-
-// toNullableNumber: null/undefined → passthrough, '' → undefined, blank → NaN, else Number.
-const rawToNullableNumber = (value: unknown): unknown => {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  if (value === '') {
-    return undefined;
-  }
-  if (isBlankString(value)) {
-    return Number(undefined);
-  }
-  return Number(value);
-};
-
-/**
- * Build a required number schema that coerces string input to a number.
- *
- * @param inner - The inner number schema to apply after coercion; pass e.g. `z.number().int()` to add
- * constraints. Defaults to `z.number()`.
- * @returns A zod schema yielding a `number`.
- *
- * @example
- * ```ts
- * // Require an integer path param:
- * const schema = z.object({ id: zNum(z.number().int()) });
- * // '42' → 42, '' / '  ' → NaN (rejected)
- * ```
- */
-export const zNum = (inner: z.ZodNumber = z.number()): z.ZodType<number> => z.preprocess(rawToNumber, inner);
-
-/**
- * Build a number schema that coerces string input and substitutes a default for missing values.
- *
- * `undefined` or an empty string yields `defaultValue`; a whitespace-only string yields `NaN`
- * (rejected by the inner schema); anything else is passed through `Number`.
- *
- * @param defaultValue - The value used when the input is `undefined` or an empty string.
- * @param inner - The inner number schema applied after coercion. Defaults to `z.number()`.
- * @returns A zod schema yielding a `number`.
- *
- * @example
- * ```ts
- * // Default page to 1 when the query param is absent:
- * const schema = z.object({ page: zNumWithDefault(1) });
- * ```
- */
-export const zNumWithDefault = (defaultValue: number, inner: z.ZodNumber = z.number()): z.ZodType<number> =>
-  z.preprocess(rawToNumberWithDefault(defaultValue), inner);
-
-/**
- * Build an optional number schema that coerces string input.
- *
- * `undefined`, `null`, or an empty string yields `undefined`; a whitespace-only string yields `NaN`
- * (rejected); anything else is passed through `Number`.
- *
- * @param inner - The inner number schema applied after coercion. Defaults to `z.number()`.
- * @returns A zod schema yielding `number | undefined`.
- *
- * @example
- * ```ts
- * const schema = z.object({ limit: zNumOptional(z.number().int()) });
- * ```
- */
-export const zNumOptional = (inner: z.ZodNumber = z.number()): z.ZodType<number | undefined> =>
-  z.preprocess(rawToOptionalNumber, inner.optional());
-
-/**
- * Build a nullable, optional number schema that coerces string input.
- *
- * `null`/`undefined` pass through unchanged; an empty string yields `undefined`; a whitespace-only
- * string yields `NaN` (rejected); anything else is passed through `Number`.
- *
- * @param inner - The inner number schema applied after coercion. Defaults to `z.number()`.
- * @returns A zod schema yielding `number | null | undefined`.
- *
- * @example
- * ```ts
- * const schema = z.object({ parentId: zNumNullable(z.number().int()) });
- * ```
- */
-export const zNumNullable = (inner: z.ZodNumber = z.number()): z.ZodType<number | null | undefined> =>
-  z.preprocess(rawToNullableNumber, inner.nullish());

package/src/queue/consumer.ts

@@ -1,146 +0,0 @@
-/**
- * Consumer-side helper for processing a Cloudflare Queues `MessageBatch` with per-message success and
- * failure handling.
- *
- * A queue consumer invocation receives at most `max_batch_size` messages (configured in
- * `wrangler.toml`), which is precisely the mechanism that bounds its subrequest budget: with a small
- * `max_batch_size`, each invocation performs a fixed, small number of external calls no matter how
- * many messages are backed up in the queue. {@link processBatch} applies the standard
- * ack-on-success / retry-on-failure discipline so one poison message does not fail its whole batch.
- *
- * Messages are processed sequentially. This keeps the number of *simultaneously open* subrequests at
- * one, staying well clear of the Workers concurrent-connection ceiling, and makes the per-invocation
- * subrequest count deterministic (`<= max_batch_size`). For a queue consumer — which is not on a
- * user-facing latency path — sequential processing is the safer default.
- *
- * @example
- * ```ts
- * // Worker `queue` handler
- * export default {
- *   async queue(batch: MessageBatchLike<{ userId: number }>, env: Env) {
- *     await processBatch(batch, async ({ userId }) => {
- *       await reloadOneCustomer(env, userId); // exactly one external payment call
- *     });
- *   },
- * };
- * ```
- *
- * @packageDocumentation
- */
-
-/**
- * Minimal subset of `@cloudflare/workers-types`' `Message` used by {@link processBatch}.
- *
- * Declared locally so consumers are not forced to depend on `@cloudflare/workers-types`.
- *
- * @typeParam Body - Type of the message body.
- */
-export interface QueueMessageLike<Body = unknown> {
-  /** Unique id assigned by the Queues runtime. */
-  readonly id: string;
-  /** Number of delivery attempts so far (starts at 1 on first delivery). */
-  readonly attempts: number;
-  /** The message payload. */
-  readonly body: Body;
-  /** Explicitly acknowledge this message so it is not redelivered. */
-  ack: () => void;
-  /** Mark this message for redelivery, optionally after a delay. */
-  retry: (options?: { delaySeconds?: number }) => void;
-}
-
-/**
- * Minimal subset of `@cloudflare/workers-types`' `MessageBatch` used by {@link processBatch}.
- *
- * @typeParam Body - Type of each message body in the batch.
- */
-export interface MessageBatchLike<Body = unknown> {
-  /** Name of the queue this batch was delivered from. */
-  readonly queue: string;
-  /** The messages in this batch; length is bounded by the consumer's `max_batch_size`. */
-  readonly messages: readonly QueueMessageLike<Body>[];
-}
-
-/**
- * Options for {@link processBatch}.
- *
- * @typeParam Body - Type of each message body.
- */
-export interface ProcessBatchOptions<Body = unknown> {
-  /**
-   * Invoked when `handler` throws for a message, immediately before the message is marked for retry.
-   * Use it to log or report; it must not throw. Defaults to `console.error`.
-   */
-  onError?: (error: unknown, message: QueueMessageLike<Body>) => void;
-  /**
-   * Delay, in seconds, applied when re-queuing a failed message. Omit to retry with the queue's
-   * default backoff.
-   */
-  retryDelaySeconds?: number;
-}
-
-/**
- * Outcome counts returned by {@link processBatch}.
- */
-export interface ProcessBatchResult {
-  /** Messages whose handler completed successfully and were acked. */
-  processed: number;
-  /** Messages whose handler threw and were marked for retry. */
-  failed: number;
-}
-
-/**
- * Process every message in `batch` sequentially, acking on success and retrying on failure.
- *
- * Each message is passed to `handler`; if it resolves the message is acked, and if it throws the
- * error is routed to {@link ProcessBatchOptions.onError} and the message is marked for retry (honoring
- * {@link ProcessBatchOptions.retryDelaySeconds}). One failing message never affects the others, and
- * the returned counts let tests assert that the per-invocation workload — and therefore the
- * subrequest count — stayed bounded by the batch size.
- *
- * @typeParam Body - Type of each message body.
- * @param batch - The delivered message batch.
- * @param handler - Async work for a single message; performs the bounded external call(s). Receives
- *   the decoded `body` and the raw message (for `attempts`, `id`, etc.).
- * @param options - Error reporting and retry tuning; see {@link ProcessBatchOptions}.
- * @returns The number of processed and failed messages.
- * @example
- * ```ts
- * const { processed, failed } = await processBatch(
- *   batch,
- *   async ({ id }) => sendOneMail(id),
- *   { retryDelaySeconds: 30, onError: (e, m) => report(e, m.id) },
- * );
- * ```
- */
-export async function processBatch<Body>(
-  batch: MessageBatchLike<Body>,
-  handler: (body: Body, message: QueueMessageLike<Body>) => Promise<void>,
-  options?: ProcessBatchOptions<Body>,
-): Promise<ProcessBatchResult> {
-  const onError =
-    options?.onError ??
-    ((error, message) => {
-      console.error(`[queue:${batch.queue}] message ${message.id} failed`, error);
-    });
-  const retryOptions =
-    options?.retryDelaySeconds === undefined ? undefined : { delaySeconds: options.retryDelaySeconds };
-
-  let processed = 0;
-  let failed = 0;
-  for (const message of batch.messages) {
-    try {
-      await handler(message.body, message);
-      message.ack();
-      processed++;
-    } catch (error) {
-      try {
-        onError(error, message);
-      } catch {
-        // onError contract says "must not throw"; guard defensively so retry() and remaining messages still run.
-      }
-      message.retry(retryOptions);
-      failed++;
-    }
-  }
-  return { processed, failed };
-}

package/src/queue/send.ts

@@ -1,129 +0,0 @@
-/**
- * Producer-side helper for fanning a large list of items into a Cloudflare Queue without letting the
- * producer's own subrequest count scale linearly with the list.
- *
- * A Worker may issue at most 50 (free) / 1000 (paid) subrequests per invocation, and each
- * {@link QueueLike.send} counts as one subrequest. Enqueuing `N` items with per-item `send()` calls
- * therefore reintroduces the very unbounded fan-out that queues exist to remove. {@link sendInChunks}
- * instead groups items into batches and issues one {@link QueueLike.sendBatch} per batch, so the
- * producer spends `ceil(N / chunkSize)` subrequests regardless of how large `N` grows.
- *
- * The heavy per-item work (external API calls, etc.) is expected to run in the queue *consumer*,
- * where each invocation processes only `max_batch_size` messages and thus enjoys its own bounded
- * subrequest budget. See {@link processBatch} for the consumer side.
- *
- * @example
- * ```ts
- * // In a Cron Trigger `scheduled` handler: enqueue every billing user, then let the consumer
- * // re-derive payment state one user per message.
- * const userIds = await query.getUserIdForReloadCustomer(); // DB read — not a subrequest
- * await sendInChunks(env.PAYMENT_RELOAD_QUEUE, userIds);     // ceil(N / 100) subrequests
- * ```
- *
- * @packageDocumentation
- */
-
-/**
- * Minimal subset of `@cloudflare/workers-types`' `Queue` used by {@link sendInChunks}.
- *
- * Declared locally so consumers are not forced to depend on `@cloudflare/workers-types`. Only the
- * batch-send operation the helper actually needs is modeled.
- *
- * @typeParam Body - Type of each message body enqueued onto this queue.
- */
-export interface QueueLike<Body = unknown> {
-  /**
-   * Enqueue up to 100 messages in a single operation (one subrequest).
-   *
-   * @param messages - The message envelopes to enqueue; at most 100 per call, 256 KB per batch.
-   * @param options - Optional batch-level options, e.g. a `delaySeconds` applied to every message.
-   * @returns A promise that resolves once the batch is accepted. The resolved value is ignored, so a
-   *   real `Queue` binding (whose `sendBatch` resolves to a `QueueSendBatchResponse`) is assignable.
-   */
-  sendBatch: (messages: Iterable<QueueSendMessage<Body>>, options?: { delaySeconds?: number }) => Promise<unknown>;
-}
-
-/**
- * A single message envelope passed to {@link QueueLike.sendBatch}.
- *
- * @typeParam Body - Type of the message body.
- */
-export interface QueueSendMessage<Body = unknown> {
-  /** The message payload; structured-cloned by the Queues runtime. */
-  body: Body;
-  /** Optional content type hint (`'json'` by default for object bodies). */
-  contentType?: 'text' | 'bytes' | 'json' | 'v8';
-  /** Optional per-message delivery delay, in seconds. */
-  delaySeconds?: number;
-}
-
-/**
- * The Cloudflare Queues hard limit on messages per {@link QueueLike.sendBatch} call.
- */
-const MAX_BATCH_SIZE = 100;
-
-/**
- * Split a list into fixed-size chunks (order preserving).
- *
- * @typeParam T - Element type.
- * @param items - Source list.
- * @param size - Maximum chunk length (assumed `>= 1`).
- * @returns An array of chunks, each at most `size` long.
- * @internal
- */
-function chunk<T>(items: readonly T[], size: number): T[][] {
-  const result: T[][] = [];
-  for (let i = 0; i < items.length; i += size) {
-    result.push(items.slice(i, i + size));
-  }
-  return result;
-}
-
-/**
- * Enqueue every item in `items` using batched sends so the producer's subrequest count stays
- * bounded at `ceil(items.length / chunkSize)` rather than growing per item.
- *
- * Each element becomes one queue message (`{ body: item }`); wrap or map your rows into small,
- * self-describing payloads (e.g. an id plus a discriminator) before calling. Keep each batch under
- * the Queues 256 KB limit — with `chunkSize <= 100` and small id-shaped payloads this is not a
- * concern, but large bodies may require a smaller `chunkSize`.
- *
- * Batches are sent sequentially so a mid-list failure surfaces promptly (the already-sent batches
- * are durably enqueued; the throw lets the caller decide whether to retry the remainder). An empty
- * `items` is a no-op.
- *
- * @typeParam Body - Type of each message body.
- * @param queue - The producer binding to send onto.
- * @param items - The full list of message bodies to enqueue; may be arbitrarily large.
- * @param options - Tuning options.
- * @param options.chunkSize - Messages per `sendBatch` call. Defaults to and is capped at 100 (the
- *   Queues per-batch maximum); values below 1 are clamped to 1.
- * @returns The number of `sendBatch` calls issued (i.e. subrequests spent), useful for asserting the
- *   fan-out stayed bounded in tests.
- * @example
- * ```ts
- * const batches = await sendInChunks(env.MY_QUEUE, ids);        // one send per 100 ids
- * const batches = await sendInChunks(env.MY_QUEUE, rows, {      // custom batch size for larger bodies
- *   chunkSize: 25,
- * });
- * ```
- */
-export async function sendInChunks<Body>(
-  queue: QueueLike<Body>,
-  items: readonly Body[],
-  options?: { chunkSize?: number },
-): Promise<number> {
-  if (items.length === 0) {
-    return 0;
-  }
-  const rawChunkSize = options?.chunkSize ?? MAX_BATCH_SIZE;
-  const chunkSize = Math.min(
-    MAX_BATCH_SIZE,
-    Math.max(1, Math.trunc(Number.isNaN(rawChunkSize) ? MAX_BATCH_SIZE : rawChunkSize)),
-  );
-  const batches = chunk(items, chunkSize);
-  for (const batch of batches) {
-    await queue.sendBatch(batch.map((body) => ({ body })));
-  }
-  return batches.length;
-}

package/src/stripe/client.ts

@@ -1,85 +0,0 @@
-import Stripe from 'stripe';
-
-/**
- * Options for {@link createStripeClient}.
- */
-export interface CreateStripeClientOptions {
-  /**
-   * Stripe API version to pin the client to. When omitted, the SDK's built-in default is used.
-   * Pin it when you need stable, reproducible API behavior independent of SDK upgrades.
-   */
-  apiVersion?: string;
-}
-
-/**
- * Create a Stripe client configured to run on Cloudflare Workers.
- *
- * @remarks
- * Workers has no Node.js `http` stack, so the client is built with `Stripe.createFetchHttpClient()`
- * (a `fetch`-based HTTP client) instead of the SDK's default Node transport.
- *
- * @param secret - Stripe secret API key.
- * @param options - Optional client configuration; see {@link CreateStripeClientOptions}.
- * @returns A configured {@link Stripe} instance.
- * @throws Error when `secret` is empty.
- * @example
- * ```ts
- * const stripe = createStripeClient(env.STRIPE_SECRET, { apiVersion: '2024-04-10' });
- * const customer = await stripe.customers.retrieve(customerId);
- * ```
- */
-export function createStripeClient(secret: string, options: CreateStripeClientOptions = {}): Stripe {
-  if (!secret) {
-    throw new Error('Stripe secret is not set');
-  }
-  const config: Stripe.StripeConfig = { httpClient: Stripe.createFetchHttpClient() };
-  if (options.apiVersion) {
-    config.apiVersion = options.apiVersion as Stripe.StripeConfig['apiVersion'];
-  }
-  return new Stripe(secret, config);
-}
-
-/**
- * Verify a Stripe webhook signature and return the parsed event.
- *
- * @remarks
- * Uses `constructEventAsync` together with `Stripe.createSubtleCryptoProvider()` because the Workers
- * crypto API (SubtleCrypto) is asynchronous and the synchronous `constructEvent` is unavailable.
- * The `secret` is not used by signature verification itself, but a client must be constructed to
- * perform the check; no Stripe API call is made.
- *
- * @param secret - Stripe secret API key, used only to construct the verifying client.
- * @param webhookSecret - Endpoint signing secret used to validate the signature.
- * @param payload - Raw request body exactly as received (string or `ArrayBuffer`).
- * @param signature - Value of the `Stripe-Signature` request header.
- * @returns The verified {@link Stripe.Event}.
- * @throws Error when `webhookSecret` is empty, or when `secret` is empty (the verifying client cannot be constructed).
- * @throws Stripe.errors.StripeSignatureVerificationError when the signature does not match.
- * @example
- * ```ts
- * const event = await verifyStripeWebhook(
- *   env.STRIPE_SECRET,
- *   env.STRIPE_WEBHOOK_SECRET,
- *   await request.text(),
- *   request.headers.get('stripe-signature')!,
- * );
- * ```
- */
-export function verifyStripeWebhook(
-  secret: string,
-  webhookSecret: string,
-  payload: string | ArrayBuffer,
-  signature: string,
-): Promise<Stripe.Event> {
-  if (!webhookSecret) {
-    throw new Error('Stripe webhook secret is not set');
-  }
-  const stripe = createStripeClient(secret);
-  return stripe.webhooks.constructEventAsync(
-    payload as string,
-    signature,
-    webhookSecret,
-    undefined,
-    Stripe.createSubtleCryptoProvider(),
-  );
-}