create-svc 0.1.85 → 0.1.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-svc",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "description": "Local microservice bootstrap CLI for Cloud Run and Workers services with Neon-backed data.",
   "module": "index.ts",
   "type": "module",

package/src/scaffold.test.ts

@@ -113,6 +113,8 @@ test("scaffolds all runtime/framework variants with shared cloudrun config", asy
 
     const dockerCompose = await Bun.file(join(generatedRoot, "docker-compose.yml")).text();
     expect(dockerCompose).toContain('image: postgres:16-alpine');
+    expect(dockerCompose).toContain("image: temporalio/auto-setup:");
+    expect(dockerCompose).toContain("127.0.0.1:7233:7233");
     expect(dockerCompose).toContain(`127.0.0.1:${localPort}:5432`);
 
     const envExample = await Bun.file(join(generatedRoot, ".env.example")).text();
@@ -337,7 +339,7 @@ test("scaffolds a backend package cleanly into a nested monorepo-style directory
   expect(readme).toContain("`microservice` profile");
   expect(readme).toContain("api.dns-api.anmho.com");
   expect(readme).toContain("open Docker Desktop if needed");
-  expect(readme).toContain("local Postgres service in `docker-compose.yml`");
+  expect(readme).toContain("local Postgres and Temporal services in `docker-compose.yml`");
   expect(readme).toContain("gcloud auth login");
   expect(readme).toContain("known-good CLIs");
   expect(readme).toContain("service create");

package/src/scaffold.ts

@@ -244,6 +244,8 @@ function buildReplacements(config: ScaffoldConfig) {
     COMMAND_GEN: config.runtime === "bun" ? "bun run gen" : "make gen",
     COMMAND_LINT: config.runtime === "bun" ? "bun run lint" : "make lint",
     COMMAND_TEST: config.runtime === "bun" ? "bun run test" : "make test",
+    COMMAND_TEST_E2E_LOCAL: config.runtime === "bun" ? "bun run test:e2e:local" : "make test-e2e-local",
+    COMMAND_TEST_E2E_PROD: config.runtime === "bun" ? "bun run test:e2e:prod" : "make test-e2e-prod",
     COMMAND_DEV_DOWN: "service dev down",
     COMMAND_BOOTSTRAP: "service create",
     COMMAND_DEPLOY: "service deploy",

package/src/service-runtime/authctl-command.ts

@@ -0,0 +1,12 @@
+export type AuthctlCommand = {
+  path: string;
+  runWithBun: boolean;
+};
+
+export function authctlSpawnArgs(command: AuthctlCommand, args: string[]) {
+  return command.runWithBun ? [bunExecutable(), command.path, ...args] : [command.path, ...args];
+}
+
+function bunExecutable() {
+  return Bun.which("bun") ?? process.execPath;
+}

package/src/service-runtime/authctl.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "bun:test";
+import { authctlSpawnArgs } from "./authctl-command";
+
+test("authctlSpawnArgs runs repo-local authctl through bun", () => {
+  const args = authctlSpawnArgs({ path: "./node_modules/.bin/authctl", runWithBun: true }, ["doctor", "--json"]);
+
+  expect(args[0]).toEndWith("bun");
+  expect(args.slice(1)).toEqual(["./node_modules/.bin/authctl", "doctor", "--json"]);
+});
+
+test("authctlSpawnArgs runs global authctl directly", () => {
+  expect(authctlSpawnArgs({ path: "/usr/local/bin/authctl", runWithBun: false }, ["version"])).toEqual([
+    "/usr/local/bin/authctl",
+    "version",
+  ]);
+});

package/src/service-runtime/authctl.ts

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { authctlSpawnArgs, type AuthctlCommand } from "./authctl-command";
 import { serviceConfig } from "./runtime";
 
 type CommandResult = {
@@ -9,6 +10,7 @@ type CommandResult = {
 };
 
 const decoder = new TextDecoder();
+const localAuthctlPath = "./node_modules/.bin/authctl";
 
 export type AuthDoctorResult = {
   hasAuthctl: boolean;
@@ -418,12 +420,12 @@ function resolveResourceServerCommand(): ResourceServerCommand | undefined {
 }
 
 function authctl(args: string[], options: { allowFailure?: boolean; quiet?: boolean } = {}): CommandResult {
-  const command = authctlPath();
+  const command = authctlCommand();
   if (!command) {
     throw new Error("authctl is not installed; run bun install in this generated service or link @anmho/authctl");
   }
 
-  const result = Bun.spawnSync([command, ...args], {
+  const result = Bun.spawnSync(authctlSpawnArgs(command, args), {
     cwd: process.cwd(),
     env: authctlEnvironment(),
     stdin: "inherit",
@@ -464,8 +466,24 @@ function formatAuthctlFailure(args: string[], output: CommandResult) {
   return `authctl ${args.join(" ")} failed with exit code ${output.exitCode}\n${detail}`;
 }
 
+function authctlCommand(): AuthctlCommand | undefined {
+  if (existsSync(localAuthctlPath)) {
+    return {
+      path: localAuthctlPath,
+      runWithBun: true,
+    };
+  }
+  const global = Bun.which("authctl");
+  return global
+    ? {
+        path: global,
+        runWithBun: false,
+      }
+    : undefined;
+}
+
 function authctlPath() {
-  return existsSync("./node_modules/.bin/authctl") ? "./node_modules/.bin/authctl" : Bun.which("authctl");
+  return authctlCommand()?.path;
 }
 
 function authctlEnvironment() {

package/templates/shared/README.md

@@ -29,6 +29,8 @@ console to create and deploy.
 {{COMMAND_GEN}}
 {{COMMAND_LINT}}
 {{COMMAND_TEST}}
+{{COMMAND_TEST_E2E_LOCAL}}
+{{COMMAND_TEST_E2E_PROD}}
 {{COMMAND_BOOTSTRAP}}
 {{COMMAND_DEPLOY}}
 {{COMMAND_PROTECT_MAIN}}
@@ -43,7 +45,7 @@ console to create and deploy.
 
 ## Local development
 
-The scaffold writes a ready-to-use `.env.local` and includes a local Postgres service in `docker-compose.yml`.
+The scaffold writes a ready-to-use `.env.local` and includes local Postgres and Temporal services in `docker-compose.yml`.
 
 First local run:
 
@@ -55,11 +57,26 @@ First local run:
 Local runtime uses:
 
 - `DATABASE_URL` from `.env.local`, pointed at Docker Compose Postgres
-- `{{COMMAND_MIGRATE}}` and `{{COMMAND_DEV}}`, which open Docker Desktop if needed, wait for Docker readiness, and start Docker Compose Postgres
-- `TEMPORAL_ENABLED=true` by default with `localhost:7233` and `default`; set `TEMPORAL_ENABLED=false` when you are not running a local Temporal server
+- `{{COMMAND_MIGRATE}}` and `{{COMMAND_DEV}}`, which open Docker Desktop if needed, wait for Docker readiness, and start Docker Compose Postgres and Temporal
+- `TEMPORAL_ENABLED=true` by default with `localhost:7233` and `default`; `{{COMMAND_DEV}}` waits for the local Temporal container before starting the API and worker
 
 No cloud credentials are required for local HTTP development after Docker and Postgres are running.
 
+Run the local end-to-end test against the already-running local service:
+
+```bash
+{{COMMAND_TEST_E2E_LOCAL}}
+```
+
+The production end-to-end test exercises health and public webhook idempotency,
+then requires Cloud Logging rows and Cloud Monitoring
+`run.googleapis.com/container/instance_count` rows for the current Cloud Run API
+and worker revisions:
+
+```bash
+{{COMMAND_TEST_E2E_PROD}}
+```
+
 ## Temporal
 
 Temporal is enabled by default for generated services.
@@ -78,7 +95,7 @@ creates a trigger, the API service starts `waitlistFollowUpWorkflow` /
 `WaitlistFollowUpWorkflow` asynchronously on the service task queue. The API
 request only waits for the trigger record; workflow completion happens through
 Temporal and is polled by the worker service.
-Local `{{COMMAND_DEV}}` starts the API process and the worker process together.
+Local `{{COMMAND_DEV}}` starts the API process and the worker process together after Docker Compose starts the local Temporal server.
 
 Production and preview deploys render `TEMPORAL_ENABLED=true` into the Cloud Run
 manifest unless you override it. For Temporal Cloud, replace the local defaults

package/templates/shared/docker-compose.yml

@@ -15,5 +15,21 @@ services:
       timeout: 5s
       retries: 10
 
+  temporal:
+    image: temporalio/auto-setup:1.28.1
+    depends_on:
+      postgres:
+        condition: service_healthy
+    environment:
+      DB: postgres12
+      DB_PORT: 5432
+      POSTGRES_USER: {{LOCAL_DATABASE_USER}}
+      POSTGRES_PWD: {{LOCAL_DATABASE_PASSWORD}}
+      POSTGRES_SEEDS: postgres
+      DBNAME: temporal
+      VISIBILITY_DBNAME: temporal_visibility
+    ports:
+      - "127.0.0.1:7233:7233"
+
 volumes:
   postgres-data:

package/templates/shared/scripts/dev.ts

@@ -16,6 +16,9 @@ const env = {
 if (env.DATABASE_URL && !env.CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_HYPERDRIVE) {
   env.CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_HYPERDRIVE = env.DATABASE_URL;
 }
+if (temporalEnabled(env)) {
+  await waitForTemporal(env.TEMPORAL_ADDRESS || "localhost:7233");
+}
 
 const api = Bun.spawn(apiCommand, {
   stdin: "inherit",
@@ -57,3 +60,36 @@ function parseCommands(argv: string[]) {
   const workerCommand = argv.slice(separator + 1);
   return { apiCommand, workerCommand: workerCommand.length > 0 ? workerCommand : undefined };
 }
+
+function temporalEnabled(env: Record<string, string | undefined>) {
+  return (env.TEMPORAL_ENABLED ?? "true").trim().toLowerCase() !== "false";
+}
+
+async function waitForTemporal(address: string) {
+  const { host, port } = parseTemporalAddress(address);
+  const deadline = Date.now() + 120_000;
+
+  while (Date.now() < deadline) {
+    const exitCode = await Bun.spawn(["nc", "-z", host, String(port)], {
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+    }).exited;
+    if (exitCode === 0) {
+      return;
+    }
+    await Bun.sleep(2_000);
+  }
+
+  throw new Error(`Temporal did not become ready at ${host}:${port} within 120 seconds`);
+}
+
+function parseTemporalAddress(address: string) {
+  const trimmed = address.trim();
+  const withoutScheme = trimmed.includes("://") ? new URL(trimmed).host : trimmed;
+  const [host = "localhost", port = "7233"] = withoutScheme.split(":");
+  return {
+    host: host || "localhost",
+    port: Number(port || "7233"),
+  };
+}

package/templates/shared/scripts/e2e.ts

@@ -0,0 +1,275 @@
+type Target = "local" | "prod";
+
+export {};
+
+type CommandOptions = {
+  allowFailure?: boolean;
+};
+
+type CloudRunService = {
+  status?: {
+    latestReadyRevisionName?: string;
+  };
+};
+
+type MonitoringSeries = {
+  resource?: {
+    labels?: Record<string, string>;
+  };
+  points?: Array<{
+    value?: {
+      int64Value?: string;
+      doubleValue?: number;
+    };
+    interval?: {
+      endTime?: string;
+    };
+  }>;
+};
+
+const args = parseArgs(Bun.argv.slice(2));
+const serviceName = "{{SERVICE_NAME}}";
+const projectId = "{{PROJECT_ID}}";
+const region = "{{REGION}}";
+const apiHostname = "{{API_HOSTNAME}}";
+const baseUrl = args.url ?? (args.target === "prod" ? `https://${apiHostname}` : `http://127.0.0.1:${Bun.env.PORT || "3000"}`);
+const proofId = `e2e-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+
+section(`${serviceName} ${args.target} e2e`);
+detail("base_url", baseUrl);
+detail("event_id", proofId);
+
+await requestJSON(`${baseUrl}/healthz`, { expectStatus: 200 });
+
+const webhookPayload = {
+  id: proofId,
+  source: "generated-e2e",
+  service: serviceName,
+  target: args.target,
+};
+const firstWebhook = await requestJSON(`${baseUrl}/webhooks/generated-e2e`, {
+  method: "POST",
+  headers: {
+    "content-type": "application/json",
+    "x-webhook-event-id": proofId,
+  },
+  body: JSON.stringify(webhookPayload),
+  expectStatus: 202,
+});
+detail("webhook_first", JSON.stringify(firstWebhook));
+
+const secondWebhook = await requestJSON(`${baseUrl}/webhooks/generated-e2e`, {
+  method: "POST",
+  headers: {
+    "content-type": "application/json",
+    "x-webhook-event-id": proofId,
+  },
+  body: JSON.stringify(webhookPayload),
+  expectStatus: 200,
+});
+detail("webhook_duplicate", JSON.stringify(secondWebhook));
+if (!isDuplicateWebhook(secondWebhook)) {
+  throw new Error("second webhook delivery did not report duplicate=true");
+}
+
+if (args.target === "prod") {
+  await Bun.sleep(5_000);
+  const state = await printCloudRunState();
+  await printCloudLogs(serviceName, state.apiRevision);
+  await printCloudLogs(`${serviceName}-worker`, state.workerRevision);
+  await printCloudMetrics(state);
+}
+
+section("e2e complete");
+
+async function requestJSON(
+  url: string,
+  options: RequestInit & { expectStatus: number } = { expectStatus: 200 }
+) {
+  const response = await fetch(url, {
+    ...options,
+    signal: AbortSignal.timeout(15_000),
+  });
+  const text = await response.text();
+  if (response.status !== options.expectStatus) {
+    throw new Error(`${url} returned ${response.status}, expected ${options.expectStatus}: ${text}`);
+  }
+  if (!text) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { text };
+  }
+}
+
+function isDuplicateWebhook(value: unknown) {
+  return Boolean(value && typeof value === "object" && "duplicate" in value && value.duplicate === true);
+}
+
+async function printCloudRunState() {
+  const [api, worker] = await Promise.all([
+    describeCloudRunService(serviceName),
+    describeCloudRunService(`${serviceName}-worker`),
+  ]);
+  const apiRevision = api.status?.latestReadyRevisionName ?? "";
+  const workerRevision = worker.status?.latestReadyRevisionName ?? "";
+  if (!apiRevision) {
+    throw new Error(`Cloud Run service ${serviceName} did not report latestReadyRevisionName`);
+  }
+  if (!workerRevision) {
+    throw new Error(`Cloud Run service ${serviceName}-worker did not report latestReadyRevisionName`);
+  }
+  detail("api_revision", apiRevision);
+  detail("worker_revision", workerRevision);
+  return { apiRevision, workerRevision };
+}
+
+async function describeCloudRunService(name: string): Promise<CloudRunService> {
+  const output = await command([
+    "gcloud",
+    "run",
+    "services",
+    "describe",
+    name,
+    "--project",
+    projectId,
+    "--region",
+    region,
+    "--format=json",
+  ]);
+  return JSON.parse(output || "{}") as CloudRunService;
+}
+
+async function printCloudLogs(name: string, revision: string) {
+  const filter = [
+    'resource.type="cloud_run_revision"',
+    `resource.labels.service_name="${name}"`,
+    `resource.labels.revision_name="${revision}"`,
+  ].join(" AND ");
+  const output = await command([
+    "gcloud",
+    "logging",
+    "read",
+    filter,
+    "--project",
+    projectId,
+    "--limit=3",
+    "--format=json",
+  ]);
+  const rows = JSON.parse(output || "[]") as unknown[];
+  section(`cloud logs ${name}`);
+  if (rows.length === 0) {
+    throw new Error(`Cloud Logging did not return rows for ${name} revision ${revision}`);
+  }
+  console.log(JSON.stringify(rows, null, 2));
+}
+
+async function printCloudMetrics(expected: { apiRevision: string; workerRevision: string }) {
+  const expectedRevisions = new Set([expected.apiRevision, expected.workerRevision]);
+  for (let attempt = 1; attempt <= 6; attempt += 1) {
+    const rows = await readCloudMetrics();
+    const seenRevisions = new Set(rows.map((row) => row.revision).filter(Boolean));
+    section(`cloud metrics container/instance_count attempt ${attempt}`);
+    for (const row of rows) {
+      console.log(`${row.service}\t${row.revision}\t${row.value}\t${row.endTime}`);
+    }
+    const missing = [...expectedRevisions].filter((revision) => !seenRevisions.has(revision));
+    if (missing.length === 0) {
+      return;
+    }
+    if (attempt === 6) {
+      throw new Error(`Cloud Monitoring did not return current revision metrics: ${missing.join(", ")}`);
+    }
+    detail("metrics_waiting_for_revisions", missing.join(", "));
+    await Bun.sleep(20_000);
+  }
+}
+
+async function readCloudMetrics() {
+  const end = new Date().toISOString();
+  const start = new Date(Date.now() - 20 * 60_000).toISOString();
+  const accessToken = await command(["gcloud", "auth", "print-access-token"]);
+  const filter = `metric.type="run.googleapis.com/container/instance_count" AND resource.labels.service_name=starts_with("${serviceName}")`;
+  const url = new URL(`https://monitoring.googleapis.com/v3/projects/${projectId}/timeSeries`);
+  url.searchParams.set("filter", filter);
+  url.searchParams.set("interval.startTime", start);
+  url.searchParams.set("interval.endTime", end);
+  url.searchParams.set("aggregation.alignmentPeriod", "60s");
+  url.searchParams.set("aggregation.perSeriesAligner", "ALIGN_SUM");
+  url.searchParams.set("view", "FULL");
+  const response = await fetch(url, {
+    headers: { authorization: `Bearer ${accessToken}` },
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!response.ok) {
+    throw new Error(`Cloud Monitoring query failed: ${response.status} ${await response.text()}`);
+  }
+  const data = (await response.json()) as { timeSeries?: MonitoringSeries[] };
+  return ((data.timeSeries ?? []) as MonitoringSeries[]).map((series) => {
+    const labels = series.resource?.labels ?? {};
+    const point = series.points?.[0];
+    const value = point?.value?.int64Value ?? point?.value?.doubleValue ?? "";
+    return {
+      service: labels.service_name ?? "",
+      revision: labels.revision_name ?? "",
+      value,
+      endTime: point?.interval?.endTime ?? "",
+    };
+  });
+}
+
+async function command(commandArgs: string[], options: CommandOptions = {}) {
+  const process = Bun.spawn(commandArgs, {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: Bun.env,
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(process.stdout).text(),
+    new Response(process.stderr).text(),
+    process.exited,
+  ]);
+  if (exitCode !== 0 && !options.allowFailure) {
+    throw new Error(`${commandArgs.join(" ")} failed with exit code ${exitCode}\n${stderr.trim()}`);
+  }
+  return stdout.trim();
+}
+
+function parseArgs(argv: string[]) {
+  let target: Target = "local";
+  let url = "";
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--local") {
+      target = "local";
+    } else if (arg === "--prod") {
+      target = "prod";
+    } else if (arg === "--url") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("Missing value for --url");
+      }
+      url = value;
+      index += 1;
+    } else if (arg.startsWith("--url=")) {
+      url = arg.slice("--url=".length);
+    } else if (arg === "--help" || arg === "-h") {
+      console.log("Usage: bun run ./scripts/e2e.ts [--local|--prod] [--url <origin>]");
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return { target, url };
+}
+
+function section(title: string) {
+  console.log(`\n== ${title} ==`);
+}
+
+function detail(key: string, value: string) {
+  console.log(`${key}: ${value}`);
+}

package/templates/shared/scripts/local-docker.ts

@@ -1,6 +1,6 @@
 export async function ensureLocalPostgres() {
   await ensureDockerRunning();
-  await run(["docker", "compose", "up", "-d"], { label: "start local postgres" });
+  await run(["docker", "compose", "up", "-d"], { label: "start local services" });
 }
 
 async function ensureDockerRunning() {

package/templates/variants/bun-connectrpc/Makefile

@@ -1,4 +1,4 @@
-.PHONY: dev migrate gen lint test create deploy protect-main dashboards observability-bootstrap auth destroy
+.PHONY: dev migrate gen lint test test-e2e test-e2e-local test-e2e-prod create deploy protect-main dashboards observability-bootstrap auth destroy
 
 SERVICE := service
 
@@ -17,6 +17,15 @@ lint:
 test:
 	bun test
 
+test-e2e:
+	bun run ./scripts/e2e.ts $(ARGS)
+
+test-e2e-local:
+	bun run ./scripts/e2e.ts --local $(ARGS)
+
+test-e2e-prod:
+	bun run ./scripts/e2e.ts --prod $(ARGS)
+
 create:
 	$(SERVICE) create
 

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

@@ -9,6 +9,9 @@
     "gen": "bun run ./scripts/codegen.ts",
     "lint": "tsc --noEmit",
     "test": "bun test",
+    "test:e2e": "bun run ./scripts/e2e.ts",
+    "test:e2e:local": "bun run ./scripts/e2e.ts --local",
+    "test:e2e:prod": "bun run ./scripts/e2e.ts --prod",
     "create": "service create",
     "deploy": "service deploy",
     "protect-main": "service protect-main",

package/templates/variants/bun-hono/Makefile

@@ -1,4 +1,4 @@
-.PHONY: dev migrate gen lint test create deploy protect-main dashboards observability-bootstrap auth destroy
+.PHONY: dev migrate gen lint test test-e2e test-e2e-local test-e2e-prod create deploy protect-main dashboards observability-bootstrap auth destroy
 
 SERVICE := service
 
@@ -17,6 +17,15 @@ lint:
 test:
 	bun test
 
+test-e2e:
+	bun run ./scripts/e2e.ts $(ARGS)
+
+test-e2e-local:
+	bun run ./scripts/e2e.ts --local $(ARGS)
+
+test-e2e-prod:
+	bun run ./scripts/e2e.ts --prod $(ARGS)
+
 create:
 	$(SERVICE) create
 

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

@@ -9,6 +9,9 @@
     "gen": "bun run ./scripts/codegen.ts",
     "lint": "tsc --noEmit",
     "test": "bun test",
+    "test:e2e": "bun run ./scripts/e2e.ts",
+    "test:e2e:local": "bun run ./scripts/e2e.ts --local",
+    "test:e2e:prod": "bun run ./scripts/e2e.ts --prod",
     "create": "service create",
     "deploy": "service deploy",
     "protect-main": "service protect-main",

package/templates/variants/go-chi/Makefile

@@ -1,4 +1,4 @@
-.PHONY: dev migrate migrate-lint gen lint test create deploy protect-main dashboards observability-bootstrap auth destroy
+.PHONY: dev migrate migrate-lint gen lint test test-e2e test-e2e-local test-e2e-prod create deploy protect-main dashboards observability-bootstrap auth destroy
 
 SERVICE := service
 WITH_ENV := set -a; [ ! -f .env.local ] || . ./.env.local; set +a;
@@ -27,6 +27,15 @@ lint:
 test:
 	bun test ./test
 
+test-e2e:
+	bun run ./scripts/e2e.ts $(ARGS)
+
+test-e2e-local:
+	bun run ./scripts/e2e.ts --local $(ARGS)
+
+test-e2e-prod:
+	bun run ./scripts/e2e.ts --prod $(ARGS)
+
 create:
 	$(SERVICE) create
 

package/templates/variants/go-chi/package.json

@@ -9,6 +9,9 @@
     "gen": "make gen",
     "lint": "make lint",
     "test": "make test",
+    "test:e2e": "bun run ./scripts/e2e.ts",
+    "test:e2e:local": "bun run ./scripts/e2e.ts --local",
+    "test:e2e:prod": "bun run ./scripts/e2e.ts --prod",
     "create": "service create",
     "deploy": "service deploy",
     "protect-main": "service protect-main",

package/templates/variants/go-connectrpc/Makefile

@@ -1,4 +1,4 @@
-.PHONY: dev migrate migrate-lint gen lint test create deploy protect-main dashboards observability-bootstrap auth destroy
+.PHONY: dev migrate migrate-lint gen lint test test-e2e test-e2e-local test-e2e-prod create deploy protect-main dashboards observability-bootstrap auth destroy
 
 SERVICE := service
 WITH_ENV := set -a; [ ! -f .env.local ] || . ./.env.local; set +a;
@@ -28,6 +28,15 @@ lint:
 test:
 	bun test ./test
 
+test-e2e:
+	bun run ./scripts/e2e.ts $(ARGS)
+
+test-e2e-local:
+	bun run ./scripts/e2e.ts --local $(ARGS)
+
+test-e2e-prod:
+	bun run ./scripts/e2e.ts --prod $(ARGS)
+
 create:
 	$(SERVICE) create
 

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

@@ -9,6 +9,9 @@
     "gen": "make gen",
     "lint": "make lint",
     "test": "make test",
+    "test:e2e": "bun run ./scripts/e2e.ts",
+    "test:e2e:local": "bun run ./scripts/e2e.ts --local",
+    "test:e2e:prod": "bun run ./scripts/e2e.ts --prod",
     "create": "service create",
     "deploy": "service deploy",
     "protect-main": "service protect-main",