@k-msg/webhook 0.19.1 → 0.20.0

package/README.md

@@ -2,17 +2,13 @@
 
 > Canonical docs: [k-msg.and.guide](https://k-msg.and.guide)
 
-Webhook delivery helpers for emitting real-time message events to HTTP endpoints.
+Runtime-first webhook package for message events.
 
-This package provides:
-- `WebhookService`: a convenience facade (in-memory endpoint registry + batching)
-- `WebhookDispatcher`: HTTP delivery with retries/backoff
-- `SecurityManager`: HMAC signature generation/verification
-- Zod schemas: `WebhookEventSchema`, `WebhookEndpointSchema`, `WebhookDeliverySchema`
+This package now follows a DX-first flow:
 
-Note:
-- The default `WebhookService` storage is in-memory. For persistence/advanced workflows, see the exported building blocks such as `EndpointManager` and `DeliveryStore`.
-- This package is runtime-neutral (Edge/Web/Node). Node built-ins are not required by default.
+1. Start in 5 minutes with in-memory persistence
+2. Move to production by swapping persistence to D1
+3. Extend to SQLite/Drizzle(Postgres) with the same store contract
 
 ## Install
 
@@ -22,50 +18,56 @@ npm install @k-msg/webhook
 bun add @k-msg/webhook
 ```
 
-## Quickstart (WebhookService)
+## Runtime API (root)
+
+`@k-msg/webhook` root exports runtime-only APIs:
+
+- `WebhookRuntimeService`
+- `createInMemoryWebhookPersistence`
+- `addEndpoints`, `probeEndpoint`
+- `validateEndpointUrl`
+
+Advanced building blocks are now exposed from subpaths:
+
+- `@k-msg/webhook/toolkit`
+- `@k-msg/webhook/adapters/cloudflare`
+
+## Quickstart (in-memory)
 
 ```ts
-import { readRuntimeEnv } from "@k-msg/core";
 import {
   WebhookEventType,
-  WebhookService,
+  WebhookRuntimeService,
+  createInMemoryWebhookPersistence,
   type WebhookConfig,
 } from "@k-msg/webhook";
 
 const config: WebhookConfig = {
   maxRetries: 3,
-  retryDelayMs: 1000,
-  // Optional: maxDelayMs, backoffMultiplier, jitter
+  retryDelayMs: 1_000,
   timeoutMs: 30_000,
-  enableSecurity: true,
-  // Optional: used when an endpoint does not provide its own secret
-  secretKey: readRuntimeEnv("WEBHOOK_SECRET"),
-  // Optional: algorithm, signatureHeader, signaturePrefix
+  enableSecurity: false,
   enabledEvents: [
     WebhookEventType.MESSAGE_SENT,
-    WebhookEventType.MESSAGE_DELIVERED,
     WebhookEventType.MESSAGE_FAILED,
+    WebhookEventType.SYSTEM_MAINTENANCE,
   ],
   batchSize: 10,
   batchTimeoutMs: 5_000,
 };
 
-const service = new WebhookService(config);
+const runtime = new WebhookRuntimeService({
+  delivery: config,
+  persistence: createInMemoryWebhookPersistence(),
+});
 
-const endpoint = await service.registerEndpoint({
+await runtime.addEndpoint({
   url: "https://example.com/webhooks/k-msg",
   active: true,
   events: [WebhookEventType.MESSAGE_SENT, WebhookEventType.MESSAGE_FAILED],
-  // Optional: endpoint-specific secret (preferred over config.secretKey)
-  secret: readRuntimeEnv("WEBHOOK_SECRET"),
-  // Optional: per-endpoint retry overrides
-  retryConfig: { maxRetries: 5, retryDelayMs: 1000, backoffMultiplier: 2 },
-  // Optional: metadata-based filters
-  filters: { providerId: ["iwinv", "solapi"] },
 });
 
-// Asynchronous emit (batched)
-await service.emit({
+await runtime.emitSync({
   id: crypto.randomUUID(),
   type: WebhookEventType.MESSAGE_SENT,
   timestamp: new Date(),
@@ -74,132 +76,119 @@ await service.emit({
   version: "1.0",
 });
 
-// Synchronous emit (returns delivery attempts)
-const deliveries = await service.emitSync({
-  id: crypto.randomUUID(),
-  type: WebhookEventType.MESSAGE_FAILED,
-  timestamp: new Date(),
-  data: { messageId: "msg_456", status: "failed" },
-  metadata: { providerId: "solapi", messageId: "msg_456" },
-  version: "1.0",
-});
-
-// Inspect recent deliveries (in-memory)
-const recent = await service.getDeliveries(endpoint.id);
-console.log(deliveries.length, recent.length);
-
-await service.shutdown();
+await runtime.shutdown();
 ```
 
-### Endpoint Registration Behavior
+## D1 quickstart (same runtime API)
 
-`registerEndpoint()` validates the URL and sends a test webhook once (a `system.maintenance` event via `testEndpoint()`).
-
-## Security (HMAC Signatures)
+```ts
+import {
+  WebhookEventType,
+  WebhookRuntimeService,
+  type WebhookConfig,
+} from "@k-msg/webhook";
+import { createD1WebhookPersistence } from "@k-msg/webhook/adapters/cloudflare";
 
-When security is enabled and a secret is available (`endpoint.secret` or `config.secretKey`), outgoing requests include:
-- `X-Webhook-Timestamp`: unix epoch seconds (string)
-- `X-Webhook-Signature`: HMAC signature (default: `sha256=<hex>`)
+type Env = {
+  DB: D1Database;
+};
 
-Signature input is:
+const config: WebhookConfig = {
+  maxRetries: 3,
+  retryDelayMs: 1_000,
+  timeoutMs: 30_000,
+  enableSecurity: false,
+  enabledEvents: [WebhookEventType.MESSAGE_SENT, WebhookEventType.MESSAGE_FAILED],
+  batchSize: 10,
+  batchTimeoutMs: 5_000,
+};
 
-```
-${timestamp}.${rawBody}
+function createRuntime(env: Env): WebhookRuntimeService {
+  return new WebhookRuntimeService({
+    delivery: config,
+    persistence: createD1WebhookPersistence(env.DB),
+    security: {
+      allowPrivateHosts: true,
+    },
+  });
+}
 ```
 
-To verify a webhook, you must use the exact raw request body string.
+`createD1WebhookPersistence()` initializes schema automatically by default.
 
-### Hono Example
+## Schema helpers (Cloudflare)
 
 ```ts
-import { Hono } from "hono";
-import { readRuntimeEnv } from "@k-msg/core";
-import { SecurityManager } from "@k-msg/webhook";
+import {
+  buildWebhookSchemaSql,
+  initializeWebhookSchema,
+} from "@k-msg/webhook/adapters/cloudflare";
 
-const app = new Hono();
+const statements = buildWebhookSchemaSql();
+// run statements in your migration system, or:
+await initializeWebhookSchema(env.DB);
+```
 
-const security = new SecurityManager({
-  algorithm: "sha256",
-  signatureHeader: "X-Webhook-Signature",
-  signaturePrefix: "sha256=",
-});
+## SQLite / Drizzle(Postgres) snippets
 
-app.post("/webhooks/k-msg", async (c) => {
-  const payload = await c.req.text();
+`WebhookRuntimeService` accepts custom stores via `endpointStore` + `deliveryStore`.
+Implement the same interfaces to plug any backend:
 
-  const signature = c.req.header("X-Webhook-Signature") ?? "";
-  const timestamp = c.req.header("X-Webhook-Timestamp") ?? "";
-  const secret = readRuntimeEnv("WEBHOOK_SECRET") ?? "";
+```ts
+import type {
+  WebhookDeliveryStore,
+  WebhookEndpointStore,
+} from "@k-msg/webhook";
 
-  if (!security.verifyTimestamp(timestamp, 300)) {
-    return c.json({ error: "Request too old" }, 401);
+class SqliteEndpointStore implements WebhookEndpointStore {
+  async add() {}
+  async update() {}
+  async remove() {}
+  async get() {
+    return null;
   }
-  if (!security.verifySignatureWithTimestamp(payload, timestamp, signature, secret)) {
-    return c.json({ error: "Invalid signature" }, 401);
+  async list() {
+    return [];
   }
+}
 
-  const event = JSON.parse(payload);
-  return c.json({ ok: true, type: event.type });
-});
+class SqliteDeliveryStore implements WebhookDeliveryStore {
+  async add() {}
+  async list() {
+    return [];
+  }
+}
 ```
 
-## Retries and Delivery Status
-
-`WebhookDispatcher` retries failed deliveries with exponential backoff.
-
-Delivery status:
-- `success`: received a 2xx response
-- `failed`: non-retryable failure (typically non-retryable 4xx)
-- `exhausted`: retryable failure, but retries were used up
-
-## Filtering
-
-Endpoints can filter deliveries based on event metadata:
+Then wire it without changing runtime logic:
 
 ```ts
-await service.registerEndpoint({
-  url: "https://example.com/webhooks/k-msg",
-  active: true,
-  events: [WebhookEventType.MESSAGE_SENT],
-  filters: {
-    providerId: ["iwinv"],
-    channelId: ["marketing"],
-    templateId: ["welcome-template"],
-  },
+const runtime = new WebhookRuntimeService({
+  delivery: config,
+  endpointStore: new SqliteEndpointStore(),
+  deliveryStore: new SqliteDeliveryStore(),
 });
 ```
 
-## File Storage Adapter (for `type: "file"`)
+## Security defaults
 
-`EndpointManager`, `EventStore`, `DeliveryStore`, and `QueueManager` no longer import Node `fs/path` directly.
-When using file persistence, provide `fileAdapter`.
+- Private hosts are blocked by default
+- `http://localhost` style URLs require explicit allowance (runtime security options)
 
-```ts
-import { DeliveryStore, type FileStorageAdapter } from "@k-msg/webhook";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-
-const nodeFileAdapter: FileStorageAdapter = {
-  appendFile: (filePath, data) => fs.appendFile(filePath, data, "utf8"),
-  readFile: (filePath) => fs.readFile(filePath, "utf8"),
-  writeFile: (filePath, data) => fs.writeFile(filePath, data, "utf8"),
-  ensureDirForFile: (filePath) =>
-    fs.mkdir(path.dirname(filePath), { recursive: true }),
-};
+## Migration notes (breaking)
 
-const store = new DeliveryStore({
-  type: "file",
-  filePath: "./data/deliveries.log",
-  fileAdapter: nodeFileAdapter,
-});
-```
+| Old usage | New usage |
+| --- | --- |
+| `WebhookService` (root) | `WebhookRuntimeService` (root) |
+| `registerEndpoint()` auto test call | `addEndpoint()` only; test with `probeEndpoint()` |
+| Advanced classes from root | import from `@k-msg/webhook/toolkit` |
+| Cloudflare persistence from custom wiring | use `@k-msg/webhook/adapters/cloudflare` |
 
-## Zod Schemas
+## Toolkit subpath
 
-This package exports Zod schemas for validation:
-- `WebhookEventSchema` (timestamp is coerced from string/number to `Date`)
-- `WebhookEndpointSchema`
-- `WebhookDeliverySchema`
+```ts
+import { LoadBalancer, QueueManager } from "@k-msg/webhook/toolkit";
+```
 
 ## License
 

package/README_ko.md

@@ -2,17 +2,13 @@
 
 > 공식 문서: [k-msg.and.guide](https://k-msg.and.guide)
 
-HTTP 엔드포인트로 실시간 메시지 이벤트를 전달하기 위한 웹훅(Webhook) 전송 도구입니다.
+메시지 이벤트 웹훅 전송을 위한 runtime 중심 패키지입니다.
 
-이 패키지는 아래 기능을 제공합니다.
-- `WebhookService`: 편의용 Facade (in-memory 엔드포인트 레지스트리 + 배치 처리)
-- `WebhookDispatcher`: HTTP 전송 + 재시도(백오프)
-- `SecurityManager`: HMAC 서명 생성/검증
-- Zod 스키마: `WebhookEventSchema`, `WebhookEndpointSchema`, `WebhookDeliverySchema`
+이번 구조는 DX 기준으로 다음 3단계에 맞춰 설계되었습니다.
 
-참고:
-- 기본 `WebhookService` 저장소는 in-memory입니다. 영속 저장/고급 워크플로우가 필요하면 `EndpointManager`, `DeliveryStore` 같은 빌딩 블록을 활용하세요.
-- 이 패키지는 런타임 중립(Edge/Web/Node)으로 동작하며, 기본적으로 Node 내장 모듈에 의존하지 않습니다.
+1. in-memory로 5분 내 시작
+2. 서비스 코드 변경 없이 D1으로 전환
+3. SQLite/Drizzle(Postgres) 확장
 
 ## 설치
 
@@ -22,50 +18,56 @@ npm install @k-msg/webhook
 bun add @k-msg/webhook
 ```
 
-## 빠른 시작 (WebhookService)
+## Runtime API (루트)
+
+`@k-msg/webhook` 루트는 runtime API만 제공합니다.
+
+- `WebhookRuntimeService`
+- `createInMemoryWebhookPersistence`
+- `addEndpoints`, `probeEndpoint`
+- `validateEndpointUrl`
+
+고급 빌딩 블록은 subpath로 분리되었습니다.
+
+- `@k-msg/webhook/toolkit`
+- `@k-msg/webhook/adapters/cloudflare`
+
+## 빠른 시작 (in-memory)
 
 ```ts
-import { readRuntimeEnv } from "@k-msg/core";
 import {
   WebhookEventType,
-  WebhookService,
+  WebhookRuntimeService,
+  createInMemoryWebhookPersistence,
   type WebhookConfig,
 } from "@k-msg/webhook";
 
 const config: WebhookConfig = {
   maxRetries: 3,
-  retryDelayMs: 1000,
-  // Optional: maxDelayMs, backoffMultiplier, jitter
+  retryDelayMs: 1_000,
   timeoutMs: 30_000,
-  enableSecurity: true,
-  // Optional: 엔드포인트에 secret이 없을 때 fallback으로 사용됩니다.
-  secretKey: readRuntimeEnv("WEBHOOK_SECRET"),
-  // Optional: algorithm, signatureHeader, signaturePrefix
+  enableSecurity: false,
   enabledEvents: [
     WebhookEventType.MESSAGE_SENT,
-    WebhookEventType.MESSAGE_DELIVERED,
     WebhookEventType.MESSAGE_FAILED,
+    WebhookEventType.SYSTEM_MAINTENANCE,
   ],
   batchSize: 10,
   batchTimeoutMs: 5_000,
 };
 
-const service = new WebhookService(config);
+const runtime = new WebhookRuntimeService({
+  delivery: config,
+  persistence: createInMemoryWebhookPersistence(),
+});
 
-const endpoint = await service.registerEndpoint({
+await runtime.addEndpoint({
   url: "https://example.com/webhooks/k-msg",
   active: true,
   events: [WebhookEventType.MESSAGE_SENT, WebhookEventType.MESSAGE_FAILED],
-  // Optional: 엔드포인트별 secret (config.secretKey보다 우선)
-  secret: readRuntimeEnv("WEBHOOK_SECRET"),
-  // Optional: 엔드포인트별 재시도 설정
-  retryConfig: { maxRetries: 5, retryDelayMs: 1000, backoffMultiplier: 2 },
-  // Optional: 메타데이터 기반 필터
-  filters: { providerId: ["iwinv", "solapi"] },
 });
 
-// 비동기 emit (배치 처리됨)
-await service.emit({
+await runtime.emitSync({
   id: crypto.randomUUID(),
   type: WebhookEventType.MESSAGE_SENT,
   timestamp: new Date(),
@@ -74,131 +76,119 @@ await service.emit({
   version: "1.0",
 });
 
-// 동기 emit (딜리버리 결과를 반환)
-const deliveries = await service.emitSync({
-  id: crypto.randomUUID(),
-  type: WebhookEventType.MESSAGE_FAILED,
-  timestamp: new Date(),
-  data: { messageId: "msg_456", status: "failed" },
-  metadata: { providerId: "solapi", messageId: "msg_456" },
-  version: "1.0",
-});
-
-// 최근 딜리버리 조회(in-memory)
-const recent = await service.getDeliveries(endpoint.id);
-console.log(deliveries.length, recent.length);
-
-await service.shutdown();
+await runtime.shutdown();
 ```
 
-### 엔드포인트 등록 동작
+## D1 전환 (동일 API)
 
-`registerEndpoint()`는 URL 유효성 검증 후, `testEndpoint()`를 통해 테스트 웹훅(`system.maintenance`)을 1회 전송합니다.
-
-## 보안 (HMAC 서명)
+```ts
+import {
+  WebhookEventType,
+  WebhookRuntimeService,
+  type WebhookConfig,
+} from "@k-msg/webhook";
+import { createD1WebhookPersistence } from "@k-msg/webhook/adapters/cloudflare";
 
-보안이 활성화되어 있고 secret이 존재하면(`endpoint.secret` 또는 `config.secretKey`), 아래 헤더가 포함됩니다.
-- `X-Webhook-Timestamp`: unix epoch seconds (string)
-- `X-Webhook-Signature`: HMAC 서명 (기본: `sha256=<hex>`)
+type Env = {
+  DB: D1Database;
+};
 
-서명 입력 문자열은 아래 형식입니다.
+const config: WebhookConfig = {
+  maxRetries: 3,
+  retryDelayMs: 1_000,
+  timeoutMs: 30_000,
+  enableSecurity: false,
+  enabledEvents: [WebhookEventType.MESSAGE_SENT, WebhookEventType.MESSAGE_FAILED],
+  batchSize: 10,
+  batchTimeoutMs: 5_000,
+};
 
-```
-${timestamp}.${rawBody}
+function createRuntime(env: Env): WebhookRuntimeService {
+  return new WebhookRuntimeService({
+    delivery: config,
+    persistence: createD1WebhookPersistence(env.DB),
+    security: {
+      allowPrivateHosts: true,
+    },
+  });
+}
 ```
 
-수신 측에서는 반드시 "raw body 문자열" 그대로 검증해야 합니다.
+`createD1WebhookPersistence()`는 기본값으로 스키마 초기화를 자동 수행합니다.
 
-### Hono 예시
+## Cloudflare 스키마 헬퍼
 
 ```ts
-import { Hono } from "hono";
-import { readRuntimeEnv } from "@k-msg/core";
-import { SecurityManager } from "@k-msg/webhook";
-
-const app = new Hono();
-const security = new SecurityManager({
-  algorithm: "sha256",
-  signatureHeader: "X-Webhook-Signature",
-  signaturePrefix: "sha256=",
-});
+import {
+  buildWebhookSchemaSql,
+  initializeWebhookSchema,
+} from "@k-msg/webhook/adapters/cloudflare";
+
+const statements = buildWebhookSchemaSql();
+// 마이그레이션 시스템에서 실행하거나:
+await initializeWebhookSchema(env.DB);
+```
 
-app.post("/webhooks/k-msg", async (c) => {
-  const payload = await c.req.text();
+## SQLite / Drizzle(Postgres) 스니펫
 
-  const signature = c.req.header("X-Webhook-Signature") ?? "";
-  const timestamp = c.req.header("X-Webhook-Timestamp") ?? "";
-  const secret = readRuntimeEnv("WEBHOOK_SECRET") ?? "";
+`WebhookRuntimeService`는 `endpointStore` + `deliveryStore` 주입을 지원합니다.
+동일 인터페이스만 구현하면 백엔드를 교체할 수 있습니다.
 
-  if (!security.verifyTimestamp(timestamp, 300)) {
-    return c.json({ error: "Request too old" }, 401);
+```ts
+import type {
+  WebhookDeliveryStore,
+  WebhookEndpointStore,
+} from "@k-msg/webhook";
+
+class SqliteEndpointStore implements WebhookEndpointStore {
+  async add() {}
+  async update() {}
+  async remove() {}
+  async get() {
+    return null;
   }
-  if (!security.verifySignatureWithTimestamp(payload, timestamp, signature, secret)) {
-    return c.json({ error: "Invalid signature" }, 401);
+  async list() {
+    return [];
   }
+}
 
-  const event = JSON.parse(payload);
-  return c.json({ ok: true, type: event.type });
-});
+class SqliteDeliveryStore implements WebhookDeliveryStore {
+  async add() {}
+  async list() {
+    return [];
+  }
+}
 ```
 
-## 재시도 및 상태
-
-`WebhookDispatcher`는 실패한 전송을 지수 백오프로 재시도합니다.
-
-딜리버리 상태:
-- `success`: 2xx 응답을 받음
-- `failed`: 재시도 대상이 아닌 실패(주로 non-retryable 4xx)
-- `exhausted`: 재시도 가능한 실패였지만, 재시도 횟수 소진
-
-## 필터링
-
-엔드포인트는 이벤트 메타데이터 기반으로 전달을 필터링할 수 있습니다.
+런타임 연결 코드는 동일합니다.
 
 ```ts
-await service.registerEndpoint({
-  url: "https://example.com/webhooks/k-msg",
-  active: true,
-  events: [WebhookEventType.MESSAGE_SENT],
-  filters: {
-    providerId: ["iwinv"],
-    channelId: ["marketing"],
-    templateId: ["welcome-template"],
-  },
+const runtime = new WebhookRuntimeService({
+  delivery: config,
+  endpointStore: new SqliteEndpointStore(),
+  deliveryStore: new SqliteDeliveryStore(),
 });
 ```
 
-## File Storage Adapter (`type: "file"` 사용 시)
+## 보안 기본값
 
-`EndpointManager`, `EventStore`, `DeliveryStore`, `QueueManager`는 Node `fs/path`를 직접 import하지 않습니다.
-파일 영속화를 사용하려면 `fileAdapter`를 주입해야 합니다.
+- 기본적으로 private host 차단
+- `http://localhost` 류 URL은 옵션으로 명시 허용해야 사용 가능
 
-```ts
-import { DeliveryStore, type FileStorageAdapter } from "@k-msg/webhook";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-
-const nodeFileAdapter: FileStorageAdapter = {
-  appendFile: (filePath, data) => fs.appendFile(filePath, data, "utf8"),
-  readFile: (filePath) => fs.readFile(filePath, "utf8"),
-  writeFile: (filePath, data) => fs.writeFile(filePath, data, "utf8"),
-  ensureDirForFile: (filePath) =>
-    fs.mkdir(path.dirname(filePath), { recursive: true }),
-};
+## 마이그레이션 (브레이킹)
 
-const store = new DeliveryStore({
-  type: "file",
-  filePath: "./data/deliveries.log",
-  fileAdapter: nodeFileAdapter,
-});
-```
+| 기존 | 변경 |
+| --- | --- |
+| 루트 `WebhookService` | 루트 `WebhookRuntimeService` |
+| `registerEndpoint()` 시 자동 테스트 전송 | `addEndpoint()` + 필요 시 `probeEndpoint()` |
+| 고급 클래스 루트 import | `@k-msg/webhook/toolkit`에서 import |
+| Cloudflare persistence 수동 구성 | `@k-msg/webhook/adapters/cloudflare` 사용 |
 
-## Zod 스키마
+## Toolkit subpath
 
-이 패키지는 검증용 Zod 스키마를 export 합니다.
-- `WebhookEventSchema` (timestamp는 string/number 입력을 `Date`로 coerce)
-- `WebhookEndpointSchema`
-- `WebhookDeliverySchema`
+```ts
+import { LoadBalancer, QueueManager } from "@k-msg/webhook/toolkit";
+```
 
 ## License
 

package/dist/adapters/cloudflare/d1-client.d.ts

@@ -0,0 +1,21 @@
+export type D1Row = Record<string, unknown>;
+export interface D1PreparedStatementLike {
+    bind(...values: unknown[]): D1PreparedStatementLike;
+    first<T extends D1Row = D1Row>(): Promise<T | null>;
+    all<T extends D1Row = D1Row>(): Promise<{
+        results: T[];
+    }>;
+    run(): Promise<unknown>;
+}
+export interface D1DatabaseLike {
+    prepare(query: string): D1PreparedStatementLike;
+    exec?(query: string): Promise<unknown>;
+}
+export declare function toDate(value: unknown): Date | undefined;
+export declare function toNumber(value: unknown, fallback?: number): number;
+export declare function toStringValue(value: unknown, fallback?: string): string;
+export declare function safeJsonParse<T>(value: unknown): T | undefined;
+export declare function queryAll<T extends D1Row = D1Row>(db: D1DatabaseLike, sql: string, params?: readonly unknown[]): Promise<T[]>;
+export declare function queryFirst<T extends D1Row = D1Row>(db: D1DatabaseLike, sql: string, params?: readonly unknown[]): Promise<T | null>;
+export declare function runStatement(db: D1DatabaseLike, sql: string, params?: readonly unknown[]): Promise<void>;
+export declare function runStatements(db: D1DatabaseLike, sqlStatements: readonly string[]): Promise<void>;

package/dist/adapters/cloudflare/d1-delivery.store.d.ts

@@ -0,0 +1,12 @@
+import type { WebhookDeliveryListOptions, WebhookDeliveryStore } from "../../runtime/types";
+import { type WebhookDelivery } from "../../types/webhook.types";
+import { type D1DatabaseLike } from "./d1-client";
+export declare class D1WebhookDeliveryStore implements WebhookDeliveryStore {
+    private readonly db;
+    private readonly tableName;
+    private readonly ensureInitialized;
+    constructor(db: D1DatabaseLike, tableName: string, ensureInitialized: () => Promise<void>);
+    add(delivery: WebhookDelivery): Promise<void>;
+    list(options?: WebhookDeliveryListOptions): Promise<WebhookDelivery[]>;
+    private toDelivery;
+}