create-svc 0.1.9 → 0.1.11

package/src/git-bootstrap.ts

@@ -0,0 +1,110 @@
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+
+export type GitBootstrapConfig = {
+  enabled: boolean;
+  owner: string;
+  repository: string;
+};
+
+export type GitBootstrapResult =
+  | { status: "disabled" }
+  | { status: "skipped-existing-worktree"; root: string }
+  | { status: "created"; url: string };
+
+export function buildGitBootstrapConfig(serviceName: string, noGit: boolean | undefined): GitBootstrapConfig {
+  return {
+    enabled: !noGit,
+    owner: "anmho",
+    repository: serviceName,
+  };
+}
+
+export async function bootstrapGitHubRepository(targetDir: string, config: GitBootstrapConfig): Promise<GitBootstrapResult> {
+  if (!config.enabled) {
+    return { status: "disabled" };
+  }
+
+  const existingRoot = findExistingGitWorktree(targetDir);
+  if (existingRoot) {
+    return { status: "skipped-existing-worktree", root: existingRoot };
+  }
+
+  run(["git", "--version"], targetDir, "git is required to initialize the generated repository");
+  run(["gh", "--version"], targetDir, "GitHub CLI `gh` is required to create the generated repository");
+  run(["gh", "auth", "status"], targetDir, "Authenticate GitHub CLI with `gh auth login` before creating the repository");
+
+  run(["git", "init", "-b", "main"], targetDir);
+  run(["git", "add", "."], targetDir);
+
+  if (hasStagedChanges(targetDir)) {
+    run(["git", "commit", "-m", "Initial commit"], targetDir);
+  }
+
+  const repository = `${config.owner}/${config.repository}`;
+  run(["gh", "repo", "create", repository, "--private", "--source", ".", "--remote", "origin", "--push"], targetDir);
+
+  return {
+    status: "created",
+    url: `https://github.com/${repository}`,
+  };
+}
+
+export function commitAndPushGeneratedArtifacts(targetDir: string, message: string) {
+  run(["git", "add", "."], targetDir);
+  if (!hasStagedChanges(targetDir)) {
+    return { committed: false };
+  }
+  run(["git", "commit", "-m", message], targetDir);
+  run(["git", "push"], targetDir);
+  return { committed: true };
+}
+
+export function findExistingGitWorktree(targetDir: string) {
+  const cwd = existingPath(targetDir);
+  const result = Bun.spawnSync(["git", "-C", cwd, "rev-parse", "--show-toplevel"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (result.exitCode !== 0) {
+    return undefined;
+  }
+  return result.stdout.toString().trim() || undefined;
+}
+
+function existingPath(path: string): string {
+  if (existsSync(path)) {
+    return path;
+  }
+
+  const parent = dirname(path);
+  if (parent === path) {
+    return path;
+  }
+
+  return existingPath(parent);
+}
+
+function hasStagedChanges(cwd: string) {
+  const result = Bun.spawnSync(["git", "diff", "--cached", "--quiet"], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return result.exitCode === 1;
+}
+
+function run(command: string[], cwd: string, message?: string) {
+  const result = Bun.spawnSync(command, {
+    cwd,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "pipe",
+  });
+  if (result.exitCode === 0) {
+    return;
+  }
+
+  const detail = result.stderr.toString().trim();
+  throw new Error([message, `Command failed: ${command.join(" ")}`, detail].filter(Boolean).join("\n"));
+}

package/src/naming.test.ts

@@ -1,14 +1,17 @@
 import { expect, test } from "bun:test";
-import { buildGcpProjectOptions, compactDatabaseName, compactIdentifier, deriveDefaults } from "./naming";
+import { buildGcpProjectOptions, compactDatabaseName, compactIdentifier, deriveDefaults, deriveLocalPostgresPort } from "./naming";
 
 test("deriveDefaults uses the service name for project, repo, and database naming", () => {
   expect(deriveDefaults("edge-api")).toEqual({
+    serviceId: "edge-api",
     serviceName: "edge-api",
     projectName: "edge-api",
     projectId: "anmho-edge-api",
-    githubRepo: "anmho/edge-api",
     cloudRunService: "edge-api",
     neonDatabaseName: "edge_api",
+    localDatabasePort: deriveLocalPostgresPort("edge-api"),
+    apiHostname: "api.edge-api.anmho.com",
+    modulePath: "example.com/edge-api",
   });
 });
 

package/src/naming.ts

@@ -1,6 +1,10 @@
 export const BILLING_ACCOUNT_DEFAULT = "billingAccounts/01BD2E-3A6949-8F4C84";
 export const QUOTA_PROJECT_DEFAULT = "anmho-infra-prod";
 
+export const DEPLOY_TARGETS = ["cloudrun", "workers"] as const;
+
+export type DeployTarget = (typeof DEPLOY_TARGETS)[number];
+
 export const FRAMEWORKS_BY_RUNTIME = {
   go: ["chi", "connectrpc"],
   bun: ["hono", "connectrpc"],
@@ -10,6 +14,24 @@ export type Runtime = keyof typeof FRAMEWORKS_BY_RUNTIME;
 export type Framework = (typeof FRAMEWORKS_BY_RUNTIME)[Runtime][number];
 export type GcpProjectMode = "create_new" | "use_existing";
 
+export function parseDeployTarget(value: string): DeployTarget {
+  if (DEPLOY_TARGETS.includes(value as DeployTarget)) {
+    return value as DeployTarget;
+  }
+
+  throw new Error(`Unknown target: ${value}`);
+}
+
+export function frameworksForTargetRuntime(target: DeployTarget, runtime: Runtime): readonly Framework[] {
+  if (target === "workers") {
+    if (runtime === "bun") {
+      return ["hono"];
+    }
+    return [];
+  }
+  return FRAMEWORKS_BY_RUNTIME[runtime];
+}
+
 export function slugify(value: string, maxLength = 63) {
   return value
     .trim()
@@ -54,16 +76,25 @@ export function compactDatabaseName(serviceName: string) {
   });
 }
 
+export function deriveLocalPostgresPort(serviceName: string) {
+  const normalized = slugify(serviceName) || "my-service";
+  const hash = Number.parseInt(shortHash(normalized).slice(0, 4), 16);
+  return String(55000 + (hash % 1000));
+}
+
 export function deriveDefaults(serviceName: string) {
   const normalizedServiceName = slugify(serviceName) || "my-service";
 
   return {
+    serviceId: normalizedServiceName,
     serviceName: normalizedServiceName,
     projectName: normalizedServiceName,
     projectId: compactIdentifier(`anmho-${normalizedServiceName}`, 30),
-    githubRepo: `anmho/${normalizedServiceName}`,
     cloudRunService: normalizedServiceName,
     neonDatabaseName: compactDatabaseName(normalizedServiceName),
+    localDatabasePort: deriveLocalPostgresPort(normalizedServiceName),
+    apiHostname: `api.${normalizedServiceName}.anmho.com`,
+    modulePath: `example.com/${normalizedServiceName}`,
   };
 }
 

package/src/neon.ts

@@ -21,25 +21,27 @@ export function createNeonApi(apiKey = process.env.NEON_API_KEY): NeonApi {
     async listProjects() {
       const client = createApiClient({ apiKey: (apiKey?.trim() || (await resolveNeonApiKey())) });
       const payload = await client.listProjects({ limit: 100 });
-      return (payload.projects ?? [])
-        .map((project) => ({
+      const projects = ((payload.data as { projects?: Array<{ id?: string; name?: string }> } | undefined)?.projects ?? []);
+      return projects
+        .map((project: { id?: string; name?: string }) => ({
           id: project.id ?? "",
           name: project.name ?? project.id ?? "",
         }))
-        .filter((project) => project.id)
-        .sort((left, right) => left.name.localeCompare(right.name));
+        .filter((project: NeonProject) => Boolean(project.id))
+        .sort((left: NeonProject, right: NeonProject) => left.name.localeCompare(right.name));
     },
 
     async listBranches(projectId: string) {
       const client = createApiClient({ apiKey: (apiKey?.trim() || (await resolveNeonApiKey())) });
       const payload = await client.listProjectBranches({ projectId });
-      return (payload.branches ?? [])
-        .map((branch) => ({
+      const branches = ((payload.data as { branches?: Array<{ id?: string; name?: string }> } | undefined)?.branches ?? []);
+      return branches
+        .map((branch: { id?: string; name?: string }) => ({
           id: branch.id ?? "",
           name: branch.name ?? branch.id ?? "",
         }))
-        .filter((branch) => branch.id)
-        .sort((left, right) => left.name.localeCompare(right.name));
+        .filter((branch: NeonBranch) => Boolean(branch.id))
+        .sort((left: NeonBranch, right: NeonBranch) => left.name.localeCompare(right.name));
     },
   };
 }

package/src/post-scaffold.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { buildPostScaffoldCommands } from "./post-scaffold";
+
+describe("buildPostScaffoldCommands", () => {
+  test("runs create and deploy for HTTP services", () => {
+    expect(buildPostScaffoldCommands({ framework: "hono" })).toEqual([
+      { command: "bun", args: ["run", "service", "--", "create"] },
+      { command: "bun", args: ["run", "service", "--", "deploy"] },
+    ]);
+  });
+
+  test("builds SDK artifacts before create and deploy for ConnectRPC services", () => {
+    expect(buildPostScaffoldCommands({ framework: "connectrpc" })).toEqual([
+      { command: "bun", args: ["run", "service", "--", "sdk", "build"] },
+      { command: "bun", args: ["run", "service", "--", "create"] },
+      { command: "bun", args: ["run", "service", "--", "deploy"] },
+    ]);
+  });
+});

package/src/post-scaffold.ts

@@ -12,40 +12,32 @@ type CommandResult = {
   stderr: string;
 };
 
+type PostScaffoldCommand = {
+  command: string;
+  args: string[];
+};
+
 const decoder = new TextDecoder();
+const encoder = new TextEncoder();
 
 export async function runPostScaffoldFlow(config: ScaffoldConfig, cwd: string) {
-  if (config.createGithubRepo) {
-    initializeRepository(cwd);
-    createGitHubRepo(config, cwd);
-  }
-
   if (config.autoDeploy) {
     installProjectDependencies(cwd);
-    run("bun", ["run", "bootstrap"], { cwd });
-    run("bun", ["run", "deploy"], { cwd });
-    return { message: "Repository initialized, pushed, and first deploy started" };
+    for (const command of buildPostScaffoldCommands(config)) {
+      run(command.command, command.args, { cwd });
+    }
+    return { message: "Dependencies installed, service created, and service deployed" };
   }
 
-  return { message: "Repository initialized" };
+  return { message: "Backend package generated" };
 }
 
-function initializeRepository(cwd: string) {
-  requireCommand("git");
-  run("git", ["init", "-b", "main"], { cwd, allowFailure: true });
-  run("git", ["add", "."], { cwd });
-  run("git", ["commit", "--allow-empty", "-m", "Initial commit"], { cwd, allowFailure: true });
-}
-
-function createGitHubRepo(config: ScaffoldConfig, cwd: string) {
-  requireCommand("gh");
-
-  const existing = run("gh", ["repo", "view", config.githubRepo], { cwd, allowFailure: true });
-  if (!existing.success) {
-    run("gh", ["repo", "create", config.githubRepo, `--${config.githubVisibility}`, "--source=.", "--remote=origin"], { cwd });
-  }
-
-  run("git", ["push", "-u", "origin", "main"], { cwd, allowFailure: true });
+export function buildPostScaffoldCommands(config: Pick<ScaffoldConfig, "framework">): PostScaffoldCommand[] {
+  return [
+    ...(config.framework === "connectrpc" ? [{ command: "bun", args: ["run", "service", "--", "sdk", "build"] }] : []),
+    { command: "bun", args: ["run", "service", "--", "create"] },
+    { command: "bun", args: ["run", "service", "--", "deploy"] },
+  ];
 }
 
 function installProjectDependencies(cwd: string) {
@@ -63,7 +55,7 @@ function run(command: string, args: string[], options: CommandOptions): CommandR
   const result = Bun.spawnSync([command, ...args], {
     cwd: options.cwd,
     env: process.env,
-    stdin: options.input,
+    stdin: options.input === undefined ? undefined : encoder.encode(options.input),
     stdout: options.allowFailure ? "pipe" : "inherit",
     stderr: options.allowFailure ? "pipe" : "inherit",
   });

package/src/profiles.ts

@@ -0,0 +1,25 @@
+export const PROFILES = ["microservice"] as const;
+
+export type Profile = (typeof PROFILES)[number];
+
+export function parseProfile(value: string): Profile {
+  if (PROFILES.includes(value as Profile)) {
+    return value as Profile;
+  }
+
+  if (value === "app") {
+    throw new Error(
+      "The app profile has moved out of create-service. Use the private create-app template repositories instead."
+    );
+  }
+
+  throw new Error(`Unknown profile: ${value}`);
+}
+
+export function exampleForProfile(_profile: Profile) {
+  return {
+    kind: "microservice",
+    domain: "waitlist",
+    label: "waitlist/launch service",
+  };
+}