feat(create-vitnode): Add option git initialization during project setup

Author: aXenDeveloper

packages/create-vitnode-app/README.md

@@ -75,6 +75,7 @@ plugins: [myPlugin()]
 | `--package-manager` | Choose `npm` or `pnpm` for the generated project. |
 | `--eslint` | Include ESLint and Prettier configuration. |
 | `--skip-install` | Skip dependency installation after scaffolding. |
+| `--skip-git` | Skip initializing a git repository (created on `main` after install). |
 | `--mode` | Choose `singleApp`, `apiMonorepo`, or `onlyApi`. |
 | `--monorepo` | Create a workspace layout for plugins and multiple applications. |
 | `--docker` | Include local Docker services. |

packages/create-vitnode-app/src/create/create-vitnode.ts

@@ -12,18 +12,30 @@ import { fileURLToPath } from "node:url";
 import ora from "ora";
 import color from "picocolors";
 
+import type { InitGitResult } from "../helpers/init-git.js";
 import type { CreateCliReturn } from "../questions.js";
 
+import { initGitRepository } from "../helpers/init-git.js";
 import { generateMigrationsVitnode } from "../helpers/init-vitnode.js";
 import { installDependencies } from "../helpers/install-dependencies.js";
 import { isFolderEmpty } from "../helpers/is-folder-empty.js";
 import { createPackageJSON } from "./create-package-json.js";
 
+const GIT_WARNINGS: Record<Exclude<InitGitResult, "created">, string> = {
+  "already-in-repository":
+    "Skipped git setup - the project already lives inside a git repository.",
+  failed:
+    'Could not initialize a git repository. Run "git init" in the project yourself once git is configured.',
+  "git-unavailable":
+    'Git is not installed, so no repository was created. Run "git init" in the project after installing git.',
+};
+
 export const createVitNode = async ({
   root,
   appName,
   packageManager,
   eslint,
+  git,
   install,
   docker,
   mode,
@@ -323,7 +335,17 @@ export const createVitNode = async ({
     }
   }
 
+  let gitResult: InitGitResult | undefined;
+  if (git) {
+    spinner.text = "Initializing git repository...";
+    gitResult = await initGitRepository({ root });
+  }
+
   spinner.succeed(
     `${color.green("Success!")} Created ${color.cyan(appName)} at ${color.cyan(root)}`,
   );
+
+  if (gitResult && gitResult !== "created") {
+    console.log(color.yellow(GIT_WARNINGS[gitResult]));
+  }
 };

packages/create-vitnode-app/src/helpers/init-git.test.ts

@@ -0,0 +1,56 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { initGitRepository } from "./init-git.js";
+
+const git = (args: string[], cwd: string): string =>
+  execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
+
+describe("initGitRepository", () => {
+  let root = "";
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "create-vitnode-git-"));
+    await writeFile(join(root, "package.json"), "{}\n");
+    process.env.GIT_AUTHOR_NAME = "VitNode";
+    process.env.GIT_AUTHOR_EMAIL = "test@vitnode.com";
+    process.env.GIT_COMMITTER_NAME = "VitNode";
+    process.env.GIT_COMMITTER_EMAIL = "test@vitnode.com";
+  });
+
+  afterEach(async () => {
+    await rm(root, { force: true, recursive: true });
+  });
+
+  it("creates a repository on the main branch with an initial commit", async () => {
+    await expect(initGitRepository({ root })).resolves.toBe("created");
+
+    expect(existsSync(join(root, ".git"))).toBe(true);
+    expect(git(["rev-parse", "--abbrev-ref", "HEAD"], root)).toBe("main");
+    expect(git(["rev-list", "--count", "HEAD"], root)).toBe("1");
+    expect(git(["show", "--name-only", "--format=", "HEAD"], root)).toContain(
+      "package.json",
+    );
+  });
+
+  it("honours a custom branch name", async () => {
+    await expect(initGitRepository({ root, branch: "trunk" })).resolves.toBe(
+      "created",
+    );
+
+    expect(git(["rev-parse", "--abbrev-ref", "HEAD"], root)).toBe("trunk");
+  });
+
+  it("leaves an existing repository alone", async () => {
+    git(["init"], root);
+
+    await expect(initGitRepository({ root })).resolves.toBe(
+      "already-in-repository",
+    );
+    expect(git(["rev-list", "--count", "--all"], root)).toBe("0");
+  });
+});

