@zap-studio/webhooks 0.2.2 → 0.4.0

package/dist/index.mjs

@@ -1,159 +0,0 @@
-import { standardValidate } from "@zap-studio/validation";
-//#region src/index.ts
-function toArray(value) {
-	if (value === void 0) return [];
-	return Array.isArray(value) ? value : [value];
-}
-/**
-* Main webhook router class.
-*
-* Register routes with typed schemas and call `handle` with a normalized request.
-*/
-var WebhookRouter = class {
-	handlers = {};
-	verify;
-	globalBeforeHooks = [];
-	globalAfterHooks = [];
-	globalErrorHook;
-	prefix;
-	constructor(opts = {}) {
-		this.prefix = opts.prefix ?? "/webhooks/";
-		this.verify = opts.verify;
-		this.globalBeforeHooks = toArray(opts.before);
-		this.globalAfterHooks = toArray(opts.after);
-		this.globalErrorHook = opts.onError;
-	}
-	register(path, handlerOrOptions) {
-		if (typeof handlerOrOptions === "function") this.handlers[path] = { handler: handlerOrOptions };
-		else this.handlers[path] = this.createHandlerEntry(handlerOrOptions);
-		return this;
-	}
-	/**
-	* Handles a normalized incoming webhook request.
-	*
-	* @param req - Normalized request object.
-	* @returns Normalized response for the adapter/framework layer.
-	*/
-	async handle(req) {
-		try {
-			const normalizedPath = this.normalizePath(req);
-			if (normalizedPath === null) return {
-				status: 404,
-				body: { error: "not found" }
-			};
-			const handlerEntry = this.handlers[normalizedPath];
-			if (!handlerEntry) return {
-				status: 404,
-				body: { error: "not found" }
-			};
-			await this.runGlobalBeforeHooks(req);
-			await this.runRouteBeforeHooks(req, handlerEntry.before);
-			if (this.verify) await this.verify(req);
-			const parsedJson = this.parseRequestBody(req);
-			const validationResult = await this.validatePayload(parsedJson, handlerEntry.schema);
-			if (this.isErrorResponse(validationResult)) return validationResult;
-			const response = await this.executeHandler(handlerEntry.handler, req, validationResult);
-			await this.runRouteAfterHooks(req, response, handlerEntry.after);
-			await this.runGlobalAfterHooks(req, response);
-			return response;
-		} catch (error) {
-			return this.handleError(error, req);
-		}
-	}
-	normalizePath(req) {
-		let pathname = req.path;
-		try {
-			pathname = new URL(req.path).pathname;
-		} catch {}
-		if (!pathname.startsWith(this.prefix)) return null;
-		pathname = pathname.slice(this.prefix.length - 1);
-		req.path = pathname;
-		return pathname.startsWith("/") ? pathname.slice(1) : pathname;
-	}
-	async runGlobalBeforeHooks(req) {
-		for (const hook of this.globalBeforeHooks) await hook(req);
-	}
-	createHandlerEntry(options) {
-		const entry = { handler: options.handler };
-		if (options.schema !== void 0) entry.schema = options.schema;
-		if (options.before !== void 0) entry.before = Array.isArray(options.before) ? options.before : [options.before];
-		if (options.after !== void 0) entry.after = Array.isArray(options.after) ? options.after : [options.after];
-		return entry;
-	}
-	async runRouteBeforeHooks(req, before) {
-		if (before) for (const hook of before) await hook(req);
-	}
-	parseRequestBody(req) {
-		try {
-			const parsed = JSON.parse(new TextDecoder().decode(req.rawBody));
-			req.json = parsed;
-			return parsed;
-		} catch {
-			return;
-		}
-	}
-	isErrorResponse(value) {
-		return typeof value === "object" && value !== null && "status" in value && typeof value.status === "number";
-	}
-	async validatePayload(parsedJson, schema) {
-		if (!schema) return parsedJson;
-		const result = await standardValidate(schema, parsedJson, { throwOnError: false });
-		if (result.issues) return {
-			status: 400,
-			body: {
-				error: "validation failed",
-				issues: result.issues.map((issue) => ({
-					path: issue.path?.map((p) => typeof p === "object" && "key" in p ? String(p.key) : String(p)),
-					message: issue.message
-				}))
-			}
-		};
-		return result.value;
-	}
-	async executeHandler(handler, req, validatedPayload) {
-		return await handler({
-			req,
-			payload: validatedPayload,
-			ack: async (r) => {
-				const response = {
-					status: r?.status ?? 200,
-					body: r?.body ?? "ok"
-				};
-				if (r?.headers !== void 0) response.headers = r.headers;
-				return response;
-			}
-		}) ?? {
-			status: 200,
-			body: "ok"
-		};
-	}
-	async runRouteAfterHooks(req, response, after) {
-		if (after) for (const hook of after) await hook(req, response);
-	}
-	async runGlobalAfterHooks(req, response) {
-		for (const hook of this.globalAfterHooks) await hook(req, response);
-	}
-	async handleError(error, req) {
-		if (this.globalErrorHook) {
-			const errorResponse = await this.globalErrorHook(error, req);
-			if (errorResponse) return errorResponse;
-		}
-		return {
-			status: 500,
-			body: { error: error instanceof Error ? error.message : "Internal server error" }
-		};
-	}
-};
-/**
-* Factory helper for creating a webhook router instance.
-*
-* @param opts - Optional global router options.
-* @returns A new webhook router.
-*/
-function createWebhookRouter(opts) {
-	return new WebhookRouter(opts);
-}
-//#endregion
-export { WebhookRouter, createWebhookRouter };
-
-//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@zap-studio/validation\";\nimport { standardValidate } from \"@zap-studio/validation\";\n\nimport type {\n  AfterHook,\n  BeforeHook,\n  ErrorHook,\n  InferSchemaOutput,\n  NormalizedRequest,\n  NormalizedResponse,\n  RegisterOptions,\n  SchemaRouteOptions,\n  WebhookHandler,\n} from \"./types/index.js\";\n\n/**\n * Schema-first webhook router with path dispatching, validation, and optional verification.\n *\n * @template TMap - Internal route payload map built incrementally via `register`.\n */\ninterface HandlerEntry<TPayload = unknown> {\n  after?: AfterHook[];\n  before?: BeforeHook[];\n  handler: WebhookHandler<TPayload>;\n  schema?: StandardSchemaV1<unknown, TPayload>;\n}\n\ntype HandlerStore = Record<string, HandlerEntry<unknown>>;\n\nexport interface WebhookRouterOptions {\n  /** Global hooks executed after successful route handler completion. */\n  after?: AfterHook | AfterHook[];\n  /** Global hooks executed before route-level hooks and verification. */\n  before?: BeforeHook | BeforeHook[];\n  /** Global error hook used to override the default `500` response. */\n  onError?: ErrorHook;\n  /** Required path prefix for all webhook routes. Defaults to `\"/webhooks/\"`. */\n  prefix?: string;\n  /** Optional request verification function (for signature checks, auth, etc.). */\n  verify?: (req: NormalizedRequest) => Promise<void> | void;\n}\n\nfunction toArray<T>(value: T | T[] | undefined): T[] {\n  if (value === undefined) {\n    return [];\n  }\n\n  return Array.isArray(value) ? value : [value];\n}\n\n/**\n * Main webhook router class.\n *\n * Register routes with typed schemas and call `handle` with a normalized request.\n */\nexport class WebhookRouter<TMap = unknown> {\n  private readonly handlers: HandlerStore = {};\n  private readonly verify: ((req: NormalizedRequest) => Promise<void> | void) | undefined;\n  private readonly globalBeforeHooks: BeforeHook[] = [];\n  private readonly globalAfterHooks: AfterHook[] = [];\n  private readonly globalErrorHook: ErrorHook | undefined;\n  private readonly prefix: string;\n\n  constructor(opts: WebhookRouterOptions = {}) {\n    this.prefix = opts.prefix ?? \"/webhooks/\";\n    this.verify = opts.verify;\n    this.globalBeforeHooks = toArray(opts.before);\n    this.globalAfterHooks = toArray(opts.after);\n    this.globalErrorHook = opts.onError;\n  }\n\n  /**\n   * Register a webhook handler for a specific path.\n   *\n   * When a schema is provided, `payload` is inferred from the schema output type.\n   *\n   * @param path - Route path relative to configured prefix.\n   * @param handlerOrOptions - Handler function or schema-based registration options.\n   * @returns The same router instance with an updated internal route type map.\n   */\n  register<Path extends string, TSchema extends StandardSchemaV1<unknown, unknown>>(\n    path: Path,\n    handlerOrOptions: SchemaRouteOptions<TSchema>,\n  ): WebhookRouter<TMap & Record<Path, InferSchemaOutput<TSchema>>>;\n  register<Path extends string, TPayload>(\n    path: Path,\n    handlerOrOptions: RegisterOptions<TPayload>,\n  ): WebhookRouter<TMap & Record<Path, TPayload>>;\n  register<Path extends string>(\n    path: Path,\n    handlerOrOptions: WebhookHandler<unknown>,\n  ): WebhookRouter<TMap & Record<Path, unknown>>;\n  register(\n    path: string,\n    handlerOrOptions: WebhookHandler<unknown> | RegisterOptions<unknown>,\n  ): WebhookRouter<TMap> {\n    if (typeof handlerOrOptions === \"function\") {\n      this.handlers[path] = { handler: handlerOrOptions };\n    } else {\n      this.handlers[path] = this.createHandlerEntry(handlerOrOptions);\n    }\n\n    return this;\n  }\n\n  /**\n   * Handles a normalized incoming webhook request.\n   *\n   * @param req - Normalized request object.\n   * @returns Normalized response for the adapter/framework layer.\n   */\n  async handle(req: NormalizedRequest): Promise<NormalizedResponse> {\n    try {\n      const normalizedPath = this.normalizePath(req);\n\n      if (normalizedPath === null) {\n        return { status: 404, body: { error: \"not found\" } };\n      }\n\n      const handlerEntry = this.handlers[normalizedPath];\n      if (!handlerEntry) {\n        return { status: 404, body: { error: \"not found\" } };\n      }\n\n      await this.runGlobalBeforeHooks(req);\n      await this.runRouteBeforeHooks(req, handlerEntry.before);\n\n      if (this.verify) {\n        await this.verify(req);\n      }\n\n      const parsedJson = this.parseRequestBody(req);\n      const validationResult = await this.validatePayload(parsedJson, handlerEntry.schema);\n\n      if (this.isErrorResponse(validationResult)) {\n        return validationResult;\n      }\n\n      const response = await this.executeHandler(handlerEntry.handler, req, validationResult);\n\n      await this.runRouteAfterHooks(req, response, handlerEntry.after);\n      await this.runGlobalAfterHooks(req, response);\n\n      return response;\n    } catch (error) {\n      return this.handleError(error, req);\n    }\n  }\n\n  private normalizePath(req: NormalizedRequest): string | null {\n    let pathname = req.path;\n    try {\n      // Try to parse as URL (e.g. handles full URLs like https://example.com/webhooks/path -> /webhooks/path)\n      const url = new URL(req.path);\n      pathname = url.pathname;\n    } catch {\n      // Not a full URL, use the path as-is\n    }\n\n    // Require prefix (e.g. /webhooks/path -> /path)\n    if (!pathname.startsWith(this.prefix)) {\n      // Path doesn't start with the required prefix - not a webhook route\n      return null;\n    }\n\n    // Strip prefix and keep the leading slash\n    pathname = pathname.slice(this.prefix.length - 1);\n    req.path = pathname;\n\n    // Normalize path by removing leading slash for handler matching (e.g. /path -> path)\n    const normalizedPath = pathname.startsWith(\"/\") ? pathname.slice(1) : pathname;\n\n    return normalizedPath;\n  }\n\n  private async runGlobalBeforeHooks(req: NormalizedRequest): Promise<void> {\n    for (const hook of this.globalBeforeHooks) {\n      await hook(req);\n    }\n  }\n\n  private createHandlerEntry(options: RegisterOptions<unknown>): HandlerEntry<unknown> {\n    const entry: HandlerEntry<unknown> = {\n      handler: options.handler,\n    };\n\n    if (options.schema !== undefined) {\n      entry.schema = options.schema;\n    }\n\n    if (options.before !== undefined) {\n      entry.before = Array.isArray(options.before) ? options.before : [options.before];\n    }\n\n    if (options.after !== undefined) {\n      entry.after = Array.isArray(options.after) ? options.after : [options.after];\n    }\n\n    return entry;\n  }\n\n  private async runRouteBeforeHooks(req: NormalizedRequest, before?: BeforeHook[]): Promise<void> {\n    if (before) {\n      for (const hook of before) {\n        await hook(req);\n      }\n    }\n  }\n\n  private parseRequestBody<TParsed = unknown>(req: NormalizedRequest): TParsed | undefined {\n    try {\n      const parsed = JSON.parse(new TextDecoder().decode(req.rawBody));\n      req.json = parsed;\n      return parsed as TParsed;\n    } catch {\n      return;\n    }\n  }\n\n  private isErrorResponse(value: unknown): value is NormalizedResponse {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"status\" in value &&\n      typeof value.status === \"number\"\n    );\n  }\n\n  private async validatePayload<TPayload>(\n    parsedJson: unknown,\n    schema?: StandardSchemaV1<unknown, TPayload>,\n  ): Promise<TPayload | NormalizedResponse> {\n    if (!schema) {\n      return parsedJson as TPayload;\n    }\n\n    const result = await standardValidate(schema, parsedJson, {\n      throwOnError: false,\n    });\n\n    if (result.issues) {\n      return {\n        status: 400,\n        body: {\n          error: \"validation failed\",\n          issues: result.issues.map((issue) => ({\n            path: issue.path?.map((p) =>\n              typeof p === \"object\" && \"key\" in p ? String(p.key) : String(p),\n            ),\n            message: issue.message,\n          })),\n        },\n      };\n    }\n\n    return result.value as TPayload;\n  }\n\n  private async executeHandler<TPayload = unknown>(\n    handler: WebhookHandler<TPayload>,\n    req: NormalizedRequest,\n    validatedPayload: TPayload,\n  ): Promise<NormalizedResponse> {\n    const responded = await handler({\n      req,\n      payload: validatedPayload,\n      ack: async (r?: Partial<NormalizedResponse>) => {\n        const response: NormalizedResponse = {\n          status: r?.status ?? 200,\n          body: r?.body ?? \"ok\",\n        };\n\n        if (r?.headers !== undefined) {\n          response.headers = r.headers;\n        }\n\n        return response;\n      },\n    });\n\n    return responded ?? { status: 200, body: \"ok\" };\n  }\n\n  private async runRouteAfterHooks(\n    req: NormalizedRequest,\n    response: NormalizedResponse,\n    after?: AfterHook[],\n  ): Promise<void> {\n    if (after) {\n      for (const hook of after) {\n        await hook(req, response);\n      }\n    }\n  }\n\n  private async runGlobalAfterHooks(\n    req: NormalizedRequest,\n    response: NormalizedResponse,\n  ): Promise<void> {\n    for (const hook of this.globalAfterHooks) {\n      await hook(req, response);\n    }\n  }\n\n  private async handleError<TError = unknown>(\n    error: TError,\n    req: NormalizedRequest,\n  ): Promise<NormalizedResponse> {\n    if (this.globalErrorHook) {\n      const errorResponse = await this.globalErrorHook(error as Error, req);\n      if (errorResponse) {\n        return errorResponse;\n      }\n    }\n\n    return {\n      status: 500,\n      body: {\n        error: error instanceof Error ? error.message : \"Internal server error\",\n      },\n    };\n  }\n}\n\n/**\n * Factory helper for creating a webhook router instance.\n *\n * @param opts - Optional global router options.\n * @returns A new webhook router.\n */\nexport function createWebhookRouter(opts?: WebhookRouterOptions): WebhookRouter {\n  return new WebhookRouter(opts);\n}\n"],"mappings":"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"}

