create-svc 0.1.1 → 0.1.3

package/src/gcp.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "bun:test";
+import { attachBillingAccount, createProject, listAccessibleProjects, listOpenBillingAccounts, type GcpApi } from "./gcp";
+
+test("listAccessibleProjects filters deleted projects and sorts by name", async () => {
+  const api: GcpApi = {
+    async listProjects() {
+      return [
+        { projectId: "b", name: "bravo" },
+        { projectId: "a", name: "alpha" },
+        { projectId: "z", name: "zulu", lifecycleState: "DELETE_REQUESTED" },
+      ];
+    },
+    async listBillingAccounts() {
+      return [];
+    },
+    async createProject() {},
+    async attachBillingAccount() {},
+  };
+
+  await expect(listAccessibleProjects(api)).resolves.toEqual([
+    { projectId: "a", name: "alpha" },
+    { projectId: "b", name: "bravo" },
+  ]);
+});
+
+test("listOpenBillingAccounts keeps only open accounts", async () => {
+  const api: GcpApi = {
+    async listProjects() {
+      return [];
+    },
+    async listBillingAccounts() {
+      return [
+        { name: "billingAccounts/2", displayName: "B", open: true },
+        { name: "billingAccounts/1", displayName: "A", open: true },
+        { name: "billingAccounts/closed", displayName: "Z", open: false },
+      ];
+    },
+    async createProject() {},
+    async attachBillingAccount() {},
+  };
+
+  await expect(listOpenBillingAccounts(api)).resolves.toEqual([
+    { name: "billingAccounts/1", displayName: "A", open: true },
+    { name: "billingAccounts/2", displayName: "B", open: true },
+  ]);
+});
+
+test("createProject and attachBillingAccount call the expected endpoints", async () => {
+  const calls: string[] = [];
+  const api: GcpApi = {
+    async listProjects() {
+      return [];
+    },
+    async listBillingAccounts() {
+      return [];
+    },
+    async createProject(projectId, name) {
+      calls.push(`create:${projectId}:${name}`);
+    },
+    async attachBillingAccount(projectId, billingAccountName) {
+      calls.push(`billing:${projectId}:${billingAccountName}`);
+    },
+  };
+
+  await createProject("anmho-test", "test", api);
+  await attachBillingAccount("anmho-test", "billingAccounts/123", api);
+
+  expect(calls).toHaveLength(2);
+  expect(calls[0]).toBe("create:anmho-test:test");
+  expect(calls[1]).toBe("billing:anmho-test:billingAccounts/123");
+});

package/src/gcp.ts

@@ -0,0 +1,97 @@
+import { CloudBillingClient } from "@google-cloud/billing";
+import { ProjectsClient } from "@google-cloud/resource-manager";
+
+export type GcpProject = {
+  projectId: string;
+  name: string;
+  lifecycleState?: string;
+};
+
+export type BillingAccount = {
+  name: string;
+  displayName: string;
+  open: boolean;
+};
+
+export type GcpApi = {
+  listProjects(): Promise<GcpProject[]>;
+  listBillingAccounts(): Promise<BillingAccount[]>;
+  createProject(projectId: string, name: string): Promise<void>;
+  attachBillingAccount(projectId: string, billingAccountName: string): Promise<void>;
+};
+
+export function createGcpApi(
+  projectsClient = new ProjectsClient(),
+  billingClient = new CloudBillingClient()
+): GcpApi {
+  return {
+    async listProjects() {
+      const projects: GcpProject[] = [];
+      for await (const project of projectsClient.searchProjectsAsync({})) {
+        projects.push({
+          projectId: project.projectId ?? "",
+          name: project.displayName ?? project.projectId ?? "",
+          lifecycleState: `${project.state ?? ""}`,
+        });
+      }
+
+      return projects
+        .filter((project) => project.projectId && project.lifecycleState !== "DELETE_REQUESTED")
+        .sort((left, right) => left.name.localeCompare(right.name));
+    },
+
+    async listBillingAccounts() {
+      const accounts: BillingAccount[] = [];
+      for await (const account of billingClient.listBillingAccountsAsync({})) {
+        accounts.push({
+          name: account.name ?? "",
+          displayName: account.displayName ?? account.name ?? "",
+          open: Boolean(account.open),
+        });
+      }
+
+      return accounts
+        .filter((account) => account.name && account.open)
+        .sort((left, right) => left.displayName.localeCompare(right.displayName));
+    },
+
+    async createProject(projectId: string, name: string) {
+      const [operation] = await projectsClient.createProject({
+        project: {
+          projectId,
+          displayName: name,
+        },
+      });
+      await operation.promise();
+    },
+
+    async attachBillingAccount(projectId: string, billingAccountName: string) {
+      await billingClient.updateProjectBillingInfo({
+        name: `projects/${projectId}`,
+        projectBillingInfo: {
+          billingAccountName,
+        },
+      });
+    },
+  };
+}
+
+export async function listAccessibleProjects(api = createGcpApi()): Promise<GcpProject[]> {
+  return (await api.listProjects())
+    .filter((project) => project.projectId && project.lifecycleState !== "DELETE_REQUESTED")
+    .sort((left, right) => left.name.localeCompare(right.name));
+}
+
+export async function listOpenBillingAccounts(api = createGcpApi()): Promise<BillingAccount[]> {
+  return (await api.listBillingAccounts())
+    .filter((account) => account.name && account.open)
+    .sort((left, right) => left.displayName.localeCompare(right.displayName));
+}
+
+export async function createProject(projectId: string, name: string, api = createGcpApi()) {
+  await api.createProject(projectId, name);
+}
+
+export async function attachBillingAccount(projectId: string, billingAccountName: string, api = createGcpApi()) {
+  await api.attachBillingAccount(projectId, billingAccountName);
+}

