create-svc 0.1.61 → 0.1.63

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],
+  });
+}

package/templates/variants/bun-hono/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-hono/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,20 @@ 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,
       payload: input.payload ?? {},
     });
+
+    startWaitlistFollowUpWorkflow({
+      triggerId: trigger.id,
+      email: trigger.payload && typeof trigger.payload === "object" && "email" in trigger.payload ? String(trigger.payload.email) : undefined,
+      type: trigger.type,
+    }).catch((error) => console.error("failed to start waitlist follow-up workflow", error));
+
+    return trigger;
   }
 
   async recordWebhookEvent(input: RecordWebhookEventInput) {

package/templates/variants/bun-hono/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/go-chi/Dockerfile

@@ -8,12 +8,14 @@ COPY cmd ./cmd
 
 RUN go mod download
 RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /out/server ./cmd/server
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /out/worker ./cmd/worker
 
 FROM gcr.io/distroless/base-debian12
 
 WORKDIR /app
 
 COPY --from=builder /out/server /app/server
+COPY --from=builder /out/worker /app/worker
 
 ENV PORT=8080
 

package/templates/variants/go-chi/Makefile

@@ -5,7 +5,7 @@ WITH_ENV := set -a; [ ! -f .env.local ] || . ./.env.local; set +a;
 ATLAS ?= atlas
 
 dev:
-	@bun run ./scripts/dev.ts go run ./cmd/server
+	@bun run ./scripts/dev.ts go run ./cmd/server --worker go run ./cmd/worker
 
 migrate:
 	@bun run ./scripts/ensure-local-db.ts

package/templates/variants/go-chi/cmd/server/main.go

@@ -31,17 +31,18 @@ func main() {
 
 	service := app.NewWaitlistService(db)
 	if cfg.TemporalEnabled {
-		stopTemporal, err := temporalapp.StartWorker(temporalapp.WorkerConfig{
+		temporalConfig := temporalapp.WorkerConfig{
 			Address:   cfg.TemporalAddress,
 			Namespace: cfg.TemporalNamespace,
 			TaskQueue: cfg.TemporalTaskQueue,
 			APIKey:    cfg.TemporalAPIKey,
-		})
+		}
+		dispatcher, err := temporalapp.NewTriggerDispatcher(temporalConfig)
 		if err != nil {
 			log.Fatal(err)
 		}
-		defer stopTemporal()
-		log.Printf("Temporal worker polling %s", cfg.TemporalTaskQueue)
+		defer dispatcher.Close()
+		service.SetTriggerDispatcher(dispatcher)
 	}
 
 	router := chi.NewRouter()