packages/create-vitnode-app/src/helpers/init-git.ts

@@ -0,0 +1,66 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+
+import { spawnCommand } from "./spawn-command.js";
+
+export type InitGitResult =
+  "already-in-repository" | "created" | "failed" | "git-unavailable";
+
+export const DEFAULT_GIT_BRANCH = "main";
+
+const runGit = async (args: string[], cwd: string): Promise<boolean> =>
+  new Promise<boolean>(resolve => {
+    const child = spawnCommand("git", args, { cwd, stdio: "ignore" });
+
+    child.on("error", () => {
+      resolve(false);
+    });
+    child.on("close", code => {
+      resolve(code === 0);
+    });
+  });
+
+export const initGitRepository = async ({
+  root,
+  branch = DEFAULT_GIT_BRANCH,
+  commitMessage = "Initial commit from Create VitNode App",
+}: {
+  branch?: string;
+  commitMessage?: string;
+  root: string;
+}): Promise<InitGitResult> => {
+  if (!(await runGit(["--version"], root))) {
+    return "git-unavailable";
+  }
+
+  if (await runGit(["rev-parse", "--is-inside-work-tree"], root)) {
+    return "already-in-repository";
+  }
+
+  const removeGitDirectory = async () => {
+    await rm(join(root, ".git"), { force: true, recursive: true });
+  };
+
+  const initialized =
+    (await runGit(["init", "--initial-branch", branch], root)) ||
+    ((await runGit(["init"], root)) &&
+      (await runGit(["symbolic-ref", "HEAD", `refs/heads/${branch}`], root)));
+
+  if (!initialized) {
+    await removeGitDirectory();
+
+    return "failed";
+  }
+
+  const committed =
+    (await runGit(["add", "-A"], root)) &&
+    (await runGit(["commit", "-m", commitMessage], root));
+
+  if (!committed) {
+    await removeGitDirectory();
+
+    return "failed";
+  }
+
+  return "created";
+};

packages/create-vitnode-app/src/index.ts

@@ -54,6 +54,10 @@ const init = async () => {
     "--skip-install",
     "Skip installing packages after initializing the project.",
   );
+  program.option(
+    "--skip-git",
+    "Skip initializing a git repository in the project.",
+  );
   program.addOption(
     new Option(
       "--mode <mode>",

packages/create-vitnode-app/src/questions.ts

@@ -8,6 +8,7 @@ import { getAvailablePackageManagers } from "./helpers/get-available-package-man
 export interface CreateCliReturn {
   docker?: boolean;
   eslint: boolean;
+  git: boolean;
   install: boolean;
   mode: "apiMonorepo" | "onlyApi" | "singleApp";
   monorepo?: boolean;
@@ -21,6 +22,7 @@ export const createQuestionsCli = async (
   const options: CreateCliReturn = {
     packageManager: optionsFromProgram.packageManager,
     eslint: optionsFromProgram.eslint,
+    git: !optionsFromProgram.skipGit,
     install: !optionsFromProgram.skipInstall,
     docker: optionsFromProgram.docker,
     mode: optionsFromProgram.mode,
@@ -99,6 +101,13 @@ export const createQuestionsCli = async (
     });
   }
 
+  if (optionsFromProgram.skipGit === undefined) {
+    options.git = await confirm({
+      message: `Would you like to initialize a ${color.blue("Git repository")}?`,
+      default: true,
+    });
+  }
+
   if (optionsFromProgram.skipInstall === undefined) {
     options.install = await confirm({
       message: `Would you like to ${color.blue("Install dependencies")}?`,