ember.nvp 1.9.0 → 1.11.0

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;
-  },
-};

package/src/layers/eslint-bundled-nvp/app.test.ts

@@ -1,91 +0,0 @@
-import { beforeAll, describe, it, expect as hardExpect, afterAll } from "vitest";
-import { expectIsSetup, generate, layers, reapply } from "#test-helpers";
-
-import type { Project } from "ember.nvp";
-import { rm } from "node:fs/promises";
-
-const expect = hardExpect.soft;
-
-let layer = layers.find((layer) => layer.name === "eslint-bundled-nvp")!;
-
-describe("starting without eslint-bundled-nvp", () => {
-  let project: Project;
-
-  beforeAll(async () => {
-    project = await generate({
-      type: "app",
-      packageManager: "pnpm",
-      layers: ["git"],
-    });
-  });
-
-  afterAll(async () => {
-    await rm(project.directory, { recursive: true, force: true });
-  });
-
-  it("applying eslint-bundled-nvp", async () => {
-    await reapply(project, ["eslint-bundled-nvp"]);
-
-    await expectIsSetup(project, layer);
-    expect(await project.gitHasDiff()).toBe(false);
-  });
-});
-
-describe("starting with eslint-bundled-nvp", () => {
-  let project: Project;
-
-  beforeAll(async () => {
-    project = await generate({
-      type: "app",
-      packageManager: "pnpm",
-      layers: ["eslint-bundled-nvp", "git"],
-    });
-  });
-
-  afterAll(async () => {
-    await rm(project.directory, { recursive: true, force: true });
-  });
-
-  it("reapplying eslint-bundled-nvp causes no changes", async () => {
-    await reapply(project, ["eslint-bundled-nvp"]);
-
-    await expectIsSetup(project, layer);
-    expect(await project.gitHasDiff()).toBe(false);
-  });
-});
-
-describe("package.json scripts", () => {
-  let project: Project;
-
-  beforeAll(async () => {
-    project = await generate({
-      type: "app",
-      packageManager: "pnpm",
-      layers: ["eslint-bundled-nvp", "git"],
-    });
-
-    let { exitCode } = await project.run("pnpm install");
-
-    hardExpect(exitCode).toBe(0);
-
-    await expectIsSetup(project, layer);
-  });
-
-  afterAll(async () => {
-    await rm(project.directory, { recursive: true, force: true });
-  });
-
-  it("linting and fixing works", async () => {
-    {
-      let { exitCode } = await project.run("pnpm lint:eslint --fix");
-
-      expect(exitCode).toBe(0);
-    }
-
-    {
-      let { exitCode } = await project.run("pnpm lint:eslint");
-
-      expect(exitCode).toBe(0);
-    }
-  });
-});

package/src/layers/eslint-bundled-nvp/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", "NullVoxPopuli's encapsulated config"),
-  hint: `Minimal dependencies added to package.json`,
-
-  async run(project) {
-    await files.applyFolder(join(import.meta.dirname, "files"), project.directory);
-
-    await packageJson.addDevDependencies(
-      await getLatest({
-        "@nullvoxpopuli/eslint-configs": "^7.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, ["@nullvoxpopuli/eslint-configs", "eslint"])) {
-      reasons.push("missing required dependencies: @nullvoxpopuli/eslint-configs, 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;
-  },
-};