package/dist/types/index.d.mts

@@ -1,93 +0,0 @@
-import { StandardSchemaV1 } from "@zap-studio/validation";
-
-//#region src/types/index.d.ts
-/** Framework-agnostic request shape consumed by the webhook router. */
-interface NormalizedRequest {
-  /** The headers of the request (e.g. { "Authorization": "Bearer token" }) */
-  headers: Headers;
-  /** The parsed JSON body of the request if applicable */
-  json?: unknown;
-  /** The HTTP method of the request */
-  method: Request["method"];
-  /** The route parameters of the request */
-  params?: Record<string, string>;
-  /** The path of the request you registered in the router (e.g. "payment", "subscription") */
-  path: string;
-  /** The query parameters of the request */
-  query?: Record<string, string | string[]>;
-  /** The raw body of the request (for signature) */
-  rawBody: Uint8Array<ArrayBufferLike>;
-  /** The parsed text body of the request if applicable */
-  text?: string;
-}
-/** Framework-agnostic response shape returned by the webhook router. */
-interface NormalizedResponse<TBody = unknown> {
-  /** The body of the response */
-  body?: TBody;
-  /** The headers of the response */
-  headers?: Headers;
-  /** The HTTP status code of the response */
-  status: number;
-}
-/** Route registration options for a webhook handler. */
-interface RegisterOptions<T> {
-  /** Hooks that run after successful processing (before global after hooks) */
-  after?: AfterHook | AfterHook[];
-  /** Hooks that run before request processing (after global before hooks) */
-  before?: BeforeHook | BeforeHook[];
-  /** The handler function to process the webhook */
-  handler: WebhookHandler<T>;
-  /** Optional Standard Schema validator to validate the webhook payload */
-  schema?: StandardSchemaV1<unknown, T>;
-}
-/**
-* Infers the output type from a Standard Schema instance.
-*
-* @template TSchema - A Standard Schema type.
-*/
-type InferSchemaOutput<TSchema> = TSchema extends StandardSchemaV1<unknown, infer TOutput> ? TOutput : never;
-/**
-* Route options where schema is required and handler payload is inferred.
-*
-* @template TSchema - Schema used to infer handler payload type.
-*/
-type SchemaRouteOptions<TSchema extends StandardSchemaV1<unknown, unknown>> = Omit<RegisterOptions<InferSchemaOutput<TSchema>>, "schema"> & {
-  schema: TSchema;
-};
-interface RouteLike {
-  after?: AfterHook | AfterHook[];
-  before?: BeforeHook | BeforeHook[];
-  handler: WebhookHandler<unknown>;
-  schema: StandardSchemaV1<unknown, unknown>;
-}
-/**
-* Applies schema-driven payload inference to each route entry.
-*
-* @template TRoutes - Route dictionary keyed by webhook path.
-*/
-type SchemaRoutes<TRoutes extends Record<string, RouteLike>> = { [P in keyof TRoutes]: SchemaRouteOptions<TRoutes[P]["schema"]> };
-/** The webhook handler function, responsible for processing incoming webhook events. */
-type WebhookHandler<TPayload = unknown> = (ctx: {
-  req: NormalizedRequest;
-  payload: TPayload;
-  ack: (res?: Partial<NormalizedResponse>) => Promise<NormalizedResponse>;
-}) => Promise<NormalizedResponse | undefined> | NormalizedResponse | undefined;
-/** Maps route keys to their payload-specific webhook handlers. */
-type HandlerMap<TMap extends Record<string, unknown>> = { [P in keyof TMap]: WebhookHandler<TMap[P]> };
-/**
-* Builds a webhook payload map from a schema-based route dictionary.
-*
-* @template TRoutes - Route dictionary keyed by webhook path.
-*/
-type InferWebhookMapFromRoutes<TRoutes extends Record<string, RouteLike>> = { [P in keyof TRoutes]: InferSchemaOutput<TRoutes[P]["schema"]> };
-/** Verification function for incoming requests */
-type VerifyFn = (req: NormalizedRequest) => Promise<void> | void;
-/** Hook function that runs before request processing */
-type BeforeHook = (req: NormalizedRequest) => Promise<void> | void;
-/** Hook function that runs after successful request processing */
-type AfterHook = (req: NormalizedRequest, res: NormalizedResponse) => Promise<void> | void;
-/** Hook function that runs when an error occurs */
-type ErrorHook = (error: Error, req: NormalizedRequest) => Promise<NormalizedResponse | undefined> | NormalizedResponse | undefined;
-//#endregion
-export { AfterHook, BeforeHook, ErrorHook, HandlerMap, InferSchemaOutput, InferWebhookMapFromRoutes, NormalizedRequest, NormalizedResponse, RegisterOptions, SchemaRouteOptions, SchemaRoutes, VerifyFn, WebhookHandler };
-//# sourceMappingURL=index.d.mts.map

