nuxt-bake 1.0.1

package/templates/with-tests/nuxt.config.ts

@@ -0,0 +1,31 @@
+import tailwindcss from "@tailwindcss/vite"
+
+export default defineNuxtConfig({
+  modules: [
+    "@nuxt/fonts",
+    "@nuxt/icon",
+    "@nuxtjs/color-mode",
+    "@nuxt/test-utils/module",
+    "@pinia/nuxt",
+    "nuxt-auth-utils",
+  ],
+  runtimeConfig: {
+    public: {
+      baseUrl: process.env.NUXT_PUBLIC_BASE_URL,
+    },
+  },
+  vite: {
+    plugins: [tailwindcss() as any],
+  },
+  css: ["~/assets/styles.css"],
+  colorMode: {
+    classSuffix: "",
+    preference: "system",
+    fallback: "light",
+    storageKey: "nuxt-color-mode",
+  },
+  icon: {
+    mode: "svg",
+    clientBundle: { scan: true },
+  },
+})

package/templates/with-tests/playwright.config.ts

@@ -0,0 +1,13 @@
+import type { ConfigOptions } from "@nuxt/test-utils/playwright"
+import { fileURLToPath } from "node:url"
+import { defineConfig } from "@playwright/test"
+
+export default defineConfig<ConfigOptions>({
+  outputDir: "./tests/e2e/test-results",
+  testDir: "./tests/e2e",
+  use: {
+    nuxt: {
+      rootDir: fileURLToPath(new URL(".", import.meta.url)),
+    },
+  },
+})

package/templates/with-tests/tests/e2e/e2e-hello.test.ts

@@ -0,0 +1,8 @@
+import { expect, test } from "@nuxt/test-utils/playwright"
+
+test.setTimeout(60000) // 60 seconds
+
+test("home page displays main heading", async ({ page, goto }) => {
+  await goto("/", { waitUntil: "load" }) // less strict than hydration
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("Nuxt Bake - with Testing Setup")
+})

package/templates/with-tests/tests/hello.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, it } from "vitest"
+
+describe("basic math", () => {
+  it("adds numbers", () => {
+    expect(1 + 1).toBe(2)
+  })
+})

package/templates/with-tests/vitest.config.ts

@@ -0,0 +1,16 @@
+import { defineVitestConfig } from "@nuxt/test-utils/config"
+
+export default defineVitestConfig({
+  test: {
+    globals: true,
+    environment: "happy-dom",
+    setupFiles: "./tests/setup.ts",
+    exclude: ["templates/**", "node_modules/**"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html"],
+      include: ["src/**/*.{ts,js}"],
+      exclude: ["**/*.d.ts", "tests/**", "node_modules/**"],
+    },
+  },
+})

package/tests/git.test.ts

@@ -0,0 +1,54 @@
+import { spawnSync } from "node:child_process"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import * as git from "../src/helpers/git"
+
+vi.mock("node:child_process")
+
+// Suppress console.error for all tests to avoid confusion
+let consoleSpy: ReturnType<typeof vi.spyOn>
+beforeEach(() => {
+  consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+})
+afterEach(() => {
+  consoleSpy.mockRestore()
+})
+
+describe("cloneRepoToTemp", () => {
+  it("should clone repo successfully", () => {
+    vi.mocked(spawnSync).mockReturnValue({ status: 0, error: null } as any)
+    const tmpDir = git.cloneRepoToTemp("fake-repo-url")
+    expect(tmpDir).toContain("nuxt-bake-")
+  })
+
+  it("should return null if clone fails with non-zero status", () => {
+    vi.mocked(spawnSync).mockReturnValue({ status: 1, error: null } as any)
+    const tmpDir = git.cloneRepoToTemp("fake-repo-url")
+    expect(tmpDir).toBeNull()
+  })
+
+  it("should return null if clone fails with error object", () => {
+    vi.mocked(spawnSync).mockReturnValue({ status: 0, error: new Error("git error") } as any)
+    const tmpDir = git.cloneRepoToTemp("fake-repo-url")
+    expect(tmpDir).toBeNull()
+  })
+})
+
+describe("promptAndInitGit", () => {
+  it("should log error if git init fails with error", () => {
+    vi.mocked(spawnSync).mockReturnValue({ status: 0, error: new Error("init error") } as any)
+    git.promptAndInitGit("/fake/dir")
+    expect(consoleSpy).toHaveBeenCalledWith("Failed to initialize Git:", "init error")
+  })
+
+  it("should log error if git init fails with non-zero status", () => {
+    vi.mocked(spawnSync).mockReturnValue({ status: 1, error: null } as any)
+    git.promptAndInitGit("/fake/dir")
+    expect(consoleSpy).toHaveBeenCalledWith("Git init failed")
+  })
+
+  it("should succeed silently if git init succeeds", () => {
+    vi.mocked(spawnSync).mockReturnValue({ status: 0, error: null } as any)
+    git.promptAndInitGit("/fake/dir")
+    expect(consoleSpy).not.toHaveBeenCalled()
+  })
+})

