create-svc 0.1.53 → 0.1.54

package/templates/variants/bun-hono/src/db/repository.ts

@@ -1,7 +1,7 @@
-import { desc, eq } from "drizzle-orm";
+import { and, desc, eq } from "drizzle-orm";
 import type { createDb } from "./client";
-import { waitlistEntries, waitlistTriggers } from "./schema";
-import type { WaitlistEntry, WaitlistTrigger } from "../waitlist/types";
+import { waitlistEntries, waitlistTriggers, webhookEvents } from "./schema";
+import type { WaitlistEntry, WaitlistTrigger, WebhookEvent } from "../waitlist/types";
 
 type Database = ReturnType<typeof createDb>;
 type WaitlistEntryRow = typeof waitlistEntries.$inferSelect;
@@ -21,6 +21,14 @@ type CreateTriggerRecord = {
   payload: unknown;
 };
 
+type CreateWebhookEventRecord = {
+  id: string;
+  provider: string;
+  externalEventId: string;
+  payload: unknown;
+  headers: Record<string, string>;
+};
+
 export class WaitlistRepository {
   constructor(private readonly db: Database) {}
 
@@ -91,6 +99,36 @@ export class WaitlistRepository {
       .returning();
     return toWaitlistTrigger(row);
   }
+
+  async recordWebhookEvent(input: CreateWebhookEventRecord): Promise<{ event: WebhookEvent; duplicate: boolean }> {
+    const [inserted] = await this.db
+      .insert(webhookEvents)
+      .values({
+        id: input.id,
+        provider: input.provider,
+        externalEventId: input.externalEventId,
+        payloadJson: JSON.stringify(input.payload ?? {}),
+        headersJson: JSON.stringify(input.headers),
+        receivedAt: new Date(),
+      })
+      .onConflictDoNothing({
+        target: [webhookEvents.provider, webhookEvents.externalEventId],
+      })
+      .returning();
+    if (inserted) {
+      return { event: toWebhookEvent(inserted), duplicate: false };
+    }
+
+    const [row] = await this.db
+      .select()
+      .from(webhookEvents)
+      .where(and(eq(webhookEvents.provider, input.provider), eq(webhookEvents.externalEventId, input.externalEventId)))
+      .limit(1);
+    if (!row) {
+      throw new Error("webhook event was not inserted and could not be read");
+    }
+    return { event: toWebhookEvent(row), duplicate: true };
+  }
 }
 
 function clampLimit(value: number | null | undefined) {
@@ -124,3 +162,14 @@ function toWaitlistTrigger(row: typeof waitlistTriggers.$inferSelect): WaitlistT
     processedAt: row.processedAt?.toISOString() ?? null,
   };
 }
+
+function toWebhookEvent(row: typeof webhookEvents.$inferSelect): WebhookEvent {
+  return {
+    id: row.id,
+    provider: row.provider,
+    externalEventId: row.externalEventId,
+    payload: JSON.parse(row.payloadJson),
+    headers: JSON.parse(row.headersJson),
+    receivedAt: row.receivedAt.toISOString(),
+  };
+}

package/templates/variants/bun-hono/src/db/schema.ts

@@ -24,3 +24,16 @@ export const waitlistTriggers = pgTable("waitlist_triggers", {
   createdAt: timestamp("created_at", { withTimezone: true, mode: "date" }).notNull().defaultNow(),
   processedAt: timestamp("processed_at", { withTimezone: true, mode: "date" }),
 });
+
+export const webhookEvents = pgTable(
+  "webhook_events",
+  {
+    id: text("id").primaryKey(),
+    provider: text("provider").notNull(),
+    externalEventId: text("external_event_id").notNull(),
+    payloadJson: text("payload_json").notNull(),
+    headersJson: text("headers_json").notNull(),
+    receivedAt: timestamp("received_at", { withTimezone: true, mode: "date" }).notNull().defaultNow(),
+  },
+  (table) => [uniqueIndex("webhook_events_provider_external_event_id_key").on(table.provider, table.externalEventId)]
+);

package/templates/variants/bun-hono/src/index.ts