package/src/naming.test.ts

@@ -0,0 +1,37 @@
+import { expect, test } from "bun:test";
+import { buildGcpProjectOptions, compactDatabaseName, compactIdentifier, deriveDefaults } from "./naming";
+
+test("deriveDefaults uses the service name for project, repo, and database naming", () => {
+  expect(deriveDefaults("edge-api")).toEqual({
+    serviceName: "edge-api",
+    projectName: "edge-api",
+    projectId: "anmho-edge-api",
+    githubRepo: "anmho/edge-api",
+    cloudRunService: "edge-api",
+    neonDatabaseName: "edge_api",
+  });
+});
+
+test("compactIdentifier preserves length constraints with a stable suffix", () => {
+  const value = compactIdentifier("anmho-this-is-a-very-long-service-name-for-cloud-run", 30);
+  expect(value.length).toBeLessThanOrEqual(30);
+  expect(value.startsWith("anmho-this-is-a-very")).toBeTrue();
+});
+
+test("compactDatabaseName switches to underscores", () => {
+  expect(compactDatabaseName("preview-worker")).toBe("preview_worker");
+});
+
+test("buildGcpProjectOptions puts create-new first", () => {
+  const options = buildGcpProjectOptions("preview-worker", "anmho-preview-worker", "preview-worker", [
+    { projectId: "anmho-existing", name: "existing" },
+  ]);
+
+  expect(options[0]).toEqual({
+    label: "Create new project: preview-worker (anmho-preview-worker)",
+    mode: "create_new",
+    projectId: "anmho-preview-worker",
+    projectName: "preview-worker",
+  });
+  expect(options[1]?.mode).toBe("use_existing");
+});

package/src/naming.ts

