ember.nvp 0.1.0 → 0.2.0

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

@@ -0,0 +1,91 @@
+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/files/eslint.config.js

@@ -0,0 +1,16 @@
+/**
+ * This config simultaneously supports apps, libraries, typescript, etc.
+ *
+ * but in a way that abstracts the dependencies and configuration
+ * out of your project.
+ *
+ * Handles: (G)TS + (G)JS, QUnit, Supporting Node files
+ *          for apps and libraries
+ */
+import { configs } from "@nullvoxpopuli/eslint-configs";
+
+export default [
+  ...configs.ember(import.meta.dirname),
+  // your modifications here
+  // see: https://eslint.org/docs/user-guide/configuring/configuration-files#how-do-overrides-work
+];

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

@@ -0,0 +1,91 @@
+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": "^5.5.0",
+        eslint: "^9.39.2",
+      }),
+      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;
+  },
+};

package/src/layers/eslint-ejected/index.js

@@ -0,0 +1,95 @@
+import { getLatest } from "#utils/npm.js";
+import { packageJson, files } from "ember-apply";
+import { formatLabel } from "#utils/cli.js";
+import { hasDevDeps } from "#utils/manifest.js";
+import { maybeLintWithConcurrently } from "#consolidators/linting.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+const toInstall = {
+  "@babel/eslint-parser": "^7.28.6",
+  "@eslint/js": "^9.39.2",
+  "eslint-config-prettier": "^10.1.8",
+  "eslint-plugin-ember": "^12.7.5",
+  "eslint-plugin-n": "^17.23.2",
+  "eslint-plugin-qunit": "^8.2.5",
+  "typescript-eslint": "^8.53.0",
+  eslint: "^9.39.2",
+};
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: formatLabel("ESLint", "fully ejected, all of the dependencies"),
+
+  async run(project) {
+    await files.applyFolder(join(import.meta.dirname, "files"), project.directory);
+
+    await packageJson.addDevDependencies(await getLatest(toInstall), 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, toInstall)) {
+      reasons.push("missing required dependencies");
+
+      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/git/index.js

@@ -0,0 +1,33 @@
+import * as p from "@clack/prompts";
+import { hasGit, initGit, isInGit } from "#utils/git.js";
+import { formatLabel } from "#utils/cli.js";
+
+export default {
+  label: formatLabel("git init"),
+  hint: "set up this project as a fresh git repository",
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  async defaultValue(project) {
+    return !isInGit();
+  },
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  async run(project) {
+    if (hasGit(project.directory)) {
+      return;
+    }
+
+    return initGit(project.directory);
+  },
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  async isSetup(project) {
+    return hasGit(project.directory);
+  },
+};

package/src/layers/github-actions/app.test.ts

@@ -0,0 +1,73 @@
+import { beforeAll, describe, it, expect as hardExpect, afterAll } from "vitest";
+import { generate, layers, reapply } from "#test-helpers";
+
+import type { Project } from "ember.nvp";
+import { rm, readFile } from "node:fs/promises";
+
+const expect = hardExpect.soft;
+
+let githubActionsLayer = layers.find((layer) => layer.name === "github-actions")!;
+
+for (let packageManager of ["pnpm", "npm"] as const) {
+  describe(packageManager, () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "app",
+        packageManager,
+        layers: ["github-actions"],
+      });
+    });
+
+    afterAll(async () => {
+      await rm(project.directory, { recursive: true, force: true });
+    });
+
+    it("did not emit a CI.yml, because it wouldn't be used", async () => {
+      let result = await githubActionsLayer.isSetup(project);
+
+      expect(await project.read(".github/workflows/ci.yml")).toMatchInlineSnapshot(`undefined`);
+      expect(result).toBe(true);
+    });
+
+    it("after emitting with an eslint layer", async () => {
+      await reapply(project, ["eslint-bundled-nvp", "github-actions"]);
+
+      let result = await githubActionsLayer.isSetup(project);
+
+      expect(result).toBe(true);
+    });
+
+    it("does not have commands for the 'other' packageManager(s)", async () => {
+      let ciYamlPath = project.path(".github/workflows/ci.yml");
+      let ciYamlContent = await readFile(ciYamlPath, "utf-8");
+
+      if (packageManager === "pnpm") {
+        expect(ciYamlContent).not.toContain(" npm install");
+        expect(ciYamlContent).toContain("wyvox/action-setup-pnpm");
+        expect(ciYamlContent).toContain("pnpm lint");
+        expect(ciYamlContent).not.toContain(" npm lint");
+        expect(await githubActionsLayer.isSetup(project, true)).toMatchInlineSnapshot(`
+          {
+            "isSetup": true,
+            "reasons": [],
+          }
+        `);
+      }
+
+      if (packageManager === "npm") {
+        expect(ciYamlContent).not.toContain("wyvox/action-setup-pnpm");
+        expect(ciYamlContent).toContain(" npm install");
+        expect(ciYamlContent).toContain(" npm run lint");
+        expect(ciYamlContent).not.toContain("pnpm lint");
+        expect(await githubActionsLayer.isSetup(project, true)).toMatchInlineSnapshot(`
+          {
+            "isSetup": true,
+            "reasons": [],
+          }
+        `);
+      }
+    });
+  });
+}