package/dist/types/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/types/index.ts"],"mappings":";;;;UAGiB,iBAAA;EAAjB;EAEE,OAAA,EAAS,OAAA;;EAET,IAAA;;EAEA,MAAA,EAAQ,OAAA;;EAER,MAAA,GAAS,MAAA;;EAET,IAAA;EAIS;EAFT,KAAA,GAAQ,MAAA;;EAER,OAAA,EAAS,UAAA,CAAW,eAAA;;EAEpB,IAAA;AAAA;;UAIe,kBAAA;;EAEf,IAAA,GAAO,KAAA;;EAEP,OAAA,GAAU,OAAA;;EAEV,MAAA;AAAA;;UAIe,eAAA;EAVA;EAYf,KAAA,GAAQ,SAAA,GAAY,SAAA;EARV;EAUV,MAAA,GAAS,UAAA,GAAa,UAAA;;EAEtB,OAAA,EAAS,cAAA,CAAe,CAAA;;EAExB,MAAA,GAAS,gBAAA,UAA0B,CAAA;AAAA;;;AARrC;;;KAgBY,iBAAA,YACV,OAAA,SAAgB,gBAAA,2BAA2C,OAAA;;;;;;KAOjD,kBAAA,iBAAmC,gBAAA,sBAAsC,IAAA,CACnF,eAAA,CAAgB,iBAAA,CAAkB,OAAA;EAGlC,MAAA,EAAQ,OAAA;AAAA;AAAA,UAGA,SAAA;EACR,KAAA,GAAQ,SAAA,GAAY,SAAA;EACpB,MAAA,GAAS,UAAA,GAAa,UAAA;EACtB,OAAA,EAAS,cAAA;EACT,MAAA,EAAQ,gBAAA;AAAA;;;;;;KAQE,YAAA,iBAA6B,MAAA,SAAe,SAAA,mBAC1C,OAAA,GAAU,kBAAA,CAAmB,OAAA,CAAQ,CAAA;;KAIvC,cAAA,wBAAsC,GAAA;EAChD,GAAA,EAAK,iBAAA;EACL,OAAA,EAAS,QAAA;EACT,GAAA,GAAM,GAAA,GAAM,OAAA,CAAQ,kBAAA,MAAwB,OAAA,CAAQ,kBAAA;AAAA,MAChD,OAAA,CAAQ,kBAAA,gBAAkC,kBAAA;;KAGpC,UAAA,cAAwB,MAAA,mCACtB,IAAA,GAAO,cAAA,CAAe,IAAA,CAAK,CAAA;;;;;;KAQ7B,yBAAA,iBAA0C,MAAA,SAAe,SAAA,mBACvD,OAAA,GAAU,iBAAA,CAAkB,OAAA,CAAQ,CAAA;;KAItC,QAAA,IAAY,GAAA,EAAK,iBAAA,KAAsB,OAAA;;KAGvC,UAAA,IAAc,GAAA,EAAK,iBAAA,KAAsB,OAAA;;KAGzC,SAAA,IAAa,GAAA,EAAK,iBAAA,EAAmB,GAAA,EAAK,kBAAA,KAAuB,OAAA;;KAGjE,SAAA,IACV,KAAA,EAAO,KAAA,EACP,GAAA,EAAK,iBAAA,KACF,OAAA,CAAQ,kBAAA,gBAAkC,kBAAA"}