@@ -0,0 +1,103 @@
+export const BILLING_ACCOUNT_DEFAULT = "billingAccounts/01BD2E-3A6949-8F4C84";
+export const QUOTA_PROJECT_DEFAULT = "anmho-infra-prod";
+
+export const FRAMEWORKS_BY_RUNTIME = {
+  go: ["chi", "connectrpc"],
+  bun: ["hono", "connectrpc"],
+} as const;
+
+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 slugify(value: string, maxLength = 63) {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, maxLength);
+}
+
+export function compactIdentifier(
+  value: string,
+  maxLength: number,
+  options: {
+    separator?: "-" | "_";
+    invalidPattern?: RegExp;
+    trimPattern?: RegExp;
+  } = {}
+) {
+  const separator = options.separator ?? "-";
+  const invalidPattern = options.invalidPattern ?? /[^a-z0-9-]+/g;
+  const trimPattern = options.trimPattern ?? /^-+|-+$/g;
+
+  const normalized = value
+    .toLowerCase()
+    .replace(invalidPattern, separator)
+    .replace(trimPattern, "");
+
+  if (normalized.length <= maxLength) {
+    return normalized || "service";
+  }
+
+  const hash = shortHash(normalized);
+  const head = normalized.slice(0, Math.max(1, maxLength - hash.length - 1)).replace(new RegExp(`${separator}+$`), "");
+  return `${head}${separator}${hash}`;
+}
+
+export function compactDatabaseName(serviceName: string) {
+  return compactIdentifier(serviceName.replace(/-/g, "_"), 63, {
+    separator: "_",
+    invalidPattern: /[^a-z0-9_]+/g,
+    trimPattern: /^_+|_+$/g,
+  });
+}
+
+export function deriveDefaults(serviceName: string) {
+  const normalizedServiceName = slugify(serviceName) || "my-service";
+
+  return {
+    serviceName: normalizedServiceName,
+    projectName: normalizedServiceName,
+    projectId: compactIdentifier(`anmho-${normalizedServiceName}`, 30),
+    githubRepo: `anmho/${normalizedServiceName}`,
+    cloudRunService: normalizedServiceName,
+    neonDatabaseName: compactDatabaseName(normalizedServiceName),
+  };
+}
+
+export function buildCreateProjectLabel(serviceName: string, projectId: string) {
+  return `Create new project: ${serviceName} (${projectId})`;
+}
+
+export function buildGcpProjectOptions(
+  serviceName: string,
+  projectId: string,
+  projectName: string,
+  projects: Array<{ projectId: string; name: string }>
+) {
+  return [
+    {
+      label: buildCreateProjectLabel(serviceName, projectId),
+      mode: "create_new" as const,
+      projectId,
+      projectName,
+    },
+    ...projects.map((project) => ({
+      label: `Use existing project: ${project.name} (${project.projectId})`,
+      mode: "use_existing" as const,
+      projectId: project.projectId,
+      projectName: project.name,
+    })),
+  ];
+}
+
+function shortHash(value: string) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).slice(0, 8);
+}

package/src/neon.test.ts

@@ -0,0 +1,48 @@
+import { expect, test } from "bun:test";
+import { discoverNeonDefaults, listBranches, listProjects, type NeonApi } from "./neon";
+
+test("listProjects and listBranches sort results", async () => {
+  const api: NeonApi = {
+    async listProjects() {
+      return [
+        { id: "p1", name: "alpha" },
+        { id: "p2", name: "zulu" },
+      ];
+    },
+    async listBranches() {
+      return [
+        { id: "b1", name: "main" },
+        { id: "b2", name: "zeta" },
+      ];
+    },
+  };
+
+  await expect(listProjects(api)).resolves.toEqual([
+    { id: "p1", name: "alpha" },
+    { id: "p2", name: "zulu" },
+  ]);
+  await expect(listBranches("p1", api)).resolves.toEqual([
+    { id: "b1", name: "main" },
+    { id: "b2", name: "zeta" },
+  ]);
+});
+
+test("discoverNeonDefaults prefers the main branch", async () => {
+  const api: NeonApi = {
+    async listProjects() {
+      return [{ id: "project-1", name: "shared" }];
+    },
+    async listBranches() {
+      return [
+        { id: "branch-2", name: "feature" },
+        { id: "branch-1", name: "main" },
+      ];
+    },
+  };
+
+  await expect(discoverNeonDefaults("dns-api", api)).resolves.toEqual({
+    projectId: "project-1",
+    baseBranchId: "branch-1",
+    baseBranchName: "main",
+  });
+});

package/src/neon.ts

