isolate-package 1.27.0 → 1.28.1

package/src/get-internal-package-names.test.ts

@@ -0,0 +1,213 @@
+import fs from "fs-extra";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { getInternalPackageNames } from "./get-internal-package-names";
+
+vi.mock("~/lib/logger", () => ({
+  useLogger: () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  }),
+  setLogLevel: vi.fn(),
+}));
+
+const packageManagerResult = {
+  name: "pnpm",
+  version: "9.0.0",
+  majorVersion: 9,
+};
+
+const mockDetectPackageManager = vi.fn(
+  (_workspaceRootDir: string) => packageManagerResult,
+);
+
+vi.mock("~/lib/package-manager", () => ({
+  usePackageManager: () => packageManagerResult,
+  detectPackageManager: (workspaceRootDir: string) =>
+    mockDetectPackageManager(workspaceRootDir),
+}));
+
+/**
+ * Sets up a minimal workspace file structure with a target package and
+ * workspace packages so that getInternalPackageNames can resolve them.
+ */
+async function createWorkspace(
+  rootDir: string,
+  {
+    targetDeps = {} as Record<string, string>,
+    targetDevDeps = {} as Record<string, string>,
+    packages = [] as {
+      name: string;
+      dir: string;
+      deps?: Record<string, string>;
+    }[],
+  },
+) {
+  const packagesDir = path.join(rootDir, "packages");
+  const targetDir = path.join(packagesDir, "target");
+
+  /** Write pnpm-workspace.yaml so the registry can find packages */
+  await fs.writeFile(
+    path.join(rootDir, "pnpm-workspace.yaml"),
+    "packages:\n  - packages/*\n",
+  );
+
+  /** Write a pnpm lockfile so package manager detection works */
+  await fs.writeFile(
+    path.join(rootDir, "pnpm-lock.yaml"),
+    "lockfileVersion: '9.0'\n",
+  );
+
+  /** Write target package manifest */
+  await fs.ensureDir(targetDir);
+  await fs.writeJson(path.join(targetDir, "package.json"), {
+    name: "@test/target",
+    version: "0.0.0",
+    dependencies: targetDeps,
+    devDependencies: targetDevDeps,
+  });
+
+  /** Write workspace package manifests */
+  for (const pkg of packages) {
+    const pkgDir = path.join(packagesDir, pkg.dir);
+    await fs.ensureDir(pkgDir);
+    await fs.writeJson(path.join(pkgDir, "package.json"), {
+      name: pkg.name,
+      version: "0.0.0",
+      dependencies: pkg.deps ?? {},
+    });
+  }
+
+  return targetDir;
+}
+
+describe("getInternalPackageNames", () => {
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    originalCwd = process.cwd();
+    tempDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), "isolate-get-internal-test-"),
+    );
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await fs.remove(tempDir);
+  });
+
+  it("returns internal package names from the target manifest", async () => {
+    const targetDir = await createWorkspace(tempDir, {
+      targetDeps: { "@test/shared": "0.0.0", lodash: "^4.0.0" },
+      packages: [{ name: "@test/shared", dir: "shared" }],
+    });
+
+    process.chdir(targetDir);
+
+    const result = await getInternalPackageNames({ workspaceRoot: "../.." });
+    expect(result).toEqual(["@test/shared"]);
+    expect(mockDetectPackageManager).toHaveBeenCalled();
+  });
+
+  it("excludes devDependencies by default", async () => {
+    const targetDir = await createWorkspace(tempDir, {
+      targetDeps: { "@test/shared": "0.0.0" },
+      targetDevDeps: { "@test/dev-tool": "0.0.0" },
+      packages: [
+        { name: "@test/shared", dir: "shared" },
+        { name: "@test/dev-tool", dir: "dev-tool" },
+      ],
+    });
+
+    process.chdir(targetDir);
+
+    const result = await getInternalPackageNames({ workspaceRoot: "../.." });
+    expect(result).toEqual(["@test/shared"]);
+  });
+
+  it("includes devDependencies when configured", async () => {
+    const targetDir = await createWorkspace(tempDir, {
+      targetDeps: { "@test/shared": "0.0.0" },
+      targetDevDeps: { "@test/dev-tool": "0.0.0" },
+      packages: [
+        { name: "@test/shared", dir: "shared" },
+        { name: "@test/dev-tool", dir: "dev-tool" },
+      ],
+    });
+
+    process.chdir(targetDir);
+
+    const result = await getInternalPackageNames({
+      workspaceRoot: "../..",
+      includeDevDependencies: true,
+    });
+    expect(result).toEqual(
+      expect.arrayContaining(["@test/shared", "@test/dev-tool"]),
+    );
+    expect(result).toHaveLength(2);
+  });
+
+  it("resolves recursive internal dependencies", async () => {
+    const targetDir = await createWorkspace(tempDir, {
+      targetDeps: { "@test/app-utils": "0.0.0" },
+      packages: [
+        {
+          name: "@test/app-utils",
+          dir: "app-utils",
+          deps: { "@test/core": "0.0.0" },
+        },
+        { name: "@test/core", dir: "core" },
+      ],
+    });
+
+    process.chdir(targetDir);
+
+    const result = await getInternalPackageNames({ workspaceRoot: "../.." });
+    expect(result).toEqual(
+      expect.arrayContaining(["@test/app-utils", "@test/core"]),
+    );
+    expect(result).toHaveLength(2);
+  });
+
+  it("returns an empty array when there are no internal dependencies", async () => {
+    const targetDir = await createWorkspace(tempDir, {
+      targetDeps: { lodash: "^4.0.0", express: "^4.0.0" },
+      packages: [{ name: "@test/unrelated", dir: "unrelated" }],
+    });
+
+    process.chdir(targetDir);
+
+    const result = await getInternalPackageNames({ workspaceRoot: "../.." });
+    expect(result).toEqual([]);
+  });
+
+  it("loads config from isolate.config.json when no config is passed", async () => {
+    const targetDir = await createWorkspace(tempDir, {
+      targetDeps: { "@test/shared": "0.0.0" },
+      targetDevDeps: { "@test/dev-tool": "0.0.0" },
+      packages: [
+        { name: "@test/shared", dir: "shared" },
+        { name: "@test/dev-tool", dir: "dev-tool" },
+      ],
+    });
+
+    /** Write config file with includeDevDependencies enabled */
+    await fs.writeJson(path.join(targetDir, "isolate.config.json"), {
+      workspaceRoot: "../..",
+      includeDevDependencies: true,
+    });
+
+    process.chdir(targetDir);
+
+    const result = await getInternalPackageNames();
+    expect(result).toEqual(
+      expect.arrayContaining(["@test/shared", "@test/dev-tool"]),
+    );
+    expect(result).toHaveLength(2);
+  });
+});

