@pob/rollup 8.3.0 → 8.5.0

package/lib/index.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
+import { setTimeout } from "node:timers/promises";
 
 export const nodeFormatToExt = (format, pkgType) => {
   if (format === "cjs" && pkgType === "module") return ".cjs";
@@ -62,27 +63,130 @@ export const createSourceWorkspaceDependencies = (cwd, pkg) => {
     }
   };
 
-  const dependencies = Object.entries(pkg.dependencies || {})
-    .filter(([, version]) => version.startsWith("workspace:"))
-    .flatMap(([name]) => {
-      const entryPath = resolve(name);
-      if (!entryPath || !sourceExtensionRegExp.test(entryPath)) return [];
-      return [{ name, pkg: readClosestPackageJson(entryPath) }];
-    });
+  const findSourceDependencies = (dependencies = {}) =>
+    Object.entries(dependencies)
+      .filter(([, version]) => version.startsWith("workspace:"))
+      .flatMap(([name]) => {
+        const entryPath = resolve(name);
+        if (!entryPath || !sourceExtensionRegExp.test(entryPath)) return [];
+        return [{ name, pkg: readClosestPackageJson(entryPath) }];
+      });
+
+  const dependencies = findSourceDependencies(pkg.dependencies);
+  // bundled as well, so the build still works, but reported: a package the
+  // build imports belongs in dependencies
+  const devDependencies = findSourceDependencies(pkg.devDependencies).filter(
+    ({ name }) => !pkg.dependencies?.[name],
+  );
+  const allDependencies = [...dependencies, ...devDependencies];
+  const warnedDevDependencies = new Set();
+
+  const findDependency = (list, id) =>
+    list.find(({ name }) => id === name || id.startsWith(`${name}/`));
 
   const isSourceWorkspaceDependency = (id) =>
-    dependencies.some(({ name }) => id === name || id.startsWith(`${name}/`));
+    findDependency(allDependencies, id) !== undefined;
 
   return {
     isSourceWorkspaceDependency,
     // their own dependencies stay external
-    pkgs: dependencies.map((dependency) => dependency.pkg),
+    pkgs: allDependencies.map((dependency) => dependency.pkg),
     plugin: {
       name: "@pob/rollup/source-workspace-dependencies",
       resolveId(source) {
         if (!isSourceWorkspaceDependency(source)) return null;
+        const devDependency = findDependency(devDependencies, source);
+        if (devDependency && !warnedDevDependencies.has(devDependency.name)) {
+          warnedDevDependencies.add(devDependency.name);
+          this.warn(
+            `"${devDependency.name}" is imported but listed in devDependencies: move it to dependencies.`,
+          );
+        }
         return resolve(source) ?? null;
       },
     },
   };
 };