package/tests/package-manager.test.ts

@@ -0,0 +1,100 @@
+import { execSync } from "node:child_process"
+import fs from "fs-extra"
+import inquirer from "inquirer"
+import ora from "ora"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import * as pkgMgr from "../src/helpers/package-manager"
+
+vi.mock("fs-extra")
+vi.mock("inquirer")
+vi.mock("ora")
+vi.mock("node:child_process")
+
+const readFileMock = vi.mocked(fs.readFile as unknown as (path: string, encoding: string) => Promise<string>)
+const writeFileMock = vi.mocked(fs.writeFile)
+const oraMock = vi.mocked(ora)
+const execMock = vi.mocked(execSync)
+
+let spinnerMock: any
+
+beforeEach(() => {
+  vi.clearAllMocks()
+
+  spinnerMock = { start: vi.fn().mockReturnThis(), stop: vi.fn(), succeed: vi.fn(), fail: vi.fn() }
+  oraMock.mockReturnValue(spinnerMock)
+})
+
+describe("createPackageManagerCommands", () => {
+  it("should return correct commands for all package managers", () => {
+    const managers = [
+      { name: "npm", installCmd: "npm install", run: "npm run test" },
+      { name: "yarn", installCmd: "yarn install", run: "yarn test" },
+      { name: "pnpm", installCmd: "pnpm install", run: "pnpm test" },
+      { name: "bun", installCmd: "bun install", run: "bun run test" },
+    ]
+
+    for (const { name, installCmd, run } of managers) {
+      const commands = pkgMgr.createPackageManagerCommands(name)
+      expect(commands.installCmd).toBe(installCmd)
+      expect(commands.runScript("test")).toBe(run)
+    }
+  })
+})
+
+describe("promptForPackageManager", () => {
+  it("should prompt and return selected package manager", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({ pkgManager: "yarn" })
+    const commands = await pkgMgr.promptForPackageManager()
+    expect(commands.name).toBe("yarn")
+    expect(commands.installCmd).toBe("yarn install")
+  })
+})
+
+describe("installDependencies", () => {
+  it("should run install and lint scripts successfully", async () => {
+    execMock.mockReturnValue("")
+    const pkg = pkgMgr.createPackageManagerCommands("npm")
+    await pkgMgr.installDependencies("targetDir", pkg)
+    expect(spinnerMock.succeed).toHaveBeenCalledWith("Dependencies installed!")
+  })
+
+  it("should fail gracefully if execSync throws", async () => {
+    execMock.mockImplementation(() => {
+      throw new Error("fail")
+    })
+    const pkg = pkgMgr.createPackageManagerCommands("npm")
+    await expect(pkgMgr.installDependencies("targetDir", pkg)).rejects.toThrow("fail")
+    expect(spinnerMock.fail).toHaveBeenCalledWith("Failed to install dependencies")
+  })
+})
+
+describe("updatePackageJson", () => {
+  it("should merge dependencies correctly", async () => {
+    readFileMock.mockResolvedValue(JSON.stringify({ dependencies: { a: "1" }, devDependencies: {}, scripts: {} }))
+    writeFileMock.mockResolvedValue()
+    await pkgMgr.updatePackageJson("rootDir", "targetDir", "standard", { dependencies: { b: "2" }, devDependencies: {}, scripts: {} })
+    expect(writeFileMock).toHaveBeenCalled()
+  })
+
+  it("should merge devDependencies and scripts", async () => {
+    readFileMock.mockResolvedValue(JSON.stringify({
+      dependencies: {},
+      devDependencies: { a: "1" },
+      scripts: { start: "node index.js" },
+    }))
+    writeFileMock.mockResolvedValue()
+    await pkgMgr.updatePackageJson("rootDir", "targetDir", "standard", {
+      dependencies: {},
+      devDependencies: { b: "2" },
+      scripts: { test: "vitest" },
+    })
+    expect(writeFileMock).toHaveBeenCalled()
+  })
+
+  it("should handle empty extras without error", async () => {
+    readFileMock.mockResolvedValue(JSON.stringify({ dependencies: {}, devDependencies: {}, scripts: {} }))
+    writeFileMock.mockResolvedValue()
+    await pkgMgr.updatePackageJson("rootDir", "targetDir", "standard", {})
+    expect(writeFileMock).toHaveBeenCalled()
+  })
+})

package/tests/template.test.ts

@@ -0,0 +1,73 @@
+import fs from "fs-extra"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import * as template from "../src/helpers/template"
+
+vi.mock("fs-extra")
+
+const tmpDir = "/tmp/mock"
+const targetDir = "/tmp/target"
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe("copyRootTemplate", () => {
+  it("throws if path doesn't exist", async () => {
+    const pathExistsMock = vi.mocked(fs.pathExists as any)
+    pathExistsMock.mockResolvedValue(false)
+
+    await expect(template.copyRootTemplate(tmpDir, targetDir)).rejects.toThrow(/not found/)
+  })
+
+  it("copies files if path exists", async () => {
+    const pathExistsMock = vi.mocked(fs.pathExists as any)
+    const copyMock = vi.mocked(fs.copy)
+
+    pathExistsMock.mockResolvedValue(true)
+    copyMock.mockResolvedValue()
+
+    const result = await template.copyRootTemplate(tmpDir, targetDir)
+
+    expect(pathExistsMock).toHaveBeenCalledOnce()
+    expect(copyMock).toHaveBeenCalledWith(
+      expect.stringContaining("base"),
+      targetDir,
+    )
+    expect(result).toContain("base")
+  })
+})
+
+describe("copyPresetFiles", () => {
+  it("throws if preset not found", async () => {
+    const pathExistsMock = vi.mocked(fs.pathExists as unknown as (path: string) => Promise<boolean>)
+    pathExistsMock.mockResolvedValue(false)
+
+    await expect(template.copyPresetFiles(tmpDir, "standard", targetDir)).rejects.toThrow(/not found/)
+  })
+
+  it("copies root files and app folder", async () => {
+    const pathExistsMock = vi.mocked(fs.pathExists)
+    const readdirMock = vi.mocked(fs.readdir as unknown as (path: string) => Promise<string[]>)
+    const copyMock = vi.mocked(fs.copy)
+
+    pathExistsMock.mockImplementation(async () => true)
+    readdirMock.mockResolvedValue(["file1.txt", "app"])
+    copyMock.mockResolvedValue()
+
+    await template.copyPresetFiles(tmpDir, "standard", targetDir)
+
+    expect(readdirMock).toHaveBeenCalledWith(
+      expect.stringContaining("standard"),
+    )
+    expect(copyMock).toHaveBeenCalledWith(
+      expect.stringContaining("file1.txt"),
+      expect.stringContaining("file1.txt"),
+      { overwrite: true },
+    )
+    expect(copyMock).toHaveBeenCalledWith(
+      expect.stringContaining("app"),
+      expect.stringContaining("app"),
+      { overwrite: true },
+    )
+  })
+})

package/tests/utils.test.ts

@@ -0,0 +1,155 @@
+import fs from "fs-extra"
+import inquirer from "inquirer"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { PRESET_EXTRA_PACKAGES, PRESET_EXTRA_SCRIPTS, REPO_URL } from "../src/helpers/utils"
+import * as utils from "../src/helpers/utils"
+
+vi.mock("fs-extra")
+vi.mock("inquirer")
+
+const presets = ["standard", "with-i18n", "with-tests"] as const
+let originalArgv: string[]
+
+beforeEach(() => {
+  originalArgv = [...process.argv]
+})
+
+afterEach(() => {
+  process.argv = originalArgv
+  vi.clearAllMocks()
+})
+
+describe("repository", () => {
+  it("has a valid REPO_URL", () => {
+    expect(REPO_URL).toBe("https://github.com/matimortari/nuxt-bake.git")
+  })
+})
+
+describe.each(presets)("preset %s", (preset) => {
+  it("has a valid scripts object", () => {
+    expect(PRESET_EXTRA_SCRIPTS[preset]).toBeTypeOf("object")
+  })
+
+  it("has a valid packages object", () => {
+    expect(PRESET_EXTRA_PACKAGES[preset]).toBeTypeOf("object")
+  })
+})
+
+describe("getProjectNameFromArgs", () => {
+  it("returns correct name with -n", () => {
+    process.argv = ["node", "cli.js", "-n", "my-nuxt-app"]
+    expect(utils.getProjectNameFromArgs()).toBe("my-nuxt-app")
+  })
+
+  it("returns correct name with --name", () => {
+    process.argv = ["node", "cli.js", "--name", "my-nuxt-app"]
+    expect(utils.getProjectNameFromArgs()).toBe("my-nuxt-app")
+  })
+
+  it("returns null if no name provided", () => {
+    process.argv = ["node", "cli.js"]
+    expect(utils.getProjectNameFromArgs()).toBeNull()
+  })
+
+  it("returns empty string if -n is empty", () => {
+    process.argv = ["node", "cli.js", "-n", ""]
+    expect(utils.getProjectNameFromArgs()).toBe("")
+  })
+})
+
+describe("promptForProjectName", () => {
+  it("returns name from args", async () => {
+    process.argv = ["node", "cli.js", "-n", "my-arg-nuxt-app"]
+    const name = await utils.promptForProjectName()
+    expect(name).toBe("my-arg-nuxt-app")
+  })
+
+  it("prompts if no args", async () => {
+    process.argv = ["node", "cli.js"]
+    const promptMock = vi.mocked(inquirer.prompt as any)
+    promptMock.mockResolvedValue({ projectName: "my-prompted-nuxt-app" })
+
+    const name = await utils.promptForProjectName()
+    expect(name).toBe("my-prompted-nuxt-app")
+  })
+
+  it("validator rejects empty string during prompt", async () => {
+    process.argv = ["node", "cli.js"]
+    const promptMock = vi.mocked(inquirer.prompt as any)
+    promptMock.mockImplementation(async (opts: any) => {
+      const validateFn = opts.validate
+      expect(validateFn("")).toBe("Project folder name cannot be empty")
+      expect(validateFn("valid")).toBe(true)
+      return { projectName: "my-filled-nuxt-app" }
+    })
+
+    const name = await utils.promptForProjectName()
+    expect(name).toBe("my-filled-nuxt-app")
+  })
+
+  it("prompts if -n is empty string", async () => {
+    process.argv = ["node", "cli.js", "-n", ""]
+    const promptMock = vi.mocked(inquirer.prompt as any)
+    promptMock.mockResolvedValue({ projectName: "my-filled-from-empty-nuxt-app" })
+
+    const name = await utils.promptForProjectName()
+    expect(name).toBe("my-filled-from-empty-nuxt-app")
+  })
+})
+
+describe("validateTargetDirectory", () => {
+  it("returns null if path exists and user declines overwrite", async () => {
+    const pathExistsMock = vi.mocked(fs.pathExists as any)
+    const promptMock = vi.mocked(inquirer.prompt as any)
+
+    pathExistsMock.mockResolvedValue(true)
+    promptMock.mockResolvedValue({ overwrite: false })
+
+    const result = await utils.validateTargetDirectory("exists")
+    expect(result).toBeNull()
+  })
+
+  it("removes existing directory if user confirms overwrite", async () => {
+    const pathExistsMock = vi.mocked(fs.pathExists as any)
+    const removeMock = vi.mocked(fs.remove as any)
+    const promptMock = vi.mocked(inquirer.prompt as any)
+
+    pathExistsMock.mockResolvedValue(true)
+    removeMock.mockResolvedValue()
+    promptMock.mockResolvedValue({ overwrite: true })
+
+    const result = await utils.validateTargetDirectory("exists")
+    expect(removeMock).toHaveBeenCalled()
+    expect(result).toContain("exists")
+  })
+
+  it("removes existing directory even if projectName is empty string", async () => {
+    const pathExistsMock = vi.mocked(fs.pathExists as any)
+    const removeMock = vi.mocked(fs.remove as any)
+    const promptMock = vi.mocked(inquirer.prompt as any)
+
+    pathExistsMock.mockResolvedValue(true)
+    removeMock.mockResolvedValue()
+    promptMock.mockResolvedValue({ overwrite: true })
+
+    const result = await utils.validateTargetDirectory("")
+    expect(removeMock).toHaveBeenCalled()
+    expect(result).toContain("")
+  })
+
+  it("returns path if not exists", async () => {
+    const pathExistsMock = vi.mocked(fs.pathExists as any)
+    pathExistsMock.mockResolvedValue(false)
+
+    const result = await utils.validateTargetDirectory("new-dir")
+    expect(result).toContain("new-dir")
+  })
+
+  it("resolves path even if projectName is empty string and path does not exist", async () => {
+    const pathExistsMock = vi.mocked(fs.pathExists as any)
+    pathExistsMock.mockResolvedValue(false)
+
+    const result = await utils.validateTargetDirectory("")
+    expect(result).toContain("")
+  })
+})

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/index.ts", "src/helpers/**/*.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config"
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    exclude: ["templates/**", "node_modules/**"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html"],
+      include: ["src/**/*.{ts,js}"],
+      exclude: ["**/*.d.ts", "tests/**", "node_modules/**"],
+    },
+  },
+})