create-svc 0.1.62 → 0.1.64

package/templates/targets/workers/.github/workflows/preview.yml

@@ -30,3 +30,6 @@ jobs:
       - run: service deploy --name {{SERVICE_ID}}-pr-${{ steps.pr.outputs.number }}
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          TRIGGER_PROJECT_REF: ${{ secrets.TRIGGER_PROJECT_REF }}
+          TRIGGER_ACCESS_TOKEN: ${{ secrets.TRIGGER_ACCESS_TOKEN }}
+          TRIGGER_SECRET_KEY: ${{ secrets.TRIGGER_SECRET_KEY }}

package/templates/targets/workers/README.md

@@ -8,6 +8,7 @@ This `{{PROFILE}}` profile targets `{{RUNTIME}} + {{FRAMEWORK}}` on Cloudflare W
 - a lightweight waitlist/launch API
 - the `service` CLI for create, deploy, doctor, dashboards, DNS, and destroy
 - a Hyperdrive binding for Neon-backed Postgres persistence
+- Trigger.dev task dispatch for background trigger execution
 - a production API origin at `https://{{API_HOSTNAME}}`
 
 ## Commands
@@ -17,6 +18,8 @@ wrangler dev
 bun run test
 bun run lint
 bun run migrate
+bun run trigger -- --help
+bun run trigger:dev
 service create
 service deploy
 bun run dashboards
@@ -48,6 +51,31 @@ binding and create the small waitlist/trigger schema on first use.
 - `POST /webhooks/:provider`
 - `GET /webhooks/:provider/health`
 