package/dist/types/index.mjs

@@ -1 +0,0 @@
-export {};

package/dist/utils/index.d.mts

@@ -1,13 +0,0 @@
-//#region src/utils/index.d.ts
-/**
-* Compares two strings in constant time to prevent timing attacks.
-*
-* @example
-* ```ts
-* const isEqual = constantTimeEquals("string1", "string2"); // returns false
-* ```
-*/
-declare function constantTimeEquals(a: string, b: string): boolean;
-//#endregion
-export { constantTimeEquals };
-//# sourceMappingURL=index.d.mts.map

package/dist/utils/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/utils/index.ts"],"mappings":";;AAQA;;;;;;;iBAAgB,kBAAA,CAAmB,CAAA,UAAW,CAAA"}

package/dist/utils/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":["/**\n * Compares two strings in constant time to prevent timing attacks.\n *\n * @example\n * ```ts\n * const isEqual = constantTimeEquals(\"string1\", \"string2\"); // returns false\n * ```\n */\nexport function constantTimeEquals(a: string, b: string): boolean {\n  if (a.length !== b.length) {\n    return false;\n  }\n\n  let result = 0;\n  for (let i = 0; i < a.length; i += 1) {\n    result |= a.charCodeAt(i) ^ b.charCodeAt(i);\n  }\n\n  return result === 0;\n}\n"],"mappings":";;;;;;;;;AAQA,SAAgB,mBAAmB,GAAW,GAAoB;AAChE,KAAI,EAAE,WAAW,EAAE,OACjB,QAAO;CAGT,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,EACjC,WAAU,EAAE,WAAW,EAAE,GAAG,EAAE,WAAW,EAAE;AAG7C,QAAO,WAAW"}