@@ -0,0 +1,76 @@
+import { createApiClient } from "@neondatabase/api-client";
+
+export type NeonProject = {
+  id: string;
+  name: string;
+};
+
+export type NeonBranch = {
+  id: string;
+  name: string;
+};
+
+export type NeonApi = {
+  listProjects(): Promise<NeonProject[]>;
+  listBranches(projectId: string): Promise<NeonBranch[]>;
+};
+
+export function createNeonApi(apiKey = process.env.NEON_API_KEY): NeonApi {
+  if (!apiKey?.trim()) {
+    throw new Error("NEON_API_KEY is not set");
+  }
+
+  const client = createApiClient({ apiKey });
+
+  return {
+    async listProjects() {
+      const payload = await client.listProjects({ limit: 100 });
+      return (payload.projects ?? [])
+        .map((project) => ({
+          id: project.id ?? "",
+          name: project.name ?? project.id ?? "",
+        }))
+        .filter((project) => project.id)
+        .sort((left, right) => left.name.localeCompare(right.name));
+    },
+
+    async listBranches(projectId: string) {
+      const payload = await client.listProjectBranches({ projectId });
+      return (payload.branches ?? [])
+        .map((branch) => ({
+          id: branch.id ?? "",
+          name: branch.name ?? branch.id ?? "",
+        }))
+        .filter((branch) => branch.id)
+        .sort((left, right) => left.name.localeCompare(right.name));
+    },
+  };
+}
+
+export async function listProjects(api = createNeonApi()): Promise<NeonProject[]> {
+  return api.listProjects();
+}
+
+export async function listBranches(projectId: string, api = createNeonApi()): Promise<NeonBranch[]> {
+  return api.listBranches(projectId);
+}
+
+export async function discoverNeonDefaults(serviceName: string, api = createNeonApi()) {
+  const projects = await listProjects(api);
+  const project = projects[0];
+  if (!project) {
+    throw new Error(`No Neon projects are available for ${serviceName}`);
+  }
+
+  const branches = await listBranches(project.id, api);
+  const branch = branches.find((candidate) => candidate.name === "main") ?? branches[0];
+  if (!branch) {
+    throw new Error(`No Neon branches are available in project ${project.id}`);
+  }
+
+  return {
+    projectId: project.id,
+    baseBranchId: branch.id,
+    baseBranchName: branch.name,
+  };
+}

package/src/post-scaffold.ts

@@ -0,0 +1,77 @@
+import type { ScaffoldConfig } from "./scaffold";
+
+type CommandOptions = {
+  cwd: string;
+  allowFailure?: boolean;
+  input?: string;
+};
+
+type CommandResult = {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+};
+
+const decoder = new TextDecoder();
+
+export async function runPostScaffoldFlow(config: ScaffoldConfig, cwd: string) {
+  if (config.createGithubRepo) {
+    initializeRepository(cwd);
+    createGitHubRepo(config, cwd);
+  }
+
+  if (config.autoDeploy) {
+    run("bun", ["run", "bootstrap"], { cwd });
+    run("bun", ["run", "deploy"], { cwd });
+    return { message: "Repository initialized, pushed, and first deploy started" };
+  }
+
+  return { message: "Repository initialized" };
+}
+
+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 });
+}
+
+function requireCommand(name: string) {
+  if (!Bun.which(name)) {
+    throw new Error(`missing required command for post-scaffold automation: ${name}`);
+  }
+}
+
+function run(command: string, args: string[], options: CommandOptions): CommandResult {
+  const result = Bun.spawnSync([command, ...args], {
+    cwd: options.cwd,
+    env: process.env,
+    stdin: options.input,
+    stdout: options.allowFailure ? "pipe" : "inherit",
+    stderr: options.allowFailure ? "pipe" : "inherit",
+  });
+
+  const stdout = result.stdout ? decoder.decode(result.stdout).trim() : "";
+  const stderr = result.stderr ? decoder.decode(result.stderr).trim() : "";
+
+  if (!result.success && !options.allowFailure) {
+    throw new Error([`command failed: ${command} ${args.join(" ")}`, stdout, stderr].filter(Boolean).join("\n"));
+  }
+
+  return {
+    success: result.success,
+    stdout,
+    stderr,
+  };
+}

package/src/scaffold.test.ts

@@ -1,46 +1,81 @@
 import { expect, test } from "bun:test";
-import { mkdtemp, readdir } from "node:fs/promises";
+import { mkdtemp } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { scaffoldProject } from "./scaffold";
+import { scaffoldProject, type ScaffoldConfig } from "./scaffold";
 