package/src/get-internal-package-names.ts

@@ -0,0 +1,38 @@
+import path from "node:path";
+import type { IsolateConfig } from "./lib/config";
+import { resolveConfig, resolveWorkspacePaths } from "./lib/config";
+import { detectPackageManager } from "./lib/package-manager";
+import { createPackagesRegistry, listInternalPackages } from "./lib/registry";
+import type { PackageManifest } from "./lib/types";
+import { readTypedJson } from "./lib/utils";
+
+/**
+ * Get the names of all internal workspace packages that the target package
+ * depends on. This is useful for tools like tsup that need a list of internal
+ * packages to include in `noExternal`.
+ *
+ * If no config is passed, it reads from `isolate.config.{ts,js,json}` in the
+ * current working directory.
+ */
+export async function getInternalPackageNames(
+  config?: IsolateConfig,
+): Promise<string[]> {
+  const resolvedConfig = resolveConfig(config);
+  const { targetPackageDir, workspaceRootDir } =
+    resolveWorkspacePaths(resolvedConfig);
+
+  detectPackageManager(workspaceRootDir);
+
+  const targetPackageManifest = await readTypedJson<PackageManifest>(
+    path.join(targetPackageDir, "package.json"),
+  );
+
+  const packagesRegistry = await createPackagesRegistry(
+    workspaceRootDir,
+    resolvedConfig.workspacePackages,
+  );
+
+  return listInternalPackages(targetPackageManifest, packagesRegistry, {
+    includeDevDependencies: resolvedConfig.includeDevDependencies,
+  });
+}

package/src/index.ts

@@ -1,7 +1,5 @@
-import type { isolate } from "./isolate";
 export { isolate } from "./isolate";
+export { getInternalPackageNames } from "./get-internal-package-names";
+export { defineConfig } from "./lib/config";
+export type { IsolateConfig } from "./lib/config";
 export type { Logger } from "./lib/logger";
-
-export type IsolateExports = {
-  isolate: typeof isolate;
-};

package/src/isolate-bin.ts

@@ -87,7 +87,7 @@ const cli = meow(
         type: "boolean",
       },
     },