package/dist/verify.d.mts

@@ -1,54 +0,0 @@
-import { VerifyFn } from "./types/index.mjs";
-
-//#region src/verify.d.ts
-declare const HMAC_HASH: {
-  readonly sha1: "SHA-1";
-  readonly sha256: "SHA-256";
-  readonly sha384: "SHA-384";
-  readonly sha512: "SHA-512";
-};
-type HmacAlgorithm = keyof typeof HMAC_HASH;
-/**
-* Creates a webhook verifier that validates an HMAC signature from a request header.
-*
-* The verifier imports the provided string secret once, computes an HMAC from
-* `req.rawBody`, normalizes the incoming header value, and compares both
-* signatures in constant time.
-*
-* Header values like `sha256=<hex>` are supported so common provider formats
-* such as GitHub work without extra parsing.
-*
-* @example
-* ```ts
-* import { createWebhookRouter } from "@zap-studio/webhooks";
-* import { createHmacVerifier } from "@zap-studio/webhooks/verify";
-*
-* const router = createWebhookRouter({
-*   verify: createHmacVerifier({
-*     headerName: "x-hub-signature-256",
-*     secret: process.env.GITHUB_WEBHOOK_SECRET!,
-*   }),
-* });
-* ```
-*
-* @param options - Verifier configuration.
-* @param options.headerName - Header containing the provider signature.
-* @param options.secret - Shared HMAC secret as a string.
-* @param options.algo - HMAC hash algorithm. Defaults to `"sha256"`.
-* @returns A router-compatible request verifier.
-*
-* @throws {VerificationError}
-* Thrown when verifier setup fails or request verification does not pass.
-*/
-declare function createHmacVerifier({
-  headerName,
-  secret,
-  algo
-}: {
-  headerName: string;
-  secret: string;
-  algo?: HmacAlgorithm;
-}): VerifyFn;
-//#endregion
-export { createHmacVerifier };
-//# sourceMappingURL=verify.d.mts.map