+
+const nodeImportConditions = new Set(["node", "import", "default"]);
+
+const resolveExportTarget = (target) => {
+  if (typeof target === "string") return target;
+  if (!target || typeof target !== "object" || Array.isArray(target)) {
+    return undefined;
+  }
+  for (const [condition, value] of Object.entries(target)) {
+    if (nodeImportConditions.has(condition)) {
+      const resolved = resolveExportTarget(value);
+      if (resolved) return resolved;
+    }
+  }
+  return undefined;
+};
+
+/** the file node imports for the package's main entry */
+const getMainEntry = (pkg) => {
+  const { exports } = pkg;
+  if (exports === undefined) return pkg.module ?? pkg.main;
+  if (typeof exports === "string") return exports;
+  const isSubpathMap = Object.keys(exports).some((key) => key.startsWith("."));
+  return resolveExportTarget(isSubpathMap ? exports["."] : exports);
+};
+
+const dependencyPollIntervalMs = 100;
+const dependencySlowAfterMs = 5000;
+
+const waitForFile = async (file, onSlow) => {
+  let waitedMs = 0;
+  while (!fs.existsSync(file)) {
+    if (waitedMs === dependencySlowAfterMs) onSlow();
+    await setTimeout(dependencyPollIntervalMs);
+    waitedMs += dependencyPollIntervalMs;
+  }
+};
+
+const findDependencyPackageJson = (cwd, name) => {
+  let directory = cwd;
+  while (true) {
+    const pkgPath = path.join(directory, "node_modules", name, "package.json");
+    if (fs.existsSync(pkgPath)) return fs.realpathSync(pkgPath);
+    if (directory === path.dirname(directory)) return undefined;
+    directory = path.dirname(directory);
+  }
+};
+
+/**
+ * Workspace dependencies imported from their build stay external, and node
+ * loads them once: the process started by the run plugin would keep running a
+ * stale build of them. Watching their entry rebuilds, and so restarts it, each
+ * time one of them is rebuilt. A watched file that gets deleted, by the
+ * `clean:build` of its package, is no longer watched once recreated: the
+ * rebuild its deletion triggers waits for it to come back, and watches the new
+ * one.
+ */
+export const createWatchWorkspaceDependencies = (cwd, pkg) => {
+  const builtEntries = Object.entries(pkg.dependencies || {})
+    .filter(([, version]) => version.startsWith("workspace:"))
+    .flatMap(([name]) => {
+      const dependencyPkgPath = findDependencyPackageJson(cwd, name);
+      if (!dependencyPkgPath) return [];
+      const entry = getMainEntry(
+        JSON.parse(fs.readFileSync(dependencyPkgPath)),
+      );
+      if (!entry || sourceExtensionRegExp.test(entry)) return [];
+      return [path.resolve(path.dirname(dependencyPkgPath), entry)];
+    });
+
+  return {
+    name: "@pob/rollup/watch-workspace-dependencies",
+    async buildStart() {
+      if (!this.meta.watchMode) return;
+      for (const entry of builtEntries) {
+        await waitForFile(entry, () => {
+          this.warn(`Waiting for ${entry} to be built`);
+        });
+        this.addWatchFile(entry);
+      }
+    },
+  };
+};

package/lib/index.test.js