@@ -110,15 +110,26 @@ export function createApp(service: WaitlistService) {
   app.post("/webhooks/:provider", async (context) => {
     try {
       const rawBody = await context.req.text();
-      const trigger = await service.recordTrigger({
-        type: `webhook.${context.req.param("provider")}`,
-        entryId: null,
-        payload: {
-          headers: Object.fromEntries(context.req.raw.headers),
-          rawBody,
-        },
+      const provider = context.req.param("provider");
+      const headers = Object.fromEntries(context.req.raw.headers);
+      const payload = parseWebhookPayload(rawBody);
+      const result = await service.recordWebhookEvent({
+        provider,
+        externalEventId: webhookEventId(payload, context.req.raw.headers),
+        payload,
+        headers,
       });
-      return context.json({ trigger }, 202);
+      if (!result.duplicate) {
+        await service.recordTrigger({
+          type: `webhook.${provider}`,
+          entryId: null,
+          payload: {
+            headers,
+            rawBody,
+          },
+        });
+      }
+      return context.json(result, result.duplicate ? 200 : 202);
     } catch (error) {
       return writeError(context, error);
     }
@@ -142,6 +153,21 @@ function parseOptionalNumber(value: string | undefined) {
   return value ? Number(value) : null;
 }
 
+function parseWebhookPayload(rawBody: string) {
+  try {
+    return rawBody ? JSON.parse(rawBody) : {};
+  } catch {
+    return { rawBody };
+  }
+}
+
+function webhookEventId(payload: unknown, headers: Headers) {
+  if (payload && typeof payload === "object" && "id" in payload && typeof payload.id === "string") {
+    return payload.id;
+  }
+  return headers.get("x-webhook-event-id") ?? crypto.randomUUID();
+}
+
 if (import.meta.main) {
   const temporalWorker = await startTemporalWorker();
   if (temporalWorker) {

package/templates/variants/bun-hono/src/waitlist/service.ts

@@ -3,8 +3,10 @@ import { WaitlistRepository } from "../db/repository";
 import type {
   JoinWaitlistInput,
   ListWaitlistEntriesInput,
+  RecordWebhookEventInput,
   RecordTriggerInput,
   UpdateWaitlistEntryInput,
+  WebhookEvent,
   WaitlistEntry,
   WaitlistEntryStatus,
 } from "./types";
@@ -27,6 +29,7 @@ export type WaitlistService = {
   updateWaitlistEntry(input: UpdateWaitlistEntryInput): Promise<WaitlistEntry>;
   exportWaitlistEntries(input?: ListWaitlistEntriesInput): Promise<string>;
   recordTrigger(input: RecordTriggerInput): Promise<unknown>;
+  recordWebhookEvent(input: RecordWebhookEventInput): Promise<{ event: WebhookEvent; duplicate: boolean }>;
 };
 
 export class DefaultWaitlistService implements WaitlistService {
@@ -113,6 +116,25 @@ export class DefaultWaitlistService implements WaitlistService {
       payload: input.payload ?? {},
     });
   }
+
+  async recordWebhookEvent(input: RecordWebhookEventInput) {
+    const provider = input.provider.trim();
+    const externalEventId = input.externalEventId.trim();
+    if (!provider) {
+      throw new AppError(400, "invalid_webhook_provider", "webhook provider is required");
+    }
+    if (!externalEventId) {
+      throw new AppError(400, "invalid_webhook_event_id", "webhook event id is required");
+    }
+
+    return this.repository.recordWebhookEvent({
+      id: crypto.randomUUID(),
+      provider,
+      externalEventId,
+      payload: input.payload ?? {},
+      headers: input.headers,
+    });
+  }
 }
 
 export function createDefaultWaitlistService() {

package/templates/variants/bun-hono/src/waitlist/types.ts

@@ -19,6 +19,15 @@ export type WaitlistTrigger = {
   processedAt: string | null;
 };
 
+export type WebhookEvent = {
+  id: string;
+  provider: string;
+  externalEventId: string;
+  payload: unknown;
+  headers: Record<string, string>;
+  receivedAt: string;
+};
+
 export type JoinWaitlistInput = {
   email: string;
   name?: string | null;
@@ -48,3 +57,10 @@ export type RecordTriggerInput = {
   entryId?: string | null;
   payload?: unknown;
 };
+
+export type RecordWebhookEventInput = {
+  provider: string;
+  externalEventId: string;
+  payload: unknown;
+  headers: Record<string, string>;
+};

package/templates/variants/bun-hono/test/app.test.ts

@@ -93,5 +93,18 @@ function createMockService(): WaitlistService {
         processedAt: null,
       };
     },
+    async recordWebhookEvent() {
+      return {
+        duplicate: false,
+        event: {
+          id: "webhook_1",
+          provider: "generic",
+          externalEventId: "evt_1",
+          payload: {},
+          headers: {},
+          receivedAt: "2026-01-01T00:00:00.000Z",
+        },
+      };
+    },
   };
 }

package/templates/variants/go-chi/Makefile

@@ -1,4 +1,4 @@
-.PHONY: dev migrate migrate-lint gen lint test create deploy dashboards auth destroy
+.PHONY: dev migrate migrate-lint gen lint test create deploy dashboards observability-bootstrap auth destroy
 
 SERVICE := service
 WITH_ENV := set -a; [ ! -f .env.local ] || . ./.env.local; set +a;
@@ -38,6 +38,9 @@ deploy:
 dashboards:
 	$(SERVICE) dashboards
 
+observability-bootstrap:
+	$(SERVICE) observability-bootstrap
+
 auth:
 	$(SERVICE) auth $(ARGS)
 

package/templates/variants/go-chi/internal/app/service.go

@@ -36,6 +36,15 @@ type WaitlistTrigger struct {
 	ProcessedAt string `json:"processed_at,omitempty" db:"processed_at"`
 }
 
+type WebhookEvent struct {
+	ID              string         `json:"id" db:"id"`
+	Provider        string         `json:"provider" db:"provider"`
+	ExternalEventID string         `json:"external_event_id" db:"external_event_id"`
+	Payload         map[string]any `json:"payload"`
+	Headers         map[string]any `json:"headers"`
+	ReceivedAt      string         `json:"received_at" db:"received_at"`
+}
+
 type JoinWaitlistInput struct {
 	Email   string `json:"email"`
 	Name    string `json:"name"`
@@ -54,6 +63,18 @@ type RecordTriggerInput struct {
 	Payload any    `json:"payload"`
 }
 
+type RecordWebhookEventInput struct {
+	Provider        string         `json:"provider"`
+	ExternalEventID string         `json:"external_event_id"`
+	Payload         map[string]any `json:"payload"`
+	Headers         map[string]any `json:"headers"`
+}
+
+type RecordWebhookEventResult struct {
+	Event     WebhookEvent `json:"event"`
+	Duplicate bool         `json:"duplicate"`
+}
+
 type ListWaitlistEntriesInput struct {
 	Status string `json:"status"`
 	Limit  int    `json:"limit"`
@@ -252,6 +273,53 @@ returning id, type, coalesce(entry_id, '') as entry_id, status, payload_json, cr
 	return row.toTrigger()
 }
 
+func (s *WaitlistService) RecordWebhookEvent(ctx context.Context, input RecordWebhookEventInput) (RecordWebhookEventResult, error) {
+	provider := strings.TrimSpace(input.Provider)
+	if provider == "" {
+		return RecordWebhookEventResult{}, &AppError{Status: 400, Code: "invalid_webhook_provider", Err: errors.New("webhook provider is required")}
+	}
+	externalEventID := strings.TrimSpace(input.ExternalEventID)
+	if externalEventID == "" {
+		return RecordWebhookEventResult{}, &AppError{Status: 400, Code: "invalid_webhook_event_id", Err: errors.New("webhook event id is required")}
+	}
+
+	payloadBytes, err := json.Marshal(input.Payload)
+	if err != nil {
+		return RecordWebhookEventResult{}, err
+	}
+	headersBytes, err := json.Marshal(input.Headers)
+	if err != nil {
+		return RecordWebhookEventResult{}, err
+	}
+
+	id := fmt.Sprintf("wh_%d", time.Now().UnixNano())
+	var row webhookEventRow
+	err = s.db.GetContext(ctx, &row, `
+insert into webhook_events (id, provider, external_event_id, payload_json, headers_json)
+values ($1, $2, $3, $4, $5)
+on conflict (provider, external_event_id) do nothing
+returning id, provider, external_event_id, payload_json, headers_json, received_at::text
+`, id, provider, externalEventID, string(payloadBytes), string(headersBytes))
+	if err == nil {
+		event, err := row.toWebhookEvent()
+		return RecordWebhookEventResult{Event: event, Duplicate: false}, err
+	}
+	if !errors.Is(err, sql.ErrNoRows) {
+		return RecordWebhookEventResult{}, err
+	}
+
+	err = s.db.GetContext(ctx, &row, `
+select id, provider, external_event_id, payload_json, headers_json, received_at::text
+from webhook_events
+where provider = $1 and external_event_id = $2
+`, provider, externalEventID)
+	if err != nil {
+		return RecordWebhookEventResult{}, err
+	}
+	event, err := row.toWebhookEvent()
+	return RecordWebhookEventResult{Event: event, Duplicate: true}, err
+}
+
 type waitlistTriggerRow struct {
 	ID          string `db:"id"`
 	Type        string `db:"type"`
@@ -262,6 +330,34 @@ type waitlistTriggerRow struct {
 	ProcessedAt string `db:"processed_at"`
 }
 
+type webhookEventRow struct {
+	ID              string `db:"id"`
+	Provider        string `db:"provider"`
+	ExternalEventID string `db:"external_event_id"`
+	PayloadJSON     string `db:"payload_json"`
+	HeadersJSON     string `db:"headers_json"`
+	ReceivedAt      string `db:"received_at"`
+}
+
+func (r webhookEventRow) toWebhookEvent() (WebhookEvent, error) {
+	var payload map[string]any
+	if err := json.Unmarshal([]byte(r.PayloadJSON), &payload); err != nil {
+		return WebhookEvent{}, err
+	}
+	var headers map[string]any
+	if err := json.Unmarshal([]byte(r.HeadersJSON), &headers); err != nil {
+		return WebhookEvent{}, err
+	}
+	return WebhookEvent{
+		ID:              r.ID,
+		Provider:        r.Provider,
+		ExternalEventID: r.ExternalEventID,
+		Payload:         payload,
+		Headers:         headers,
+		ReceivedAt:      r.ReceivedAt,
+	}, nil
+}
+
 func (r waitlistTriggerRow) toTrigger() (WaitlistTrigger, error) {
 	var payload any
 	if err := json.Unmarshal([]byte(r.PayloadJSON), &payload); err != nil {

package/templates/variants/go-chi/internal/httpapi/routes.go

@@ -3,10 +3,12 @@ package httpapi
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
 	"net/http"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/go-chi/chi/v5"
 
@@ -130,18 +132,35 @@ func RegisterRoutes(router chi.Router, service *app.WaitlistService) {
 			writeError(w, err)
 			return
 		}
-		trigger, err := service.RecordTrigger(request.Context(), app.RecordTriggerInput{
-			Type: "webhook." + chi.URLParam(request, "provider"),
-			Payload: map[string]any{
-				"headers": request.Header,
-				"rawBody": string(rawBody),
-			},
+		provider := chi.URLParam(request, "provider")
+		payload := parseWebhookPayload(rawBody)
+		result, err := service.RecordWebhookEvent(request.Context(), app.RecordWebhookEventInput{
+			Provider:        provider,
+			ExternalEventID: webhookEventID(payload, request.Header),
+			Payload:         payload,
+			Headers:         headersPayload(request.Header),
 		})
 		if err != nil {
 			writeError(w, err)
 			return
 		}
-		writeJSON(w, http.StatusAccepted, map[string]any{"trigger": trigger})
+		if !result.Duplicate {
+			if _, err := service.RecordTrigger(request.Context(), app.RecordTriggerInput{
+				Type: "webhook." + provider,
+				Payload: map[string]any{
+					"headers": headersPayload(request.Header),
+					"rawBody": string(rawBody),
+				},
+			}); err != nil {
+				writeError(w, err)
+				return
+			}
+		}
+		if result.Duplicate {
+			writeJSON(w, http.StatusOK, result)
+			return
+		}
+		writeJSON(w, http.StatusAccepted, result)
 	})
 
 	router.Get("/webhooks/{provider}/health", func(w http.ResponseWriter, request *http.Request) {
@@ -157,6 +176,36 @@ func decodeJSON(request *http.Request, out any) error {
 	return json.NewDecoder(request.Body).Decode(out)
 }
 
+func parseWebhookPayload(rawBody []byte) map[string]any {
+	var payload map[string]any
+	if len(rawBody) == 0 || json.Unmarshal(rawBody, &payload) != nil {
+		return map[string]any{"rawBody": string(rawBody)}
+	}
+	return payload
+}
+
+func webhookEventID(payload map[string]any, headers http.Header) string {
+	if id, ok := payload["id"].(string); ok && id != "" {
+		return id
+	}
+	if id := headers.Get("X-Webhook-Event-Id"); id != "" {
+		return id
+	}
+	return fmt.Sprintf("evt_%d", time.Now().UnixNano())
+}
+
+func headersPayload(headers http.Header) map[string]any {
+	out := make(map[string]any, len(headers))
+	for key, values := range headers {
+		if len(values) == 1 {
+			out[key] = values[0]
+			continue
+		}
+		out[key] = values
+	}
+	return out
+}
+
 func decodeOptionalJSON(request *http.Request, out any) error {
 	defer request.Body.Close()
 	decoder := json.NewDecoder(request.Body)

package/templates/variants/go-chi/migrations/0000_init.sql

@@ -18,3 +18,13 @@ create table if not exists waitlist_triggers (
   created_at timestamptz not null default now(),
   processed_at timestamptz
 );
+
+create table if not exists webhook_events (
+  id text primary key,
+  provider text not null,
+  external_event_id text not null,
+  payload_json text not null,
+  headers_json text not null,
+  received_at timestamptz not null default now(),
+  unique (provider, external_event_id)
+);

package/templates/variants/go-chi/migrations/atlas.sum

@@ -1,2 +1,2 @@
-h1:D9GgvtEf0xxnRDaTb/C3cPtRbncVXsK6Ef0KYQuLMRw=
-0000_init.sql h1:dBpLGyoeZNRpjT6RvQXiqx3p2ICAChKy2jVqCIYuWQg=
+h1:AhMVwNnmHR10XivPa/5MXyIZrG7LPmekS6SpgjTGJyA=
+0000_init.sql h1:9Sm7GI+kmYAsnRTFdZkIZl0bsQN5EUlN/AopryCCRgs=

package/templates/variants/go-connectrpc/Makefile

@@ -1,4 +1,4 @@
-.PHONY: dev migrate migrate-lint gen lint test create deploy dashboards auth destroy
+.PHONY: dev migrate migrate-lint gen lint test create deploy dashboards observability-bootstrap auth destroy
 
 SERVICE := service
 WITH_ENV := set -a; [ ! -f .env.local ] || . ./.env.local; set +a;
@@ -39,6 +39,9 @@ deploy:
 dashboards:
 	$(SERVICE) dashboards
 
+observability-bootstrap:
+	$(SERVICE) observability-bootstrap
+
 auth:
 	$(SERVICE) auth $(ARGS)
 

package/templates/variants/go-connectrpc/internal/app/service.go

@@ -36,6 +36,15 @@ type WaitlistTrigger struct {
 	ProcessedAt string `json:"processed_at,omitempty" db:"processed_at"`
 }
 
+type WebhookEvent struct {
+	ID              string         `json:"id" db:"id"`
+	Provider        string         `json:"provider" db:"provider"`
+	ExternalEventID string         `json:"external_event_id" db:"external_event_id"`
+	Payload         map[string]any `json:"payload"`
+	Headers         map[string]any `json:"headers"`
+	ReceivedAt      string         `json:"received_at" db:"received_at"`
+}
+
 type JoinWaitlistInput struct {
 	Email   string `json:"email"`
 	Name    string `json:"name"`
@@ -54,6 +63,18 @@ type RecordTriggerInput struct {
 	Payload any    `json:"payload"`
 }
 
+type RecordWebhookEventInput struct {
+	Provider        string         `json:"provider"`
+	ExternalEventID string         `json:"external_event_id"`
+	Payload         map[string]any `json:"payload"`
+	Headers         map[string]any `json:"headers"`
+}
+
+type RecordWebhookEventResult struct {
+	Event     WebhookEvent `json:"event"`
+	Duplicate bool         `json:"duplicate"`
+}
+
 type ListWaitlistEntriesInput struct {
 	Status string `json:"status"`
 	Limit  int    `json:"limit"`
@@ -252,6 +273,53 @@ returning id, type, coalesce(entry_id, '') as entry_id, status, payload_json, cr
 	return row.toTrigger()
 }
 
+func (s *WaitlistService) RecordWebhookEvent(ctx context.Context, input RecordWebhookEventInput) (RecordWebhookEventResult, error) {
+	provider := strings.TrimSpace(input.Provider)
+	if provider == "" {
+		return RecordWebhookEventResult{}, &AppError{Status: 400, Code: "invalid_webhook_provider", Err: errors.New("webhook provider is required")}
+	}
+	externalEventID := strings.TrimSpace(input.ExternalEventID)
+	if externalEventID == "" {
+		return RecordWebhookEventResult{}, &AppError{Status: 400, Code: "invalid_webhook_event_id", Err: errors.New("webhook event id is required")}
+	}
+
+	payloadBytes, err := json.Marshal(input.Payload)
+	if err != nil {
+		return RecordWebhookEventResult{}, err
+	}
+	headersBytes, err := json.Marshal(input.Headers)
+	if err != nil {
+		return RecordWebhookEventResult{}, err
+	}
+
+	id := fmt.Sprintf("wh_%d", time.Now().UnixNano())
+	var row webhookEventRow
+	err = s.db.GetContext(ctx, &row, `
+insert into webhook_events (id, provider, external_event_id, payload_json, headers_json)
+values ($1, $2, $3, $4, $5)
+on conflict (provider, external_event_id) do nothing
+returning id, provider, external_event_id, payload_json, headers_json, received_at::text
+`, id, provider, externalEventID, string(payloadBytes), string(headersBytes))
+	if err == nil {
+		event, err := row.toWebhookEvent()
+		return RecordWebhookEventResult{Event: event, Duplicate: false}, err
+	}
+	if !errors.Is(err, sql.ErrNoRows) {
+		return RecordWebhookEventResult{}, err
+	}
+
+	err = s.db.GetContext(ctx, &row, `
+select id, provider, external_event_id, payload_json, headers_json, received_at::text
+from webhook_events
+where provider = $1 and external_event_id = $2
+`, provider, externalEventID)
+	if err != nil {
+		return RecordWebhookEventResult{}, err
+	}
+	event, err := row.toWebhookEvent()
+	return RecordWebhookEventResult{Event: event, Duplicate: true}, err
+}
+
 type waitlistTriggerRow struct {
 	ID          string `db:"id"`
 	Type        string `db:"type"`
@@ -262,6 +330,34 @@ type waitlistTriggerRow struct {
 	ProcessedAt string `db:"processed_at"`
 }
 
+type webhookEventRow struct {
+	ID              string `db:"id"`
+	Provider        string `db:"provider"`
+	ExternalEventID string `db:"external_event_id"`
+	PayloadJSON     string `db:"payload_json"`
+	HeadersJSON     string `db:"headers_json"`
+	ReceivedAt      string `db:"received_at"`
+}
+
+func (r webhookEventRow) toWebhookEvent() (WebhookEvent, error) {
+	var payload map[string]any
+	if err := json.Unmarshal([]byte(r.PayloadJSON), &payload); err != nil {
+		return WebhookEvent{}, err
+	}
+	var headers map[string]any
+	if err := json.Unmarshal([]byte(r.HeadersJSON), &headers); err != nil {
+		return WebhookEvent{}, err
+	}
+	return WebhookEvent{
+		ID:              r.ID,
+		Provider:        r.Provider,
+		ExternalEventID: r.ExternalEventID,
+		Payload:         payload,
+		Headers:         headers,
+		ReceivedAt:      r.ReceivedAt,
+	}, nil
+}
+
 func (r waitlistTriggerRow) toTrigger() (WaitlistTrigger, error) {
 	var payload any
 	if err := json.Unmarshal([]byte(r.PayloadJSON), &payload); err != nil {