package/dist/verify.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"verify.d.mts","names":[],"sources":["../src/verify.ts"],"mappings":";;;cAIM,SAAA;EAAA,SACJ,IAAA;EAAA,SACA,MAAA;EAAA,SACA,MAAA;EAAA,SACA,MAAA;AAAA;AAAA,KAGG,aAAA,gBAA6B,SAAA;;;;;;AAHhC;;;;;AAqCF;;;;;;;;;;;;;;;;;;;;;;iBAAgB,kBAAA,CAAA;EACd,UAAA;EACA,MAAA;EACA;AAAA;EAEA,UAAA;EACA,MAAA;EACA,IAAA,GAAO,aAAA;AAAA,IACL,QAAA"}

package/dist/verify.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"verify.mjs","names":[],"sources":["../src/verify.ts"],"sourcesContent":["import { VerificationError } from \"./errors.js\";\nimport type { VerifyFn } from \"./types/index.js\";\nimport { constantTimeEquals } from \"./utils/index.js\";\n\nconst HMAC_HASH = {\n  sha1: \"SHA-1\",\n  sha256: \"SHA-256\",\n  sha384: \"SHA-384\",\n  sha512: \"SHA-512\",\n} as const;\n\ntype HmacAlgorithm = keyof typeof HMAC_HASH;\n\n/**\n * Creates a webhook verifier that validates an HMAC signature from a request header.\n *\n * The verifier imports the provided string secret once, computes an HMAC from\n * `req.rawBody`, normalizes the incoming header value, and compares both\n * signatures in constant time.\n *\n * Header values like `sha256=<hex>` are supported so common provider formats\n * such as GitHub work without extra parsing.\n *\n * @example\n * ```ts\n * import { createWebhookRouter } from \"@zap-studio/webhooks\";\n * import { createHmacVerifier } from \"@zap-studio/webhooks/verify\";\n *\n * const router = createWebhookRouter({\n *   verify: createHmacVerifier({\n *     headerName: \"x-hub-signature-256\",\n *     secret: process.env.GITHUB_WEBHOOK_SECRET!,\n *   }),\n * });\n * ```\n *\n * @param options - Verifier configuration.\n * @param options.headerName - Header containing the provider signature.\n * @param options.secret - Shared HMAC secret as a string.\n * @param options.algo - HMAC hash algorithm. Defaults to `\"sha256\"`.\n * @returns A router-compatible request verifier.\n *\n * @throws {VerificationError}\n * Thrown when verifier setup fails or request verification does not pass.\n */\nexport function createHmacVerifier({\n  headerName,\n  secret,\n  algo = \"sha256\",\n}: {\n  headerName: string;\n  secret: string;\n  algo?: HmacAlgorithm;\n}): VerifyFn {\n  const subtle = globalThis.crypto?.subtle;\n  if (!subtle) {\n    throw new VerificationError(\"Web Crypto API is unavailable in this runtime\");\n  }\n\n  const hash = HMAC_HASH[algo];\n  if (!hash) {\n    throw new VerificationError(`Unsupported HMAC algorithm: ${algo}`);\n  }\n\n  const keyPromise = subtle.importKey(\n    \"raw\",\n    new TextEncoder().encode(secret),\n    { name: \"HMAC\", hash },\n    false,\n    [\"sign\"],\n  );\n\n  return async (req) => {\n    const actual = req.headers.get(headerName);\n    if (!actual) {\n      throw new VerificationError(`Missing signature header: ${headerName}`);\n    }\n\n    const key = await keyPromise;\n    const signature = await subtle.sign(\"HMAC\", key, req.rawBody as BufferSource);\n    const expected = toHex(new Uint8Array(signature));\n\n    if (!constantTimeEquals(expected, normalizeSignature(actual))) {\n      throw new VerificationError(`Invalid signature for header: ${headerName}`);\n    }\n  };\n}\n\nfunction toHex(bytes: Uint8Array): string {\n  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, \"0\")).join(\"\");\n}\n\nfunction normalizeSignature(signature: string): string {\n  return signature\n    .replace(/^[a-z0-9-]+=/i, \"\")\n    .trim()\n    .toLowerCase();\n}\n"],"mappings":";;;AAIA,MAAM,YAAY;CAChB,MAAM;CACN,QAAQ;CACR,QAAQ;CACR,QAAQ;CACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCD,SAAgB,mBAAmB,EACjC,YACA,QACA,OAAO,YAKI;CACX,MAAM,SAAS,WAAW,QAAQ;AAClC,KAAI,CAAC,OACH,OAAM,IAAI,kBAAkB,gDAAgD;CAG9E,MAAM,OAAO,UAAU;AACvB,KAAI,CAAC,KACH,OAAM,IAAI,kBAAkB,+BAA+B,OAAO;CAGpE,MAAM,aAAa,OAAO,UACxB,OACA,IAAI,aAAa,CAAC,OAAO,OAAO,EAChC;EAAE,MAAM;EAAQ;EAAM,EACtB,OACA,CAAC,OAAO,CACT;AAED,QAAO,OAAO,QAAQ;EACpB,MAAM,SAAS,IAAI,QAAQ,IAAI,WAAW;AAC1C,MAAI,CAAC,OACH,OAAM,IAAI,kBAAkB,6BAA6B,aAAa;EAGxE,MAAM,MAAM,MAAM;EAClB,MAAM,YAAY,MAAM,OAAO,KAAK,QAAQ,KAAK,IAAI,QAAwB;AAG7E,MAAI,CAAC,mBAFY,MAAM,IAAI,WAAW,UAAU,CAAC,EAEf,mBAAmB,OAAO,CAAC,CAC3D,OAAM,IAAI,kBAAkB,iCAAiC,aAAa;;;AAKhF,SAAS,MAAM,OAA2B;AACxC,QAAO,MAAM,KAAK,QAAQ,SAAS,KAAK,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,KAAK,GAAG;;AAGjF,SAAS,mBAAmB,WAA2B;AACrD,QAAO,UACJ,QAAQ,iBAAiB,GAAG,CAC5B,MAAM,CACN,aAAa"}