-test("scaffolds the default project shape", async () => {
-  const root = await mkdtemp(join(tmpdir(), "create-service-"));
-  const generatedRoot = join(root, "dns-api");
-
-  await scaffoldProject({
-    directory: generatedRoot,
+function baseConfig(overrides: Partial<ScaffoldConfig> = {}): ScaffoldConfig {
+  return {
+    directory: "svc",
     serviceName: "dns-api",
-    modulePath: "github.com/anmho/dns-api",
-    projectId: "anmho-infra-prod",
+    runtime: "go",
+    framework: "chi",
     region: "us-west1",
+    gcpProjectMode: "create_new",
+    gcpProject: "anmho-dns-api",
+    gcpProjectName: "dns-api",
+    billingAccount: "billingAccounts/01BD2E-3A6949-8F4C84",
+    quotaProjectId: "anmho-infra-prod",
     githubRepo: "anmho/dns-api",
-    vaultAddr: "https://vault.anmho.com",
-    vaultSecretPath: "provider/cloudflare-api-token",
-    vaultSecretKey: "value",
-    cloudflareZoneId: "893c2371cc222826de6e00583f4902ea",
-    bufModule: "buf.build/anmho/dns-api",
+    githubVisibility: "public",
+    createGithubRepo: true,
+    autoDeploy: false,
+    neonProjectId: "project-123",
+    neonBaseBranchId: "br-main",
+    neonBaseBranchName: "main",
+    neonDatabaseName: "dns_api",
     generatorRoot: join(import.meta.dir, ".."),
-  });
+    ...overrides,
+  };
+}
+
+test("scaffolds all runtime/framework variants with shared cloudrun config", async () => {
+  const cases: Array<Pick<ScaffoldConfig, "runtime" | "framework">> = [
+    { runtime: "go", framework: "chi" },
+    { runtime: "go", framework: "connectrpc" },
+    { runtime: "bun", framework: "hono" },
+    { runtime: "bun", framework: "connectrpc" },
+  ];
+
+  for (const variant of cases) {
+    const root = await mkdtemp(join(tmpdir(), "create-svc-"));
+    const generatedRoot = join(root, `${variant.runtime}-${variant.framework}`);
+
+    await scaffoldProject(
+      baseConfig({
+        directory: generatedRoot,
+        runtime: variant.runtime,
+        framework: variant.framework,
+      })
+    );
 
-  const entries = await readdir(generatedRoot);
+    const configScript = await Bun.file(join(generatedRoot, "scripts", "cloudrun", "config.ts")).text();
+    expect(configScript).toContain(`runtime: "${variant.runtime}"`);
+    expect(configScript).toContain(`framework: "${variant.framework}"`);
+    expect(configScript).toContain('mode: "create_new"');
+    expect(configScript).toContain('quotaProjectId: "anmho-infra-prod"');
+    expect(configScript).toContain('projectId: "project-123"');
+    expect(configScript).toContain('previewBranchPrefix: "dns-api-pr"');
 
-  expect(entries).toContain("cmd");
-  expect(entries).toContain("gen");
-  expect(entries).toContain("internal");
-  expect(entries).toContain("scripts");
-  expect(entries).toContain("service.yaml");
+    const deployScript = await Bun.file(join(generatedRoot, "scripts", "cloudrun", "lib.ts")).text();
+    expect(deployScript).toContain('--billing-project", config.project.quotaProjectId');
 
-  const manifest = await Bun.file(join(generatedRoot, "service.yaml")).text();
-  expect(manifest).toContain("serving.knative.dev/v1");
-  expect(manifest.includes("{{")).toBeFalse();
+    const workflow = await Bun.file(join(generatedRoot, ".github", "workflows", "personal.yml")).text();
+    expect(workflow).toContain("workflow_dispatch");
+    expect(workflow).toContain("--environment personal");
 
-  const deployScript = await Bun.file(join(generatedRoot, "scripts", "cloudrun", "deploy.ts")).text();
-  expect(deployScript).toContain('"run", "services", "replace"');
+    if (variant.runtime === "go") {
+      const goMod = await Bun.file(join(generatedRoot, "go.mod")).text();
+      expect(goMod).toContain("connectrpc.com/connect");
 
-  const configScript = await Bun.file(join(generatedRoot, "scripts", "cloudrun", "config.ts")).text();
-  expect(configScript).toContain('serviceName: "dns-api"');
+      const mainGo = await Bun.file(join(generatedRoot, "cmd", "server", "main.go")).text();
+      expect(mainGo).toContain("NewDNSService");
+    } else {
+      const packageJson = await Bun.file(join(generatedRoot, "package.json")).text();
+      expect(packageJson).toContain('"bootstrap": "bun run ./scripts/cloudrun/bootstrap.ts"');
 
-  const protoStub = await Bun.file(join(generatedRoot, "gen", "dns", "v1", "dns.pb.go")).text();
-  expect(protoStub).toContain("package dnsv1");
+      const entrypoint = await Bun.file(join(generatedRoot, "src", "index.ts")).text();
+      expect(entrypoint).toContain(variant.framework === "hono" ? "Hono" : "rpc.example.v1.Service/Ping");
+    }
+  }
 });