+## Trigger.dev
+
+Cloudflare Workers services use Trigger.dev for background work. The Worker is
+the API surface; it records trigger rows and dispatches the generated
+`{{SERVICE_ID}}-waitlist-follow-up` task.
+
+Required production configuration:
+
+```bash
+export TRIGGER_PROJECT_REF=<project ref>
+export TRIGGER_ACCESS_TOKEN=<personal access token>
+export TRIGGER_SECRET_KEY=<secret key>
+```
+
+`service create` and `service deploy` deploy the Trigger.dev task before the
+Worker deploy and fail clearly if these values are missing.
+GitHub Actions deploys require matching repository secrets:
+`TRIGGER_PROJECT_REF`, `TRIGGER_ACCESS_TOKEN`, and `TRIGGER_SECRET_KEY`.
+
+The Trigger.dev CLI is installed in this generated package as a dev dependency
+from the `trigger.dev` npm package.
+Use `bun run trigger -- <args>` for ad-hoc commands, `bun run trigger:dev` for
+local task development, and `bun run trigger:deploy` when you want to deploy
+tasks directly without running the full service deploy.
+
 ## Production
 
 ```bash

package/templates/targets/workers/package.json

@@ -13,12 +13,16 @@
     "deploy": "service deploy",
     "dashboards": "service dashboards",
     "auth": "service auth",
-    "destroy": "service destroy"
+    "destroy": "service destroy",
+    "trigger": "trigger",
+    "trigger:dev": "trigger dev",
+    "trigger:deploy": "trigger deploy"
   },
   "dependencies": {
     "@anmho/authctl": "0.1.1",
     "@clack/prompts": "^1.2.0",
     "@neondatabase/api-client": "^2.7.1",
+    "@trigger.dev/sdk": "^4.4.6",
     "hono": "^4.10.1",
     "pg": "^8.16.3"
   },
@@ -26,6 +30,7 @@
     "@cloudflare/workers-types": "latest",
     "@types/pg": "^8.16.0",
     "@types/bun": "latest",
+    "trigger.dev": "^4.4.6",
     "typescript": "^5.9.3",
     "wrangler": "^4.49.0"
   }

package/templates/targets/workers/src/index.ts

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { authMiddleware } from "./auth";
 import { createStorage } from "./storage";
+import { createTriggerDevDispatcher, TriggerDispatchError, type TriggerDispatcher } from "./trigger";
 
 type Env = {
   HYPERDRIVE?: Hyperdrive;
@@ -8,10 +9,14 @@ type Env = {
   AUTH_ISSUER?: string;
   AUTH_AUDIENCE?: string;
   AUTH_JWKS_URL?: string;
+  TRIGGER_SECRET_KEY?: string;
+  TRIGGER_TASK_ID?: string;
+  TRIGGER_API_URL?: string;
 };
 
-export function createApp() {
+export function createApp(options: { triggerDispatcher?: TriggerDispatcher } = {}) {
   const app = new Hono<{ Bindings: Env }>();
+  const triggerDispatcher = options.triggerDispatcher ?? createTriggerDevDispatcher();
 
   app.get("/healthz", (context) => context.json({ status: "ok" }));
   app.get("/readyz", (context) => context.json({ status: "ok" }));
@@ -104,26 +109,36 @@ export function createApp() {
   });
 
   app.post("/v1/triggers/waitlist", async (context) => {
-    const body = await context.req.json().catch(() => ({}));
-    const trigger = await createStorage(context.env).recordTrigger({
-      type: String(body.type ?? "manual"),
-      entryId: body.entry_id ?? body.entryId ?? null,
-      payload: body,
-    });
-    return context.json({ trigger }, 202);
+    try {
+      const body = await context.req.json().catch(() => ({}));
+      const trigger = await createStorage(context.env).recordTrigger({
+        type: String(body.type ?? "manual"),
+        entryId: body.entry_id ?? body.entryId ?? null,
+        payload: body,
+      });
+      const run = await triggerDispatcher.dispatchWaitlistFollowUp(trigger, context.env);
+      return context.json({ trigger, trigger_dev_run_id: run.id }, 202);
+    } catch (error) {
+      return writeError(context, error);
+    }
   });
 
   app.post("/webhooks/:provider", async (context) => {
-    const rawBody = await context.req.text();
-    const trigger = await createStorage(context.env).recordTrigger({
-      type: `webhook.${context.req.param("provider")}`,
-      entryId: null,
-      payload: {
-        headers: Object.fromEntries(context.req.raw.headers),
-        rawBody,
-      },
-    });
-    return context.json({ trigger }, 202);
+    try {
+      const rawBody = await context.req.text();
+      const trigger = await createStorage(context.env).recordTrigger({
+        type: `webhook.${context.req.param("provider")}`,
+        entryId: null,
+        payload: {
+          headers: Object.fromEntries(context.req.raw.headers),
+          rawBody,
+        },
+      });
+      const run = await triggerDispatcher.dispatchWaitlistFollowUp(trigger, context.env);
+      return context.json({ trigger, trigger_dev_run_id: run.id }, 202);
+    } catch (error) {
+      return writeError(context, error);
+    }
   });
 
   app.get("/webhooks/:provider/health", (context) => context.json({ status: "ok", provider: context.req.param("provider") }));
@@ -153,6 +168,9 @@ function writeError(context: any, error: unknown) {
   if (error instanceof ValidationError) {
     return context.json({ error: error.message, code: error.code }, 400);
   }
+  if (error instanceof TriggerDispatchError) {
+    return context.json({ error: error.message, code: error.code }, 500);
+  }
   console.error(error);
   return context.json({ error: "internal server error", code: "internal" }, 500);
 }
@@ -188,11 +206,4 @@ function csvCell(value: string) {
 
 export default {
   fetch: app.fetch,
-  async scheduled(_event: ScheduledEvent, env: Env, context: ExecutionContext) {
-    context.waitUntil(
-      createStorage(env).claimQueuedTriggers(10).then((triggers) => {
-        console.log("processed waitlist triggers", triggers.length);
-      })
-    );
-  },
 };

package/templates/targets/workers/src/trigger.ts

@@ -0,0 +1,81 @@
+import type { WaitlistTrigger } from "./storage";
+
+export type TriggerRun = {
+  id: string;
+};
+
+export type TriggerDispatcher = {
+  dispatchWaitlistFollowUp(trigger: WaitlistTrigger, env: TriggerEnv): Promise<TriggerRun>;
+};
+
+export type TriggerEnv = {
+  TRIGGER_SECRET_KEY?: string;
+  TRIGGER_TASK_ID?: string;
+  TRIGGER_API_URL?: string;
+};
+
+export class TriggerDispatchError extends Error {
+  constructor(
+    readonly code: string,
+    message: string
+  ) {
+    super(message);
+  }
+}
+
+export function createTriggerDevDispatcher(): TriggerDispatcher {
+  return {
+    async dispatchWaitlistFollowUp(trigger, env) {
+      const config = triggerConfigFromEnv(env);
+      const response = await fetch(`${config.apiUrl}/api/v1/tasks/${encodeURIComponent(config.taskId)}/trigger`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${config.secretKey}`,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          payload: {
+            triggerId: trigger.id,
+            type: trigger.type,
+            entryId: trigger.entry_id,
+            payload: parsePayload(trigger.payload_json),
+          },
+          options: {
+            idempotencyKey: trigger.id,
+          },
+        }),
+      });
+
+      if (!response.ok) {
+        throw new TriggerDispatchError("trigger_dev_request_failed", `Trigger.dev task trigger failed with ${response.status}: ${await response.text()}`);
+      }
+
+      const result = (await response.json()) as { id?: string };
+      if (!result.id) {
+        throw new TriggerDispatchError("trigger_dev_missing_run_id", "Trigger.dev did not return a run id");
+      }
+      return { id: result.id };
+    },
+  };
+}
+
+function triggerConfigFromEnv(env: TriggerEnv = {}) {
+  const secretKey = env.TRIGGER_SECRET_KEY?.trim();
+  if (!secretKey) {
+    throw new TriggerDispatchError("trigger_dev_not_configured", "TRIGGER_SECRET_KEY is required to dispatch Trigger.dev tasks");
+  }
+
+  return {
+    secretKey,
+    taskId: env.TRIGGER_TASK_ID?.trim() || "{{SERVICE_ID}}-waitlist-follow-up",
+    apiUrl: (env.TRIGGER_API_URL?.trim() || "https://api.trigger.dev").replace(/\/$/, ""),
+  };
+}
+
+function parsePayload(value: string) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+}