-  }
+  },
 );
 
 async function run() {

package/src/isolate.ts

@@ -4,7 +4,7 @@ import assert from "node:assert";
 import path from "node:path";
 import { unique } from "remeda";
 import type { IsolateConfig } from "./lib/config";
-import { resolveConfig } from "./lib/config";
+import { resolveConfig, resolveWorkspacePaths } from "./lib/config";
 import { processLockfile } from "./lib/lockfile";
 import { setLogLevel, useLogger } from "./lib/logger";
 import {
@@ -44,23 +44,13 @@ export function createIsolator(config?: IsolateConfig) {
     const log = useLogger();
 
     const { version: libraryVersion } = await readTypedJson<PackageManifest>(
-      path.join(path.join(__dirname, "..", "package.json"))
+      path.join(path.join(__dirname, "..", "package.json")),
     );
 
     log.debug("Using isolate-package version", libraryVersion);
 
-    /**
-     * If a targetPackagePath is set, we assume the configuration lives in the
-     * root of the workspace. If targetPackagePath is undefined (the default),
-     * we assume that the configuration lives in the target package directory.
-     */
-    const targetPackageDir = config.targetPackagePath
-      ? path.join(process.cwd(), config.targetPackagePath)
-      : process.cwd();
-
-    const workspaceRootDir = config.targetPackagePath
-      ? process.cwd()
-      : path.join(targetPackageDir, config.workspaceRoot);
+    const { targetPackageDir, workspaceRootDir } =
+      resolveWorkspacePaths(config);
 
     const buildOutputDir = await getBuildOutputDir({
       targetPackageDir,
@@ -70,20 +60,20 @@ export function createIsolator(config?: IsolateConfig) {
 
     assert(
       fs.existsSync(buildOutputDir),
-      `Failed to find build output path at ${buildOutputDir}. Please make sure you build the source before isolating it.`
+      `Failed to find build output path at ${buildOutputDir}. Please make sure you build the source before isolating it.`,
     );
 
     log.debug("Workspace root resolved to", workspaceRootDir);
     log.debug(
       "Isolate target package",
-      getRootRelativeLogPath(targetPackageDir, workspaceRootDir)
+      getRootRelativeLogPath(targetPackageDir, workspaceRootDir),
     );
 
     const isolateDir = path.join(targetPackageDir, config.isolateDirName);
 
     log.debug(
       "Isolate output directory",
-      getRootRelativeLogPath(isolateDir, workspaceRootDir)
+      getRootRelativeLogPath(isolateDir, workspaceRootDir),
     );
 
     if (fs.existsSync(isolateDir)) {
@@ -97,13 +87,13 @@ export function createIsolator(config?: IsolateConfig) {
     await fs.ensureDir(tmpDir);
 
     const targetPackageManifest = await readTypedJson<PackageManifest>(
-      path.join(targetPackageDir, "package.json")
+      path.join(targetPackageDir, "package.json"),
     );
 
     /** Validate mandatory fields for the target package */
     validateManifestMandatoryFields(
       targetPackageManifest,
-      getRootRelativeLogPath(targetPackageDir, workspaceRootDir)
+      getRootRelativeLogPath(targetPackageDir, workspaceRootDir),
     );
 
     const packageManager = detectPackageManager(workspaceRootDir);
@@ -111,7 +101,7 @@ export function createIsolator(config?: IsolateConfig) {
     log.debug(
       "Detected package manager",
       packageManager.name,
-      packageManager.version
+      packageManager.version,
     );
 
     if (shouldUsePnpmPack()) {
@@ -124,7 +114,7 @@ export function createIsolator(config?: IsolateConfig) {
      */
     const packagesRegistry = await createPackagesRegistry(
       workspaceRootDir,
-      config.workspacePackages
+      config.workspacePackages,
     );
 
     const internalPackageNames = listInternalPackages(
@@ -132,7 +122,7 @@ export function createIsolator(config?: IsolateConfig) {
       packagesRegistry,
       {
         includeDevDependencies: config.includeDevDependencies,
-      }
+      },
     );
 
     /**
@@ -144,7 +134,7 @@ export function createIsolator(config?: IsolateConfig) {
       packagesRegistry,
       {
         includeDevDependencies: false,
-      }
+      },
     );
 
     /** Validate mandatory fields for all internal packages that will be isolated */
@@ -155,7 +145,7 @@ export function createIsolator(config?: IsolateConfig) {
       validateManifestMandatoryFields(
         packageDef.manifest,
         getRootRelativeLogPath(packageDef.absoluteDir, workspaceRootDir),
-        isProductionDependency
+        isProductionDependency,
       );
     }
 
@@ -169,7 +159,7 @@ export function createIsolator(config?: IsolateConfig) {
       packedFilesByName,
       packagesRegistry,
       tmpDir,
-      isolateDir
+      isolateDir,
     );
 
     /** Adapt the manifest files for all the unpacked local dependencies */
@@ -250,10 +240,10 @@ export function createIsolator(config?: IsolateConfig) {
           Object.entries(copiedPatches).map(([spec, patchFile]) => [
             spec,
             patchFile.path,
-          ])
+          ]),
         );
         log.debug(
-          `Added ${Object.keys(copiedPatches).length} patches to isolated package.json`
+          `Added ${Object.keys(copiedPatches).length} patches to isolated package.json`,
         );
       }
 
@@ -281,8 +271,8 @@ export function createIsolator(config?: IsolateConfig) {
         const packagesFolderNames = unique(
           internalPackageNames.map(
             (name) =>
-              path.parse(got(packagesRegistry, name).rootRelativeDir).dir
-          )
+              path.parse(got(packagesRegistry, name).rootRelativeDir).dir,
+          ),
         );
 
         log.debug("Generating pnpm-workspace.yaml for Rush workspace");
@@ -296,7 +286,7 @@ export function createIsolator(config?: IsolateConfig) {
       } else {
         fs.copyFileSync(
           path.join(workspaceRootDir, "pnpm-workspace.yaml"),
-          path.join(isolateDir, "pnpm-workspace.yaml")
+          path.join(isolateDir, "pnpm-workspace.yaml"),
         );
       }
     }
@@ -321,7 +311,7 @@ export function createIsolator(config?: IsolateConfig) {
      */
     log.debug(
       "Deleting temp directory",
-      getRootRelativeLogPath(tmpDir, workspaceRootDir)
+      getRootRelativeLogPath(tmpDir, workspaceRootDir),
     );
     await fs.remove(tmpDir);
 

package/src/lib/cli.test.ts

@@ -36,7 +36,7 @@ describe("wasFlagExplicitlyPassed", () => {
   it("detects a short flag", () => {
     const argv = ["node", "isolate", "-d"];
     expect(wasFlagExplicitlyPassed("includeDevDependencies", argv, "d")).toBe(
-      true
+      true,
     );
   });
 
@@ -70,7 +70,7 @@ describe("parseLogLevel", () => {
 
   it("throws for an invalid log level", () => {
     expect(() => parseLogLevel("verbose")).toThrow(
-      'Invalid log level: "verbose"'
+      'Invalid log level: "verbose"',
     );
   });
 });
@@ -168,7 +168,7 @@ describe("buildCliOverrides", () => {
     const flags: ParsedFlags = { ...defaultFlags, logLevel: "verbose" };
     const argv = ["node", "isolate", "--log-level", "verbose"];
     expect(() => buildCliOverrides(flags, argv)).toThrow(
-      'Invalid log level: "verbose"'
+      'Invalid log level: "verbose"',
     );
   });
 

package/src/lib/cli.ts

@@ -12,14 +12,14 @@ const validLogLevels: readonly LogLevel[] = ["info", "debug", "warn", "error"];
 export function wasFlagExplicitlyPassed(
   flagName: string,
   argv: string[],
-  shortFlag?: string
+  shortFlag?: string,
 ): boolean {
   const kebab = flagName.replace(/[A-Z]/g, (l) => `-${l.toLowerCase()}`);
   return argv.some(
     (arg) =>
       arg === `--${kebab}` ||
       arg === `--no-${kebab}` ||
-      (shortFlag !== undefined && arg === `-${shortFlag}`)
+      (shortFlag !== undefined && arg === `-${shortFlag}`),
   );
 }
 
@@ -34,7 +34,7 @@ export function parseLogLevel(value: string | undefined): LogLevel | undefined {
 
   if (!validLogLevels.includes(value as LogLevel)) {
     throw new Error(
-      `Invalid log level: "${value}". Must be one of: ${validLogLevels.join(", ")}`
+      `Invalid log level: "${value}". Must be one of: ${validLogLevels.join(", ")}`,
     );
   }
 
@@ -64,7 +64,7 @@ export type ParsedFlags = {
  */
 export function buildCliOverrides(
   flags: ParsedFlags,
-  argv: string[]
+  argv: string[],
 ): IsolateConfig {
   const logLevel = parseLogLevel(flags.logLevel);
 

package/src/lib/config.test.ts

@@ -0,0 +1,163 @@
+import fs from "fs-extra";
+import path from "node:path";
+import os from "node:os";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { defineConfig, loadConfigFromFile } from "./config";
+
+/** Shared mock logger instance so assertions can check calls. */
+const mockLogger = {
+  debug: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+};
+
+vi.mock("~/lib/logger", () => ({
+  useLogger: () => mockLogger,
+}));
+
+describe("loadConfigFromFile", () => {
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    originalCwd = process.cwd();
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "isolate-config-test-"));
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await fs.remove(tempDir);
+  });
+
+  it("returns empty object when no config file exists", () => {
+    const config = loadConfigFromFile();
+    expect(config).toEqual({});
+  });
+
+  it("loads a JSON config file", async () => {
+    await fs.writeJson(path.join(tempDir, "isolate.config.json"), {
+      isolateDirName: "output",
+      workspaceRoot: "../../..",
+    });
+
+    const config = loadConfigFromFile();
+    expect(config).toEqual({
+      isolateDirName: "output",
+      workspaceRoot: "../../..",
+    });
+  });
+
+  it("loads a TypeScript config file", async () => {
+    await fs.writeFile(
+      path.join(tempDir, "isolate.config.ts"),
+      `export default { isolateDirName: "from-ts", workspaceRoot: "../.." };`,
+    );
+
+    const config = loadConfigFromFile();
+    expect(config).toEqual({
+      isolateDirName: "from-ts",
+      workspaceRoot: "../..",
+    });
+  });
+
+  it("loads a TypeScript config file that uses defineConfig", async () => {
+    /**
+     * The subprocess can't import from "isolate-package" since it's not
+     * installed in the temp dir, so we inline the defineConfig identity
+     * function to verify the pattern works end-to-end.
+     */
+    await fs.writeFile(
+      path.join(tempDir, "isolate.config.ts"),
+      [
+        `const defineConfig = (c: Record<string, unknown>) => c;`,
+        `export default defineConfig({ isolateDirName: "defined" });`,
+      ].join("\n"),
+    );
+
+    const config = loadConfigFromFile();
+    expect(config).toEqual({ isolateDirName: "defined" });
+  });
+
+  it("loads a JavaScript config file", async () => {
+    await fs.writeFile(
+      path.join(tempDir, "isolate.config.js"),
+      `export default { isolateDirName: "from-js", workspaceRoot: "../.." };`,
+    );
+
+    const config = loadConfigFromFile();
+    expect(config).toEqual({
+      isolateDirName: "from-js",
+      workspaceRoot: "../..",
+    });
+  });
+
+  it("prefers TypeScript config and warns when multiple exist", async () => {
+    await fs.writeJson(path.join(tempDir, "isolate.config.json"), {
+      isolateDirName: "from-json",
+    });
+    await fs.writeFile(
+      path.join(tempDir, "isolate.config.ts"),
+      `export default { isolateDirName: "from-ts" };`,
+    );
+
+    const config = loadConfigFromFile();
+    expect(config).toEqual({ isolateDirName: "from-ts" });
+    expect(mockLogger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("Found multiple config files"),
+    );
+  });
+
+  it("prefers JavaScript config over JSON", async () => {
+    await fs.writeJson(path.join(tempDir, "isolate.config.json"), {
+      isolateDirName: "from-json",
+    });
+    await fs.writeFile(
+      path.join(tempDir, "isolate.config.js"),
+      `export default { isolateDirName: "from-js" };`,
+    );
+
+    const config = loadConfigFromFile();
+    expect(config).toEqual({ isolateDirName: "from-js" });
+    expect(mockLogger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("Found multiple config files"),
+    );
+  });
+
+  it("throws when the config file has no default export", async () => {
+    await fs.writeFile(
+      path.join(tempDir, "isolate.config.ts"),
+      `export const config = { isolateDirName: "oops" };`,
+    );
+
+    expect(() => loadConfigFromFile()).toThrow("Failed to load config from");
+  });
+
+  it("throws when the default export is not an object", async () => {
+    await fs.writeFile(
+      path.join(tempDir, "isolate.config.ts"),
+      `export default "not an object";`,
+    );
+
+    expect(() => loadConfigFromFile()).toThrow("Failed to load config from");
+  });
+
+  it("throws when the TypeScript file has a syntax error", async () => {
+    await fs.writeFile(
+      path.join(tempDir, "isolate.config.ts"),
+      `export default {{{`,
+    );
+
+    expect(() => loadConfigFromFile()).toThrow("Failed to load config from");
+  });
+});
+
+describe("defineConfig", () => {
+  it("returns the config object unchanged", () => {
+    const input = { isolateDirName: "output", workspaceRoot: "../.." };
+    const result = defineConfig(input);
+    expect(result).toBe(input);
+  });
+});