package/src/layers/github-actions/index.js

@@ -0,0 +1,200 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: "GitHub Actions",
+  async run(project) {
+    let result = await transform(project);
+
+    if (result.didChange) {
+      await mkdir(project.path(".github/workflows"), { recursive: true });
+      await writeFile(result.outputPath, result.content, "utf-8");
+    }
+  },
+  /**
+   * @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 = [];
+
+    let result = await transform(project);
+
+    if (result.didChange) {
+      reasons.push(
+        `GitHub Actions workflow needs updates. Was ${result.original}, now ${result.content}`,
+      );
+
+      if (!explain) return false;
+    }
+
+    if (explain) {
+      return {
+        isSetup: reasons.length === 0,
+        reasons,
+      };
+    }
+
+    return reasons.length === 0;
+  },
+};
+
+/**
+ * This is a very silly way to handle YAML, but 🤷
+ * will update if this starts getting to be troublesome.
+ */
+const preamble = `name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - master
+  pull_request: {}
+
+concurrency:
+  group: ci-\${{ github.head_ref || github.ref }}
+  cancel-in-progress: true`;
+
+const lint = {
+  npm: `lint:
+    name: "Lints"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+      - run: npm install
+      - run: npm run lint`,
+  pnpm: `  lint:
+    name: "Lints"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: wyvox/action-setup-pnpm@v3
+      - run: pnpm lint`,
+};
+
+const test = {
+  npm: `test:
+    name: "Tests"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+      - run: npm install
+      - run: npm test`,
+  pnpm: `  test:
+    name: "Tests"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: wyvox/action-setup-pnpm@v3
+      - run: pnpm test`,
+};
+
+/**
+ *
+ * @param {import('#utils/project.js').Project} project
+ * @returns
+ */
+async function transform(project) {
+  let outputPath = join(project.directory, ".github/workflows/ci.yml");
+  let content = "";
+  let original = "";
+
+  if (existsSync(outputPath)) {
+    let buffer = await readFile(outputPath, "utf-8");
+    content = buffer.toString();
+    original = content;
+  }
+
+  content = await addOrUpdateLints(project, content);
+  content = await addOrUpdateTests(project, content);
+
+  /**
+   * If we've still added nothing, we can't actually add the preamble
+   * because there are no jobs to run (we need at least one job).
+   */
+  if (content === "") {
+    return { content, original, didChange: original !== content, outputPath };
+  }
+
+  content = await addOrUpdateBase(project, content);
+
+  return { content, original, didChange: original !== content, outputPath };
+}
+
+/**
+ *
+ * @param {import('#utils/project.js').Project} project
+ * @param {string} file
+ */
+async function addOrUpdateBase(project, file) {
+  if (file.includes("jobs:")) {
+    if (file.includes(preamble)) {
+      return file;
+    }
+
+    return preamble + file;
+  }
+
+  return file;
+}
+
+/**
+ *
+ * @param {import('#utils/project.js').Project} project
+ * @param {string} file
+ */
+async function addOrUpdateLints(project, file) {
+  if (!(await project.hasOrWantsLayer("eslint"))) {
+    return file;
+  }
+
+  if (file.includes("lint:")) {
+    return file;
+  }
+
+  if (!file.includes("jobs:")) {
+    file += "\n\njobs:\n";
+  }
+
+  return file + "\n" + lint[project.desires.packageManager];
+}
+
+/**
+ *
+ * @param {import('#utils/project.js').Project} project
+ * @param {string} file
+ */
+async function addOrUpdateTests(project, file) {
+  if (!(await project.hasOrWantsLayer("testing"))) {
+    return file;
+  }
+
+  if (file.includes("test:")) {
+    return file;
+  }
+
+  if (!file.includes("jobs:")) {
+    file += "\n\njobs:\n";
+  }
+
+  return file + "\n" + test[project.desires.packageManager];
+}

package/src/layers/index.js

@@ -0,0 +1,47 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * @type {Set<string>}
+ */
+export const TODO = new Set(["vitest", "release-plan", "eslint-ejected"]);
+
+/**
+ * @returns {Promise<Array<import('#types').DiscoveredLayer>>}
+ */
+export async function discoverLayers() {
+  const layersDir = import.meta.dirname;
+  const entries = await readdir(layersDir, { withFileTypes: true });
+
+  const layers = [];
+
+  for (const entry of entries) {
+    if (TODO.has(entry.name)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      const layerPath = join(layersDir, entry.name, "index.js");
+      try {
+        const layer = await import(layerPath);
+        layers.push({
+          name: entry.name,
+          ...layer.default,
+        });
+      } catch (error) {
+        if (typeof error !== "object" || error === null) {
+          console.warn(`Warning: Could not load layer ${entry.name}:`, error);
+          continue;
+        }
+        if ("message" in error) {
+          console.warn(`Warning: Could not load layer ${entry.name}:`, error.message);
+        }
+      }
+    }
+  }
+
+  return layers;
+}
+
+export const layers = await discoverLayers();
+export const layerNames = layers.map((layer) => layer.name);

package/src/layers/prettier/files/.prettierrc.js

@@ -0,0 +1,4 @@
+export default {
+  printWidth: 100,
+  plugins: ["prettier-plugin-ember-template-tag"],
+};