package/templates/targets/workers/test/app.test.ts

@@ -1,5 +1,6 @@
 import { expect, test } from "bun:test";
 import { createApp } from "../src/index";
+import type { TriggerDispatcher } from "../src/trigger";
 
 type JoinResponse = {
   entry: {
@@ -92,7 +93,8 @@ test("waitlist join persists an idempotent entry", async () => {
 });
 
 test("waitlist trigger is queued for cron processing", async () => {
-  const response = await createApp().request("/v1/triggers/waitlist", {
+  const calls: unknown[] = [];
+  const response = await createApp({ triggerDispatcher: mockTriggerDispatcher(calls) }).request("/v1/triggers/waitlist", {
     method: "POST",
     body: JSON.stringify({ type: "cron.digest" }),
     headers: { "content-type": "application/json" },
@@ -104,5 +106,48 @@ test("waitlist trigger is queued for cron processing", async () => {
       type: "cron.digest",
       status: "queued",
     },
+    trigger_dev_run_id: "run_test",
   });
+  expect(calls).toHaveLength(1);
 });
+
+test("waitlist trigger reports missing Trigger.dev configuration", async () => {
+  const response = await createApp().request("/v1/triggers/waitlist", {
+    method: "POST",
+    body: JSON.stringify({ type: "manual" }),
+    headers: { "content-type": "application/json" },
+  });
+
+  expect(response.status).toBe(500);
+  await expect(response.json()).resolves.toMatchObject({
+    code: "trigger_dev_not_configured",
+  });
+});
+
+test("webhook dispatches a Trigger.dev run", async () => {
+  const calls: unknown[] = [];
+  const response = await createApp({ triggerDispatcher: mockTriggerDispatcher(calls) }).request("/webhooks/stripe", {
+    method: "POST",
+    body: JSON.stringify({ id: "evt_test" }),
+    headers: { "content-type": "application/json" },
+  });
+
+  expect(response.status).toBe(202);
+  await expect(response.json()).resolves.toMatchObject({
+    trigger: {
+      type: "webhook.stripe",
+      status: "queued",
+    },
+    trigger_dev_run_id: "run_test",
+  });
+  expect(calls).toHaveLength(1);
+});
+
+function mockTriggerDispatcher(calls: unknown[]): TriggerDispatcher {
+  return {
+    async dispatchWaitlistFollowUp(trigger) {
+      calls.push(trigger);
+      return { id: "run_test" };
+    },
+  };
+}

package/templates/targets/workers/trigger/waitlist-follow-up.ts

@@ -0,0 +1,24 @@
+import { logger, task } from "@trigger.dev/sdk";
+
+export type WaitlistFollowUpPayload = {
+  triggerId: string;
+  type: string;
+  entryId: string | null;
+  payload: unknown;
+};
+
+export const waitlistFollowUp = task({
+  id: "{{SERVICE_ID}}-waitlist-follow-up",
+  run: async (payload: WaitlistFollowUpPayload) => {
+    logger.info("Processing waitlist follow-up", {
+      triggerId: payload.triggerId,
+      type: payload.type,
+      entryId: payload.entryId,
+    });
+
+    return {
+      status: "queued",
+      triggerId: payload.triggerId,
+    };
+  },
+});

package/templates/targets/workers/trigger.config.ts

@@ -0,0 +1,24 @@
+import { defineConfig } from "@trigger.dev/sdk";
+
+const project = process.env.TRIGGER_PROJECT_REF;
+
+if (!project) {
+  throw new Error("TRIGGER_PROJECT_REF is required to build or deploy Trigger.dev tasks");
+}
+
+export default defineConfig({
+  project,
+  dirs: ["./trigger"],
+  runtime: "node-22",
+  maxDuration: 300,
+  retries: {
+    enabledInDev: false,
+    default: {
+      maxAttempts: 3,
+      minTimeoutInMs: 1_000,
+      maxTimeoutInMs: 10_000,
+      factor: 2,
+      randomize: true,
+    },
+  },
+});

package/templates/targets/workers/tsconfig.json

@@ -7,5 +7,5 @@
     "skipLibCheck": true,
     "types": ["bun", "@cloudflare/workers-types"]
   },
-  "include": ["src/**/*.ts", "test/**/*.ts", "scripts/**/*.ts"]
+  "include": ["src/**/*.ts", "test/**/*.ts", "scripts/**/*.ts", "trigger/**/*.ts", "trigger.config.ts"]
 }

package/templates/targets/workers/wrangler.toml

@@ -11,6 +11,8 @@ AUTH_ENABLED = "true"
 AUTH_ISSUER = "{{AUTH_ISSUER}}"
 AUTH_AUDIENCE = "{{AUTH_AUDIENCE}}"
 AUTH_JWKS_URL = "{{AUTH_JWKS_URL}}"
+TRIGGER_TASK_ID = "{{SERVICE_ID}}-waitlist-follow-up"
+TRIGGER_API_URL = "https://api.trigger.dev"
 
 [[routes]]
 pattern = "{{API_HOSTNAME}}"

package/templates/variants/bun-connectrpc/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "bun run ./scripts/dev.ts bun run ./src/index.ts",
+    "dev": "bun run ./scripts/dev.ts bun run ./src/index.ts --worker bun run ./src/worker.ts",
     "service": "service",
     "migrate": "service migrate",
     "gen": "bun run ./scripts/codegen.ts",

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

@@ -5,7 +5,7 @@ import { createServer } from "node:http";
 import { WaitlistService as WaitlistRpcService } from "../gen/protos/waitlist/v1/waitlist_pb.js";
 import { withServiceAuth } from "./auth";
 import { AppError, createDefaultWaitlistService, type WaitlistService } from "./waitlist/service";
-import { startTemporalWorker } from "./temporal/worker";
+import { assertTemporalRuntimeConfig } from "./temporal";
 import type { WaitlistEntry, WaitlistTrigger } from "./waitlist/types";
 
 type RpcService = ServiceImpl<typeof WaitlistRpcService>;
@@ -236,11 +236,7 @@ function headersPayload(headers: Parameters<FallbackHandler>[0]["headers"]) {
 }
 
 if (import.meta.main) {
-  const temporalWorker = await startTemporalWorker();
-  if (temporalWorker) {
-    console.log(`Temporal worker polling ${temporalWorker.taskQueue}`);
-  }
-
+  assertTemporalRuntimeConfig();
   const port = Number(Bun.env.PORT ?? 8080);
   const server = createServer(withServiceAuth(createHandler(createDefaultWaitlistService())));
   server.listen(port);

package/templates/variants/bun-connectrpc/src/temporal/client.ts

@@ -0,0 +1,28 @@
+import { Client, Connection } from "@temporalio/client";
+import type { WaitlistFollowUpInput } from "./activities";
+import { waitlistFollowUpWorkflow } from "./workflows";
+
+export function temporalClientEnabled() {
+  return (Bun.env.TEMPORAL_ENABLED ?? "").trim().toLowerCase() === "true";
+}
+
+export async function startWaitlistFollowUpWorkflow(input: WaitlistFollowUpInput) {
+  if (!temporalClientEnabled()) {
+    return undefined;
+  }
+
+  const address = Bun.env.TEMPORAL_ADDRESS || "localhost:7233";
+  const namespace = Bun.env.TEMPORAL_NAMESPACE || "default";
+  const taskQueue = Bun.env.TEMPORAL_TASK_QUEUE || "{{SERVICE_NAME}}";
+  const apiKey = Bun.env.TEMPORAL_API_KEY?.trim();
+  const connection = await Connection.connect({
+    address,
+    ...(apiKey ? { apiKey } : {}),
+  });
+  const client = new Client({ connection, namespace });
+  return client.workflow.start(waitlistFollowUpWorkflow, {
+    workflowId: `waitlist-follow-up-${input.triggerId ?? crypto.randomUUID()}`,
+    taskQueue,
+    args: [input],
+  });
+}

package/templates/variants/bun-connectrpc/src/temporal.ts

@@ -0,0 +1,56 @@
+export type TemporalRuntimeConfig = {
+  enabled: boolean;
+  address: string;
+  namespace: string;
+  taskQueue: string;
+};
+
+type Env = Record<string, string | undefined>;
+
+export function resolveTemporalRuntimeConfig(env: Env = Bun.env): TemporalRuntimeConfig {
+  const enabled = readBoolean(env.TEMPORAL_ENABLED, true);
+  const cloudRun = isCloudRun(env);
+
+  return {
+    enabled,
+    address: readString(env.TEMPORAL_ADDRESS, cloudRun ? "" : "localhost:7233"),
+    namespace: readString(env.TEMPORAL_NAMESPACE, cloudRun ? "" : "default"),
+    taskQueue: readString(env.TEMPORAL_TASK_QUEUE, "{{SERVICE_NAME}}"),
+  };
+}
+
+export function assertTemporalRuntimeConfig(config = resolveTemporalRuntimeConfig()) {
+  if (!config.enabled) {
+    return config;
+  }
+
+  const missing = [
+    config.address ? "" : "TEMPORAL_ADDRESS",
+    config.namespace ? "" : "TEMPORAL_NAMESPACE",
+  ].filter(Boolean);
+
+  if (missing.length > 0) {
+    throw new Error(
+      `Temporal is enabled, but ${missing.join(" and ")} ${missing.length === 1 ? "is" : "are"} required. Set Temporal Cloud connection settings or TEMPORAL_ENABLED=false.`
+    );
+  }
+
+  return config;
+}
+
+function readBoolean(value: string | undefined, fallback: boolean) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  return !["0", "false", "no", "off"].includes(normalized);
+}
+
+function readString(value: string | undefined, fallback: string) {
+  const normalized = value?.trim();
+  return normalized || fallback;
+}
+
+function isCloudRun(env: Env) {
+  return Boolean(env.K_SERVICE?.trim());
+}

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

@@ -1,5 +1,6 @@
 import { createDb } from "../db/client";
 import { WaitlistRepository } from "../db/repository";
+import { startWaitlistFollowUpWorkflow } from "../temporal/client";
 import type {
   JoinWaitlistInput,
   ListWaitlistEntriesInput,
@@ -109,12 +110,21 @@ export class DefaultWaitlistService implements WaitlistService {
       await this.getWaitlistEntry(input.entryId);
     }
 
-    return this.repository.createTrigger({
+    const trigger = await this.repository.createTrigger({
       id: crypto.randomUUID(),
       type,
       entryId: input.entryId?.trim() || null,
       payloadJson: normalizePayloadJson(input.payloadJson),
     });
+
+    const payload = parsePayloadJson(trigger.payloadJson);
+    startWaitlistFollowUpWorkflow({
+      triggerId: trigger.id,
+      email: typeof payload.email === "string" ? payload.email : undefined,
+      type: trigger.type,
+    }).catch((error) => console.error("failed to start waitlist follow-up workflow", error));
+
+    return trigger;
   }
 
   async recordWebhookEvent(input: RecordWebhookEventInput) {
@@ -192,3 +202,8 @@ function normalizePayloadJson(value: string | null | undefined) {
   JSON.parse(payload);
   return payload;
 }
+
+function parsePayloadJson(value: string) {
+  const parsed = JSON.parse(value || "{}");
+  return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {};
+}

package/templates/variants/bun-connectrpc/src/worker.ts

@@ -0,0 +1,21 @@
+import { assertTemporalRuntimeConfig } from "./temporal";
+import { startTemporalWorker } from "./temporal/worker";
+
+assertTemporalRuntimeConfig();
+const temporalWorker = await startTemporalWorker();
+if (!temporalWorker) {
+  throw new Error("Temporal worker is disabled. Set TEMPORAL_ENABLED=true or do not run the worker process.");
+}
+
+console.log(`Temporal worker polling ${temporalWorker.taskQueue}`);
+
+Bun.serve({
+  port: Number(Bun.env.PORT ?? 8080),
+  fetch: (request) => {
+    const path = new URL(request.url).pathname;
+    if (path === "/healthz" || path === "/readyz") {
+      return Response.json({ status: "ok", worker: "temporal" });
+    }
+    return Response.json({ status: "ok", worker: "temporal" });
+  },
+});

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

@@ -1,5 +1,6 @@
 import { expect, test } from "bun:test";
 import { createIntrospectionDocument, isLocalRpcIntrospectionEnabled } from "../src/index";
+import { assertTemporalRuntimeConfig, resolveTemporalRuntimeConfig } from "../src/temporal";
 
 test("local introspection document exposes waitlist service and methods", () => {
   const document = createIntrospectionDocument();
@@ -16,3 +17,24 @@ test("local introspection defaults to enabled outside Cloud Run", () => {
 
   expect(isLocalRpcIntrospectionEnabled()).toBeTrue();
 });
+
+test("Temporal runtime config defaults to enabled local development", () => {
+  expect(resolveTemporalRuntimeConfig({})).toEqual({
+    enabled: true,
+    address: "localhost:7233",
+    namespace: "default",
+    taskQueue: "{{SERVICE_NAME}}",
+  });
+});
+
+test("Temporal runtime config supports explicit opt-out", () => {
+  expect(resolveTemporalRuntimeConfig({ TEMPORAL_ENABLED: "false", K_SERVICE: "svc" })).toMatchObject({
+    enabled: false,
+  });
+});
+
+test("Temporal runtime config fails clearly in Cloud Run without connection settings", () => {
+  expect(() => assertTemporalRuntimeConfig(resolveTemporalRuntimeConfig({ K_SERVICE: "svc" }))).toThrow(
+    "TEMPORAL_ADDRESS and TEMPORAL_NAMESPACE"
+  );
+});

package/templates/variants/bun-hono/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "bun run ./scripts/dev.ts bun run ./src/index.ts",
+    "dev": "bun run ./scripts/dev.ts bun run ./src/index.ts --worker bun run ./src/worker.ts",
     "service": "service",
     "migrate": "service migrate",
     "gen": "bun run ./scripts/codegen.ts",

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

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
 import { authMiddleware } from "./auth";
 import { AppError, createDefaultWaitlistService, type WaitlistService } from "./waitlist/service";
-import { startTemporalWorker } from "./temporal/worker";
+import { assertTemporalRuntimeConfig } from "./temporal";
 
 export function createApp(service: WaitlistService) {
   const app = new Hono();
@@ -169,11 +169,7 @@ function webhookEventId(payload: unknown, headers: Headers) {
 }
 
 if (import.meta.main) {
-  const temporalWorker = await startTemporalWorker();
-  if (temporalWorker) {
-    console.log(`Temporal worker polling ${temporalWorker.taskQueue}`);
-  }
-
+  assertTemporalRuntimeConfig();
   Bun.serve({
     port: Number(Bun.env.PORT ?? 3000),
     fetch: createApp(createDefaultWaitlistService()).fetch,

package/templates/variants/bun-hono/src/temporal/client.ts

@@ -0,0 +1,28 @@
+import { Client, Connection } from "@temporalio/client";
+import type { WaitlistFollowUpInput } from "./activities";
+import { waitlistFollowUpWorkflow } from "./workflows";
+
+export function temporalClientEnabled() {
+  return (Bun.env.TEMPORAL_ENABLED ?? "").trim().toLowerCase() === "true";
+}
+
+export async function startWaitlistFollowUpWorkflow(input: WaitlistFollowUpInput) {
+  if (!temporalClientEnabled()) {
+    return undefined;
+  }
+
+  const address = Bun.env.TEMPORAL_ADDRESS || "localhost:7233";
+  const namespace = Bun.env.TEMPORAL_NAMESPACE || "default";
+  const taskQueue = Bun.env.TEMPORAL_TASK_QUEUE || "{{SERVICE_NAME}}";
+  const apiKey = Bun.env.TEMPORAL_API_KEY?.trim();
+  const connection = await Connection.connect({
+    address,
+    ...(apiKey ? { apiKey } : {}),
+  });
+  const client = new Client({ connection, namespace });
+  return client.workflow.start(waitlistFollowUpWorkflow, {
+    workflowId: `waitlist-follow-up-${input.triggerId ?? crypto.randomUUID()}`,
+    taskQueue,
+    args: [input],
+  });
+}