@@ -0,0 +1,186 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  createSourceWorkspaceDependencies,
+  createWatchWorkspaceDependencies,
+} from "./index.js";
+
+const writeJson = (filePath, value) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value));
+};
+
+describe("createSourceWorkspaceDependencies", () => {
+  let root;
+  let appDirectory;
+
+  const addWorkspacePackage = (name, pkg) => {
+    const directory = path.join(root, "packages", name);
+    writeJson(path.join(directory, "package.json"), { name, ...pkg });
+    fs.mkdirSync(path.join(directory, "src"), { recursive: true });
+    fs.writeFileSync(path.join(directory, "src/index.ts"), "export {};");
+    fs.mkdirSync(path.join(root, "node_modules"), { recursive: true });
+    fs.symlinkSync(directory, path.join(root, "node_modules", name), "dir");
+    return fs.realpathSync(directory);
+  };
+
+  const resolveImports = (pkg, sources) => {
+    const warn = vi.fn();
+    const { plugin } = createSourceWorkspaceDependencies(appDirectory, pkg);
+    const resolved = sources.map((source) =>
+      plugin.resolveId.call({ warn }, source),
+    );
+    return { resolved, warnings: warn.mock.calls.map(([message]) => message) };
+  };
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "pob-rollup-"));
+    appDirectory = path.join(root, "packages", "app");
+    fs.mkdirSync(appDirectory, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("resolves a source dependency to its source, without warning", () => {
+    const shared = addWorkspacePackage("shared", { exports: "./src/index.ts" });
+
+    expect(
+      resolveImports({ dependencies: { shared: "workspace:*" } }, ["shared"]),
+    ).toEqual({
+      resolved: [path.join(shared, "src/index.ts")],
+      warnings: [],
+    });
+  });
+
+  it("resolves a source devDependency, warning once to move it", () => {
+    const shared = addWorkspacePackage("shared", { exports: "./src/index.ts" });
+
+    expect(
+      resolveImports({ devDependencies: { shared: "workspace:*" } }, [
+        "shared",
+        "shared",
+      ]),
+    ).toEqual({
+      resolved: [
+        path.join(shared, "src/index.ts"),
+        path.join(shared, "src/index.ts"),
+      ],
+      warnings: [
+        '"shared" is imported but listed in devDependencies: move it to dependencies.',
+      ],
+    });
+  });
+
+  it("leaves other imports to the other resolvers", () => {
+    addWorkspacePackage("shared", { exports: "./src/index.ts" });
+
+    expect(
+      resolveImports({ dependencies: { shared: "workspace:*" } }, ["other"]),
+    ).toEqual({ resolved: [null], warnings: [] });
+  });
+});
+
+describe("createWatchWorkspaceDependencies", () => {
+  let root;
+  let appDirectory;
+
+  /** a workspace package, linked in the root node_modules as pnpm hoists it */
+  const addWorkspacePackage = (name, pkg) => {
+    const directory = path.join(root, "packages", name);
+    writeJson(path.join(directory, "package.json"), { name, ...pkg });
+    fs.mkdirSync(path.join(root, "node_modules"), { recursive: true });
+    fs.symlinkSync(directory, path.join(root, "node_modules", name), "dir");
+    return fs.realpathSync(directory);
+  };
+
+  const watchedFiles = async (pkg, { watchMode = true } = {}) => {
+    const addWatchFile = vi.fn();
+    await createWatchWorkspaceDependencies(appDirectory, pkg).buildStart.call({
+      meta: { watchMode },
+      addWatchFile,
+      warn: vi.fn(),
+    });
+    return addWatchFile.mock.calls.map(([file]) => file);
+  };
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "pob-rollup-"));
+    appDirectory = path.join(root, "packages", "app");
+    fs.mkdirSync(appDirectory, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("watches the build node imports of each workspace dependency", async () => {
+    const core = addWorkspacePackage("core", {
+      exports: {
+        "./package.json": "./package.json",
+        ".": {
+          types: "./src/index.ts",
+          node: { import: "./build/index-node.mjs" },
+        },
+      },
+    });
+    const legacy = addWorkspacePackage("legacy", { main: "./dist/index.js" });
+    const builtFiles = [
+      path.join(core, "build/index-node.mjs"),
+      path.join(legacy, "dist/index.js"),
+    ];
+    builtFiles.forEach((builtFile) => {
+      fs.mkdirSync(path.dirname(builtFile));
+      fs.writeFileSync(builtFile, "export {};");
+    });
+
+    expect(
+      await watchedFiles({
+        dependencies: { core: "workspace:*", legacy: "workspace:^" },
+      }),
+    ).toEqual(builtFiles);
+  });
+
+  it("leaves out sources, registry dependencies and unknown packages", async () => {
+    addWorkspacePackage("untranspiled", { exports: "./src/index.ts" });
+    addWorkspacePackage("published", { main: "./index.js" });
+
+    expect(
+      await watchedFiles({
+        dependencies: {
+          untranspiled: "workspace:*",
+          published: "1.0.0",
+          missing: "workspace:*",
+        },
+      }),
+    ).toEqual([]);
+  });
+
+  it("watches nothing outside watch mode", async () => {
+    addWorkspacePackage("core", { main: "./build/index.js" });
+
+    expect(
+      await watchedFiles(
+        { dependencies: { core: "workspace:*" } },
+        { watchMode: false },
+      ),
+    ).toEqual([]);
+  });
+
+  it("waits for a dependency being rebuilt before watching it", async () => {
+    const core = addWorkspacePackage("core", { main: "./build/index.js" });
+    const builtFile = path.join(core, "build/index.js");
+    setTimeout(() => {
+      fs.mkdirSync(path.dirname(builtFile));
+      fs.writeFileSync(builtFile, "export {};");
+    }, 150);
+
+    expect(
+      await watchedFiles({ dependencies: { core: "workspace:*" } }),
+    ).toEqual([builtFile]);
+    expect(fs.existsSync(builtFile)).toBe(true);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pob/rollup",
-  "version": "8.3.0",
+  "version": "8.5.0",
   "description": "rollup configuration for pob",
   "keywords": [],
   "homepage": "https://github.com/christophehurpeau/pob",