create-svc 0.1.40 → 0.1.42

package/package.json

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

package/src/post-scaffold.test.ts

@@ -4,6 +4,7 @@ import {
   buildLocalVerificationCommands,
   buildPostScaffoldCommands,
   buildPreGitBootstrapCommands,
+  shouldRunLocalMigrate,
 } from "./post-scaffold";
 
 describe("buildPostScaffoldCommands", () => {
@@ -37,6 +38,13 @@ describe("buildPreGitBootstrapCommands", () => {
   });
 });
 
+describe("shouldRunLocalMigrate", () => {
+  test("skips local migrate before Workers dev", () => {
+    expect(shouldRunLocalMigrate({ target: "workers" })).toBe(false);
+    expect(shouldRunLocalMigrate({ target: "cloudrun" })).toBe(true);
+  });
+});
+
 describe("buildLocalVerificationCommands", () => {
   test("uses local curl checks for Bun Hono services", () => {
     expect(buildLocalVerificationCommands({ apiHostname: "api.launch.anmho.com", framework: "hono", runtime: "bun" })).toEqual([

package/src/post-scaffold.ts

@@ -58,7 +58,9 @@ export function runPreGitBootstrapFlow(config: Pick<ScaffoldConfig, "framework">
 }
 
 async function startLocalDevelopment(config: Pick<ScaffoldConfig, "target">, cwd: string) {
-  run("bun", ["run", "migrate"], { cwd });
+  if (shouldRunLocalMigrate(config)) {
+    run("bun", ["run", "migrate"], { cwd });
+  }
   await mkdir(join(cwd, ".service"), { recursive: true });
   const child = Bun.spawn(["sh", "-c", "exec bun run dev > .service/local-dev.log 2>&1 < /dev/null"], {
     cwd,
@@ -72,6 +74,10 @@ async function startLocalDevelopment(config: Pick<ScaffoldConfig, "target">, cwd
   await Bun.write(join(cwd, ".service", "local-dev.pid"), `${child.pid}\n`);
 }
 
+export function shouldRunLocalMigrate(config: Pick<ScaffoldConfig, "target">) {
+  return config.target !== "workers";
+}
+
 function runWithRetries(command: PostScaffoldCommand, options: CommandOptions, attempts: number, delayMs: number) {
   let lastError: unknown;
   for (let attempt = 1; attempt <= attempts; attempt += 1) {

package/src/service-runtime/cloudrun/deploy-args.ts

@@ -6,6 +6,12 @@ export type DeployArgs = {
   name?: string;
 };
 
+export const CLOUD_RUN_LOCAL_BUILD_PLATFORM = "linux/amd64";
+
+export function localDockerBuildArgs(image: string) {
+  return ["build", "--platform", CLOUD_RUN_LOCAL_BUILD_PLATFORM, "-t", image, "."];
+}
+
 export function parseDeployArgs(argv: string[]): DeployArgs {
   const parsed: DeployArgs = {
     build: parseBuildStrategy(process.env.SERVICE_BUILD_STRATEGY || process.env.SERVICE_BUILD),
@@ -87,4 +93,3 @@ function parseBuildStrategy(value: string | undefined): DeployArgs["build"] {
   }
   throw new Error(`Unknown build strategy: ${value}`);
 }
-

package/src/service-runtime/cloudrun/deploy.ts

@@ -12,6 +12,7 @@ import {
   gcloudStreaming,
   gcloudWithRetry,
   imageUrl,
+  localDockerBuildArgs,
   parseDeployArgs,
   requireCommand,
   resolveDeploymentTarget,
@@ -84,7 +85,7 @@ export async function deploy(args = Bun.argv.slice(2), deployOptions: DeployOpti
     await runStep("Authenticating Docker to Artifact Registry", () =>
       gcloud(["auth", "configure-docker", `${config.region}-docker.pkg.dev`, "--quiet"])
     );
-    await runStep("Building container image locally", () => dockerStreaming(["build", "-t", image, "."]));
+    await runStep("Building container image locally", () => dockerStreaming(localDockerBuildArgs(image)));
     await runStep("Pushing container image to Artifact Registry", () => dockerStreaming(["push", image]));
   }
 

package/src/service-runtime/cloudrun/lib.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, expect, test } from "bun:test";
-import { parseDeployArgs } from "./deploy-args";
+import { localDockerBuildArgs, parseDeployArgs } from "./deploy-args";
 
 const originalBuild = process.env.SERVICE_BUILD;
 const originalBuildStrategy = process.env.SERVICE_BUILD_STRATEGY;
@@ -27,3 +27,14 @@ test("parseDeployArgs accepts build strategy from env", () => {
 
   expect(parseDeployArgs([]).build).toBe("cloudbuild");
 });
+
+test("local Docker builds target Cloud Run's runtime platform", () => {
+  expect(localDockerBuildArgs("us-west1-docker.pkg.dev/example/services/api:latest")).toEqual([
+    "build",
+    "--platform",
+    "linux/amd64",
+    "-t",
+    "us-west1-docker.pkg.dev/example/services/api:latest",
+    ".",
+  ]);
+});

package/src/service-runtime/cloudrun/lib.ts

@@ -2,7 +2,7 @@ import { intro, log, outro, spinner } from "@clack/prompts";
 import { join } from "node:path";
 import { config } from "./config";
 import { serviceRoot } from "../runtime";
-import { parseDeployArgs, type DeployArgs } from "./deploy-args";
+import { localDockerBuildArgs, parseDeployArgs, type DeployArgs } from "./deploy-args";
 
 type CommandOptions = {
   allowFailure?: boolean;
@@ -452,7 +452,7 @@ export function imageUrl(tag = imageTag()) {
   return `${artifactImageBase()}:${tag}`;
 }
 
-export { parseDeployArgs };
+export { localDockerBuildArgs, parseDeployArgs };
 
 export function parseCleanupArgs(argv: string[]): CleanupArgs {
   const parsed: CleanupArgs = {

package/src/service-runtime/workers/cli.ts

@@ -7,6 +7,7 @@ import { manualGitHubDeleteCommand } from "../../git-bootstrap";
 import { ensureAuthClient, ensureAuthResourceServer, runAuthCommand, runAuthDoctor } from "../authctl";
 import { stopLocalDev } from "../local-dev";
 import { serviceConfig } from "../runtime";
+import { isLocalDatabaseUrl, resolveCommandPath } from "./lib";
 
 const config = {
   serviceName: serviceConfig.service_id,
@@ -35,7 +36,7 @@ export async function main(argv = Bun.argv.slice(2)) {
     return runMain("Create", async () => {
       ensureAuthResourceServer();
       ensureAuthClient();
-      const databaseUrl = await resolveDatabaseUrl();
+      const databaseUrl = await resolveDatabaseUrl({ preferRemote: true });
       await applySchema(databaseUrl);
       await ensureHyperdrive(databaseUrl);
       run("wrangler", ["deploy"]);
@@ -196,10 +197,11 @@ async function confirmGitHubRepositoryDeletion(force: boolean) {
 }
 
 function run(command: string, args: string[], options: { allowFailure?: boolean; capture?: boolean } = {}) {
-  if (!Bun.which(command)) {
+  const resolvedCommand = resolveCommandPath(command);
+  if (!resolvedCommand) {
     throw new Error(`missing required command: ${command}`);
   }
-  const result = Bun.spawnSync([command, ...args], {
+  const result = Bun.spawnSync([resolvedCommand, ...args], {
     cwd: process.cwd(),
     env: process.env,
     stdin: "inherit",
@@ -254,15 +256,15 @@ async function deleteHyperdrive() {
   run("wrangler", ["hyperdrive", "delete", id, "--force"], { allowFailure: true });
 }
 
-async function resolveDatabaseUrl() {
+async function resolveDatabaseUrl(options: { preferRemote?: boolean } = {}) {
   const direct = Bun.env.DATABASE_URL?.trim();
-  if (direct) {
+  const apiKey = resolveNeonApiKey();
+  if (direct && (!options.preferRemote || !isLocalDatabaseUrl(direct) || !apiKey)) {
     return direct;
   }
 
-  const apiKey = Bun.env.NEON_API_KEY?.trim();
   if (!apiKey) {
-    throw new Error("DATABASE_URL or NEON_API_KEY is required to provision the Hyperdrive binding");
+    throw new Error("NEON_API_KEY, readable Vault Neon provider path, or non-local DATABASE_URL is required to provision the Hyperdrive binding");
   }
 
   const { neon, projectId, branchId } = await resolveNeonTarget(apiKey);
@@ -295,6 +297,32 @@ async function resolveDatabaseUrl() {
   return uri;
 }
 
+function resolveNeonApiKey() {
+  const direct = Bun.env.NEON_API_KEY?.trim();
+  if (direct) {
+    return direct;
+  }
+
+  const vault = resolveCommandPath("vault");
+  if (!vault) {
+    return "";
+  }
+
+  const mount = Bun.env.VAULT_SECRET_MOUNT?.trim() || "secret";
+  const path = Bun.env.VAULT_NEON_API_KEY_PATH?.trim() || "prod/providers/neon";
+  const field = Bun.env.VAULT_NEON_API_KEY_FIELD?.trim() || "api_key";
+  const result = Bun.spawnSync([vault, "kv", "get", `-mount=${mount}`, `-field=${field}`, path], {
+    cwd: process.cwd(),
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (!result.success || !result.stdout) {
+    return "";
+  }
+  return new TextDecoder().decode(result.stdout).trim();
+}
+
 async function resolveNeonTarget(apiKey: string) {
   const neon = createApiClient({ apiKey });
   const projectsPayload = await neon.listProjects({ limit: 100 });
@@ -462,7 +490,7 @@ async function record(
 }
 
 function checkCommand(name: string) {
-  const path = Bun.which(name);
+  const path = resolveCommandPath(name);
   if (!path) {
     throw new Error(`${name} is not installed`);
   }

package/src/service-runtime/workers/lib.test.ts

@@ -0,0 +1,28 @@
+import { expect, test } from "bun:test";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { mkdtempSync } from "node:fs";
+import { isLocalDatabaseUrl, resolveCommandPath } from "./lib";
+
+test("resolveCommandPath prefers repo-local bins", async () => {
+  const root = mkdtempSync(join(tmpdir(), "create-svc-workers-bin-"));
+  try {
+    const binDir = join(root, "node_modules", ".bin");
+    await mkdir(binDir, { recursive: true });
+    const wrangler = join(binDir, "wrangler");
+    await writeFile(wrangler, "#!/bin/sh\n");
+
+    expect(resolveCommandPath("wrangler", root)).toBe(wrangler);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("isLocalDatabaseUrl detects localhost database URLs", () => {
+  expect(isLocalDatabaseUrl("postgres://postgres:postgres@127.0.0.1:5432/app")).toBe(true);
+  expect(isLocalDatabaseUrl("postgres://postgres:postgres@localhost:5432/app")).toBe(true);
+  expect(isLocalDatabaseUrl("postgres://user:pass@ep-example.us-east-2.aws.neon.tech/app")).toBe(false);
+  expect(isLocalDatabaseUrl("not a url")).toBe(false);
+});
+

package/src/service-runtime/workers/lib.ts

@@ -0,0 +1,20 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export function resolveCommandPath(command: string, cwd = process.cwd()) {
+  const local = join(cwd, "node_modules", ".bin", command);
+  if (existsSync(local)) {
+    return local;
+  }
+  return Bun.which(command);
+}
+
+export function isLocalDatabaseUrl(value: string) {
+  try {
+    const parsed = new URL(value);
+    return ["localhost", "127.0.0.1", "::1"].includes(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+

package/templates/shared/README.md

@@ -74,6 +74,8 @@ Local provisioning intentionally prefers known-good CLIs over SDKs for Google Cl
 Cloud Run deploys build and push the container image locally by default. Use
 `service deploy --build cloudbuild` only when you explicitly want Google Cloud
 Build to build the image remotely.
+Local Docker builds target `linux/amd64` so images built on Apple Silicon run on
+Cloud Run.
 
 Authenticate `gcloud` on the machine before running provisioning commands:
 

package/templates/targets/workers/README.md

@@ -70,6 +70,9 @@ If the Hyperdrive binding id is empty, `service create` uses `DATABASE_URL`, or
 `NEON_API_KEY` to create/resolve the generated Neon database and connection URI,
 applies the waitlist schema, then runs `wrangler hyperdrive create` and writes
 the returned id back into `wrangler.toml` before deploy.
+For production create, a generated local `DATABASE_URL` pointing at localhost is
+ignored when `NEON_API_KEY` or the generated Vault Neon provider path is
+available.
 
 You can also apply the schema manually: