ember.nvp 1.9.0 → 1.10.0

package/test/ember.nvp/layer-typescript.test.ts

@@ -0,0 +1,302 @@
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+import { generate, expectIsSetup, layers, reapply } from "#test-helpers";
+import { writeLibrarySource } from "./library-src-fixtures.ts";
+import { execa } from "execa";
+import { rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { packageJson } from "ember-apply";
+
+import type { Project } from "ember.nvp";
+
+const typescript = layers.find((layer) => layer.name === "typescript")!;
+const eslint = layers.find((layer) => layer.name === "eslint-bundled")!;
+
+const typescript6 = { typescript: { version: "6" }, "eslint-bundled": { preset: "nvp" } };
+const typescript7 = { typescript: { version: "7" }, "eslint-bundled": { preset: "nvp" } };
+
+function run(project: Project, command: string) {
+  return execa(command, { cwd: project.directory, shell: true, all: true, reject: false });
+}
+
+async function devDependencies(project: Project): Promise<Record<string, string>> {
+  let manifest = await packageJson.read(project.directory);
+
+  return manifest.devDependencies ?? {};
+}
+
+describe("layer: typescript, version 7", () => {
+  const dirs: string[] = [];
+
+  afterAll(async () => {
+    if (process.env.CI) return;
+
+    for (const dir of dirs) {
+      await rm(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    }
+  });
+
+  describe("app with eslint", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "app",
+        layers: ["typescript", "eslint-bundled", "git"],
+        options: typescript7,
+      });
+      dirs.push(project.directory);
+    });
+
+    it("is setup", async () => {
+      await expectIsSetup(project, typescript);
+      await expectIsSetup(project, eslint);
+    });
+
+    it("installs TypeScript 7 as @typescript/native, and TypeScript 6 for typescript-eslint", async () => {
+      let deps = await devDependencies(project);
+
+      expect(deps["@typescript/native"]).toMatch(/^npm:typescript@7\./);
+      expect(deps["typescript"]).toMatch(/^npm:@typescript\/typescript6@6\./);
+      expect(deps).toHaveProperty("ember-content-mapper");
+      expect(deps).not.toHaveProperty("@glint/tsserver-plugin");
+    });
+
+    it("reapplying causes no changes", async () => {
+      await reapply(project, ["typescript", "eslint-bundled", "git"]);
+
+      expect(await project.gitHasDiff()).toBe(false);
+    });
+
+    describe("after install", () => {
+      beforeAll(async () => {
+        let install = await run(project, "pnpm install");
+        expect(install.exitCode, install.all).toBe(0);
+      });
+
+      it("type checking works", async () => {
+        let result = await run(project, "pnpm lint:types");
+
+        expect(result.exitCode, result.all).toBe(0);
+      });
+
+      it("reports template errors in .gts files", async () => {
+        let file = "app/templates/application.gts";
+        let original = await project.read(file);
+
+        await writeFile(
+          join(project.directory, file),
+          `const count: number = 1;\n\n<template>{{count.nope}}</template>\n`,
+        );
+
+        let result = await run(project, "pnpm lint:types");
+
+        await writeFile(join(project.directory, file), original!);
+
+        expect(result.exitCode).not.toBe(0);
+        expect(result.all).toContain("application.gts");
+        expect(result.all).toContain("'nope'");
+      });
+
+      it("linting works", async () => {
+        await run(project, "pnpm lint:eslint --fix");
+
+        let result = await run(project, "pnpm lint:eslint");
+
+        expect(result.exitCode, result.all).toBe(0);
+      });
+
+      it("build works", async () => {
+        let result = await run(project, "pnpm build");
+
+        expect(result.exitCode, result.all).toBe(0);
+      });
+    });
+  });
+
+  describe("app without eslint", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({ type: "app", layers: ["typescript"], options: typescript7 });
+      dirs.push(project.directory);
+    });
+
+    it("is setup", async () => {
+      await expectIsSetup(project, typescript);
+    });
+
+    it("has no typescript, because nothing needs TypeScript 6", async () => {
+      expect(await devDependencies(project)).not.toHaveProperty("typescript");
+    });
+
+    it("type checking works", async () => {
+      let install = await run(project, "pnpm install");
+      expect(install.exitCode, install.all).toBe(0);
+
+      let result = await run(project, "pnpm lint:types");
+
+      expect(result.exitCode, result.all).toBe(0);
+    });
+  });
+
+  describe.each(["app", "library"] as const)(
+    "migrating a TypeScript 6 %s without eslint",
+    (type) => {
+      let project: Project;
+
+      beforeAll(async () => {
+        let layers = ["typescript", "git"];
+        let before = await generate({
+          type,
+          layers,
+          options: { typescript: { version: "6" } },
+        });
+        dirs.push(before.directory);
+
+        expect(await devDependencies(before)).toHaveProperty("typescript");
+
+        project = await generate({
+          directory: before.directory,
+          type,
+          layers,
+          options: { typescript: { version: "7" } },
+        });
+      });
+
+      it("is setup, and detects version 7", async () => {
+        await expectIsSetup(project, typescript);
+        expect(await typescript.options?.version?.detect?.(project)).toBe("7");
+      });
+
+      it("removes typescript and the tsserver plugin, because nothing needs TypeScript 6", async () => {
+        let manifest = await packageJson.read(project.directory);
+
+        expect(manifest.scripts?.["lint:types"]).toBe("tsc --noEmit --runExternalCode");
+        expect(manifest.devDependencies?.["@typescript/native"]).toMatch(/^npm:typescript@7\./);
+        expect(manifest.devDependencies).not.toHaveProperty("typescript");
+        expect(manifest.devDependencies).not.toHaveProperty("@glint/tsserver-plugin");
+      });
+
+      it("reapplying causes no changes", async () => {
+        await reapply(project, ["typescript", "git"]);
+
+        expect(await project.gitHasDiff()).toBe(false);
+      });
+
+      it("type checking and the build work", async () => {
+        if (type === "library") await writeLibrarySource(project, "typescript");
+
+        let install = await run(project, "pnpm install");
+        expect(install.exitCode, install.all).toBe(0);
+
+        let types = await run(project, "pnpm lint:types");
+        expect(types.exitCode, types.all).toBe(0);
+
+        let build = await run(project, "pnpm build");
+        expect(build.exitCode, build.all).toBe(0);
+      });
+    },
+  );
+
+  describe("migrating a TypeScript 6 app with eslint", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      let layers = ["typescript", "eslint-bundled", "git"];
+      let before = await generate({ type: "app", layers, options: typescript6 });
+      dirs.push(before.directory);
+
+      project = await generate({
+        directory: before.directory,
+        type: "app",
+        layers,
+        options: typescript7,
+      });
+    });
+
+    it("is setup", async () => {
+      await expectIsSetup(project, typescript);
+      await expectIsSetup(project, eslint);
+    });
+
+    it("detects the version the project uses", async () => {
+      expect(await typescript.options?.version?.detect?.(project)).toBe("7");
+    });
+
+    it("switches to TypeScript 7 and keeps TypeScript 6 for typescript-eslint", async () => {
+      let manifest = await packageJson.read(project.directory);
+
+      expect(manifest.scripts?.["lint:types"]).toBe("tsc --noEmit --runExternalCode");
+      expect(manifest.devDependencies?.["typescript"]).toMatch(/^npm:@typescript\/typescript6@/);
+      expect(manifest.devDependencies).not.toHaveProperty("@glint/tsserver-plugin");
+    });
+
+    it("type checking and linting work", async () => {
+      let install = await run(project, "pnpm install");
+      expect(install.exitCode, install.all).toBe(0);
+
+      let types = await run(project, "pnpm lint:types");
+      expect(types.exitCode, types.all).toBe(0);
+
+      await run(project, "pnpm lint:eslint --fix");
+
+      let lint = await run(project, "pnpm lint:eslint");
+      expect(lint.exitCode, lint.all).toBe(0);
+    });
+  });
+
+  describe("library", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "library",
+        name: "my-lib",
+        layers: ["typescript", "expect-type"],
+        options: typescript7,
+      });
+      dirs.push(project.directory);
+
+      await writeLibrarySource(project, "typescript");
+
+      let install = await run(project, "pnpm install");
+      expect(install.exitCode, install.all).toBe(0);
+    });
+
+    it("is setup", async () => {
+      await expectIsSetup(project, typescript);
+    });
+
+    it("has no typescript, because nothing needs TypeScript 6", async () => {
+      expect(await devDependencies(project)).not.toHaveProperty("typescript");
+    });
+
+    it("type checking works", async () => {
+      let result = await run(project, "pnpm lint:types");
+
+      expect(result.exitCode, result.all).toBe(0);
+    });
+
+    it("type tests resolve .gts modules", async () => {
+      await writeFile(
+        join(project.directory, "type-tests/greeting.test.ts"),
+        `import { expectTypeOf } from "expect-type";
+import { Greeting, type GreetingSignature } from "../src/index.ts";
+
+expectTypeOf(Greeting).not.toBeAny();
+expectTypeOf<GreetingSignature["Args"]>().toEqualTypeOf<{ name: string }>();
+`,
+      );
+
+      let result = await run(project, "pnpm lint:type-tests");
+
+      expect(result.exitCode, result.all).toBe(0);
+    });
+
+    it("build works", async () => {
+      let result = await run(project, "pnpm build");
+
+      expect(result.exitCode, result.all).toBe(0);
+    });
+  });
+});

package/test/ember.nvp/layers.test.ts

@@ -11,8 +11,7 @@ describe("discoverLayers", () => {
     expect(layerNames).toMatchInlineSnapshot(`
       [
         "are-the-types-wrong",
-        "eslint-bundled-ember",
-        "eslint-bundled-nvp",
+        "eslint-bundled",
         "expect-type",
         "git",
         "github-actions",

package/test/ember.nvp/permutations/shared.ts

@@ -16,7 +16,7 @@ const RE_APPLY_ONLY = new Set<string>([
 ]);
 const INITIAL_ONLY = new Set<string>([
   // baseline,
-  // "eslint-bundled-nvp",
+  // "eslint-bundled",
   // "typescript"
 ]);
 
@@ -45,7 +45,7 @@ const TYPE_FOR_BASE: Record<(typeof bases)[number], ProjectType> = {
 };
 
 /**
- * Layers that only add lint / format / publish checks.
+ * Layers that only add lint / format / type / publish checks.
  *
  * They don't affect the runtime shape of a project,
  * so they permutate among themselves in a small "checks" matrix
@@ -55,8 +55,7 @@ const TYPE_FOR_BASE: Record<(typeof bases)[number], ProjectType> = {
  * so linear cross-group coverage remains.
  */
 const CHECK_LAYERS = new Set<string>([
-  "eslint-bundled-ember",
-  "eslint-bundled-nvp",
+  "eslint-bundled",
   "eslint-ejected",
   "prettier",
   "publint",

package/test/ember.nvp/validate-option.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect } from "vitest";
+import { validateOption } from "../../src/cli/questions/validate-option.js";
+import type { LayerOptionSchema } from "../../src/utils/types.js";
+
+describe("validateOption", () => {
+  describe("number validation", () => {
+    const schema: LayerOptionSchema = {
+      type: "number",
+      prompt: "Enter number",
+      default: 10,
+      validate: (val: number) => (val > 0 ? undefined : "Must be greater than 0"),
+    };
+
+    it("validates valid numbers", () => {
+      expect(validateOption(schema, 5)).toEqual({ ok: true, value: 5 });
+      expect(validateOption(schema, "42")).toEqual({ ok: true, value: 42 });
+      expect(validateOption(schema, " 2.5 ")).toEqual({ ok: true, value: 2.5 });
+    });
+
+    it.each(["", "abc", "0x10", "1e3"])("fails on '%s'", (input) => {
+      expect(validateOption(schema, input)).toEqual({
+        ok: false,
+        error: `'${input}' is not a number`,
+      });
+    });
+
+    it("fails custom validate function", () => {
+      expect(validateOption(schema, -5)).toEqual({ ok: false, error: "Must be greater than 0" });
+    });
+  });
+
+  describe("text validation", () => {
+    const schema: LayerOptionSchema = {
+      type: "text",
+      prompt: "Enter text",
+      default: "default-title",
+      validate: (val: string) => (val.length >= 3 ? undefined : "Minimum 3 chars"),
+    };
+
+    it("validates valid text", () => {
+      expect(validateOption(schema, "hello")).toEqual({ ok: true, value: "hello" });
+    });
+
+    it("fails custom validate function", () => {
+      expect(validateOption(schema, "hi")).toEqual({ ok: false, error: "Minimum 3 chars" });
+    });
+
+    it("fails with the message of an Error", () => {
+      const strict: LayerOptionSchema = { ...schema, validate: () => new Error("Nope") };
+
+      expect(validateOption(strict, "hello")).toEqual({ ok: false, error: "Nope" });
+    });
+  });
+
+  describe("confirm validation", () => {
+    const schema: LayerOptionSchema = {
+      type: "confirm",
+      prompt: "Confirm action",
+      default: true,
+    };
+
+    it("validates booleans", () => {
+      expect(validateOption(schema, true)).toEqual({ ok: true, value: true });
+      expect(validateOption(schema, false)).toEqual({ ok: true, value: false });
+    });
+
+    it("fails on strings", () => {
+      expect(validateOption(schema, "yes")).toEqual({
+        ok: false,
+        error: "'yes' is not true or false",
+      });
+    });
+  });
+
+  describe("select validation", () => {
+    const schema: LayerOptionSchema = {
+      type: "select",
+      prompt: "Select option",
+      default: "standard",
+      options: [
+        { label: "Standard", value: "standard" },
+        { label: "Deluxe", value: "deluxe" },
+      ],
+    };
+
+    it("validates valid option choice", () => {
+      expect(validateOption(schema, "deluxe")).toEqual({ ok: true, value: "deluxe" });
+    });
+
+    it("fails unlisted choice", () => {
+      expect(validateOption(schema, "ultra")).toEqual({
+        ok: false,
+        error: "Invalid option 'ultra'. Must be one of: standard, deluxe",
+      });
+    });
+  });
+
+  describe("multiselect validation", () => {
+    const schema: LayerOptionSchema = {
+      type: "multiselect",
+      prompt: "Select options",
+      options: [
+        { label: "A", value: "a" },
+        { label: "B", value: "b" },
+      ],
+      validate: (val: string[]) => (val.length > 0 ? undefined : "Select at least one"),
+    };
+
+    it("validates listed choices", () => {
+      expect(validateOption(schema, ["a", "b"])).toEqual({ ok: true, value: ["a", "b"] });
+    });
+
+    it("fails unlisted choice", () => {
+      expect(validateOption(schema, ["a", "c"])).toEqual({
+        ok: false,
+        error: "Invalid option 'c'. Must be one of: a, b",
+      });
+    });
+
+    it("fails custom validate function", () => {
+      expect(validateOption(schema, [])).toEqual({ ok: false, error: "Select at least one" });
+    });
+  });
+
+  describe("Standard Schema validation", () => {
+    // A hand-written schema, so the test needs no schema library
+    const positive = {
+      "~standard": {
+        version: 1 as const,
+        vendor: "test",
+        validate: (value: unknown) =>
+          typeof value === "number" && value > 0
+            ? { value }
+            : { issues: [{ message: "Must be positive" }] },
+      },
+    };
+
+    const schema: LayerOptionSchema = {
+      type: "number",
+      prompt: "Enter number",
+      validate: positive,
+    };
+
+    it("passes values the schema accepts", () => {
+      expect(validateOption(schema, "3")).toEqual({ ok: true, value: 3 });
+    });
+
+    it("fails with the schema's first issue", () => {
+      expect(validateOption(schema, "-3")).toEqual({ ok: false, error: "Must be positive" });
+    });
+  });
+});

package/test/test-helpers/permutate.test.ts

@@ -25,12 +25,7 @@ describe("permutate", () => {
   });
 
   it("enforces mutual exclusivity for eslint-prefixed entries", () => {
-    const result = permutate([
-      "eslint-bundled-ember",
-      "eslint-bundled-nvp",
-      "eslint-ejected",
-      "other",
-    ]);
+    const result = permutate(["eslint-bundled", "eslint-ejected", "other"]);
 
     // Check that no permutation has more than one eslint-prefixed entry
     for (const permutation of result) {
@@ -40,7 +35,7 @@ describe("permutate", () => {
   });
 
   it("allows permutations with 0 or 1 eslint entry", () => {
-    const result = permutate(["eslint-bundled-ember", "eslint-bundled-nvp", "other"]);
+    const result = permutate(["eslint-bundled", "eslint-ejected", "other"]);
 
     const hasNoEslint = result.some((perm) => !perm.some((item) => item.startsWith("eslint-")));
     const hasOneEslint = result.some(

package/test/test-helpers.ts

@@ -6,7 +6,7 @@ import { mkdtemp, readdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { generateProject, Project } from "ember.nvp";
 import { discoverLayers } from "#layers";
-import type { DiscoveredLayer, ProjectType } from "#types";
+import type { Answers, DiscoveredLayer, ProjectType } from "#types";
 import { expect } from "vitest";
 
 const minimalApp = "minimal-app";
@@ -78,6 +78,7 @@ export async function reapply(project: Project, layers: string[]) {
     name: project.name,
     type: project.type,
     packageManager: project.packageManager,
+    options: project.desires.options,
   });
 }
 
@@ -87,12 +88,17 @@ export async function generate({
   type = "app",
   packageManager = "pnpm",
   directory,
+  options,
 }: {
   directory?: string;
   layers?: string[];
   name?: string;
   type?: ProjectType;
   packageManager?: "pnpm" | "npm";
+  /**
+   * Layer options, keyed by layer name
+   */
+  options?: Answers["options"];
 }): Promise<Project> {
   const tempDir = directory ?? (await mktemp(name));
 
@@ -103,6 +109,7 @@ export async function generate({
     path: tempDir,
     layers: selectedLayers,
     packageManager,
+    options,
   });
 
   await generateProject(project);

package/src/layers/eslint-bundled-ember/index.js

@@ -1,91 +0,0 @@
-import { getLatest } from "#utils/npm.js";
-import { files, packageJson } from "ember-apply";
-import { formatLabel } from "#utils/cli.js";
-import { maybeLintWithConcurrently } from "#consolidators/linting.js";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { hasDevDeps } from "#utils/manifest.js";
-
-/**
- * @type {import('#types').Layer}
- */
-export default {
-  label: formatLabel("ESLint", "ember's encapsulated config"),
-  hint: `Minimal dependencies added to package.json. Not official, but follows the official configuration`,
-
-  async run(project) {
-    await files.applyFolder(join(import.meta.dirname, "files"), project.directory);
-
-    await packageJson.addDevDependencies(
-      await getLatest({
-        "ember-eslint": "^1.0.0",
-        eslint: "^10.9.1",
-      }),
-      project.directory,
-    );
-
-    await packageJson.addScripts(
-      {
-        "lint:eslint": "eslint . --cache",
-        "lint:eslint:fix": "eslint . --fix",
-      },
-      project.directory,
-    );
-
-    await maybeLintWithConcurrently(project);
-  },
-
-  /**
-   * @overload
-   * @param {import('#utils/project.js').Project} project
-   * @param {true} explain
-   * @returns {Promise<{ isSetup: boolean; reasons: string[] }>}
-   */
-  /**
-   * @overload
-   * @param {import('#utils/project.js').Project} project
-   * @param {boolean | undefined} [explain]
-   * @returns {Promise<boolean>}
-   */
-  async isSetup(project, explain) {
-    const reasons = [];
-
-    if (!existsSync(join(project.directory, "eslint.config.js"))) {
-      reasons.push("eslint.config.js is missing");
-
-      if (!explain) return false;
-    }
-
-    let manifest = await packageJson.read(project.directory);
-
-    if (!hasDevDeps(manifest, ["ember-eslint", "eslint"])) {
-      reasons.push("missing required dependencies: ember-eslint, eslint");
-
-      if (!explain) return false;
-    }
-
-    let scripts = Object.values(manifest.scripts ?? {}).filter((script) =>
-      script.includes("eslint"),
-    );
-
-    if (!scripts.some((script) => script.includes("--cache"))) {
-      reasons.push("missing eslint script with --cache flag");
-
-      if (!explain) return false;
-    }
-    if (!scripts.some((script) => script.includes("--fix"))) {
-      reasons.push("missing eslint script with --fix flag");
-
-      if (!explain) return false;
-    }
-
-    if (explain) {
-      return {
-        isSetup: reasons.length === 0,
-        reasons,
-      };
-    }
-
-    return reasons.length === 0;
-  },
-};