isolate-package 1.27.0 → 1.28.1

package/src/lib/config.ts

@@ -1,5 +1,7 @@
+import { execFileSync } from "node:child_process";
 import fs from "fs-extra";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { isEmpty } from "remeda";
 import { type LogLevel, setLogLevel, useLogger } from "./logger";
 import { inspectValue, readTypedJsonSync } from "./utils";
@@ -37,19 +39,126 @@ const configDefaults: IsolateConfigResolved = {
 };
 
 const validConfigKeys = Object.keys(configDefaults);
-const CONFIG_FILE_NAME = "isolate.config.json";
+const CONFIG_FILE_NAME_TS = "isolate.config.ts";
+const CONFIG_FILE_NAME_JS = "isolate.config.js";
+const CONFIG_FILE_NAME_JSON = "isolate.config.json";
+
+/**
+ * Load a JS or TS config file by spawning a Node subprocess. For TS files,
+ * --experimental-strip-types is added so Node can handle TypeScript natively.
+ * This keeps the function synchronous while allowing us to import the module.
+ */
+const CONFIG_JSON_DELIMITER = "__ISOLATE_CONFIG_JSON__";
+
+function loadModuleConfig(filePath: string): IsolateConfig {
+  const fileUrl = pathToFileURL(filePath).href;
+  const isTypeScript = filePath.endsWith(".ts");
+  const script = `import(process.argv[1])
+    .then(m => {
+      if (m.default === undefined) {
+        process.stderr.write("Config file has no default export");
+        process.exit(1);
+      }
+      process.stdout.write("${CONFIG_JSON_DELIMITER}" + JSON.stringify(m.default) + "${CONFIG_JSON_DELIMITER}");
+    })
+    .catch(err => {
+      process.stderr.write(String(err));
+      process.exit(1);
+    })`;
+
+  try {
+    const result = execFileSync(
+      process.execPath,
+      [
+        ...(isTypeScript ? ["--experimental-strip-types"] : []),
+        "--no-warnings",
+        "--input-type=module",
+        "-e",
+        script,
+        fileUrl,
+      ],
+      { encoding: "utf8" },
+    );
+
+    const jsonMatch = result.split(CONFIG_JSON_DELIMITER)[1];
+
+    if (jsonMatch === undefined) {
+      throw new Error("Failed to extract config JSON from subprocess output");
+    }
+
+    const parsed = JSON.parse(jsonMatch);
+
+    if (
+      typeof parsed !== "object" ||
+      parsed === null ||
+      Array.isArray(parsed)
+    ) {
+      throw new Error(
+        `Expected default export to be an object, got ${typeof parsed}`,
+      );
+    }
+
+    return parsed;
+  } catch (error) {
+    const stderr =
+      error instanceof Error && "stderr" in error
+        ? String(error.stderr).trim()
+        : "";
+    const detail = stderr || (error instanceof Error ? error.message : "");
+    throw new Error(
+      `Failed to load config from ${filePath}${detail ? `: ${detail}` : ""}`,
+      { cause: error },
+    );
+  }
+}
 
 export function loadConfigFromFile(): IsolateConfig {
-  const configFilePath = path.join(process.cwd(), CONFIG_FILE_NAME);
-  return fs.existsSync(configFilePath)
-    ? readTypedJsonSync<IsolateConfig>(configFilePath)
-    : {};
+  const log = useLogger();
+  const cwd = process.cwd();
+  const tsConfigPath = path.join(cwd, CONFIG_FILE_NAME_TS);
+  const jsConfigPath = path.join(cwd, CONFIG_FILE_NAME_JS);
+  const jsonConfigPath = path.join(cwd, CONFIG_FILE_NAME_JSON);
+
+  const tsExists = fs.existsSync(tsConfigPath);
+  const jsExists = fs.existsSync(jsConfigPath);
+  const jsonExists = fs.existsSync(jsonConfigPath);
+
+  const existingFiles = [
+    tsExists && CONFIG_FILE_NAME_TS,
+    jsExists && CONFIG_FILE_NAME_JS,
+    jsonExists && CONFIG_FILE_NAME_JSON,
+  ].filter(Boolean);
+
+  if (existingFiles.length > 1) {
+    log.warn(
+      `Found multiple config files: ${existingFiles.join(", ")}. Using ${existingFiles[0]}.`,
+    );
+  }
+
+  if (tsExists) {
+    return loadModuleConfig(tsConfigPath);
+  }
+
+  if (jsExists) {
+    return loadModuleConfig(jsConfigPath);
+  }
+
+  if (jsonExists) {
+    return readTypedJsonSync<IsolateConfig>(jsonConfigPath);
+  }
+
+  return {};
+}
+
+/** Helper for type-safe configuration in isolate.config.ts files. */
+export function defineConfig(config: IsolateConfig): IsolateConfig {
+  return config;
 }
 
 function validateConfig(config: IsolateConfig) {
   const log = useLogger();
   const foreignKeys = Object.keys(config).filter(
-    (key) => !validConfigKeys.includes(key)
+    (key) => !validConfigKeys.includes(key),
   );
 
   if (!isEmpty(foreignKeys)) {
@@ -57,8 +166,25 @@ function validateConfig(config: IsolateConfig) {
   }
 }
 
+/**
+ * Resolve the target package directory and workspace root directory from the
+ * configuration. When targetPackagePath is set, the config is assumed to live
+ * at the workspace root. Otherwise it lives in the target package directory.
+ */
+export function resolveWorkspacePaths(config: IsolateConfigResolved) {
+  const targetPackageDir = config.targetPackagePath
+    ? path.join(process.cwd(), config.targetPackagePath)
+    : process.cwd();
+
+  const workspaceRootDir = config.targetPackagePath
+    ? process.cwd()
+    : path.join(targetPackageDir, config.workspaceRoot);
+
+  return { targetPackageDir, workspaceRootDir };
+}
+
 export function resolveConfig(
-  initialConfig?: IsolateConfig
+  initialConfig?: IsolateConfig,
 ): IsolateConfigResolved {
   setLogLevel(process.env.DEBUG_ISOLATE_CONFIG ? "debug" : "info");
   const log = useLogger();
@@ -68,7 +194,7 @@ export function resolveConfig(
   if (initialConfig) {
     log.debug(`Using user defined config:`, inspectValue(initialConfig));
   } else {
-    log.debug(`Loaded config from ${CONFIG_FILE_NAME}`);
+    log.debug(`Loaded config from file`);
   }
 
   validateConfig(userConfig);

package/src/lib/lockfile/helpers/generate-pnpm-lockfile.ts

@@ -61,7 +61,7 @@ export async function generatePnpmLockfile({
             : workspaceRootDir,
           {
             ignoreIncompatible: false,
-          }
+          },
         )
       : await readWantedLockfile_v8(
           isRush
@@ -69,7 +69,7 @@ export async function generatePnpmLockfile({
             : workspaceRootDir,
           {
             ignoreIncompatible: false,
-          }
+          },
         );
 
     assert(lockfile, `No input lockfile found at ${workspaceRootDir}`);
@@ -84,7 +84,7 @@ export async function generatePnpmLockfile({
         assert(pkg, `Package ${name} not found in packages registry`);
 
         return [name, pkg.rootRelativeDir];
-      })
+      }),
     );
 
     const relevantImporterIds = [
@@ -115,12 +115,12 @@ export async function generatePnpmLockfile({
      * only for parsing.
      */
     const relevantImporterIdsWithPrefix = relevantImporterIds.map((x) =>
-      isRush ? `../../${x}` : x
+      isRush ? `../../${x}` : x,
     );
 
     lockfile.importers = Object.fromEntries(
       Object.entries(
-        pick(lockfile.importers, relevantImporterIdsWithPrefix)
+        pick(lockfile.importers, relevantImporterIdsWithPrefix),
       ).map(([prefixedImporterId, importer]) => {
         const importerId = isRush
           ? prefixedImporterId.replace("../../", "")
@@ -147,7 +147,7 @@ export async function generatePnpmLockfile({
             directoryByPackageName,
           }),
         ];
-      })
+      }),
     );
 
     log.debug("Pruning the lockfile");

package/src/lib/lockfile/helpers/pnpm-map-importer.ts

@@ -14,14 +14,14 @@ export function pnpmMapImporter(
   }: {
     includeDevDependencies: boolean;
     directoryByPackageName: { [packageName: string]: string };
-  }
+  },
 ): ProjectSnapshot {
   return {
     dependencies: dependencies
       ? pnpmMapDependenciesLinks(
           importerPath,
           dependencies,
-          directoryByPackageName
+          directoryByPackageName,
         )
       : undefined,
     devDependencies:
@@ -29,7 +29,7 @@ export function pnpmMapImporter(
         ? pnpmMapDependenciesLinks(
             importerPath,
             devDependencies,
-            directoryByPackageName
+            directoryByPackageName,
           )
         : undefined,
     ...rest,
@@ -44,7 +44,7 @@ export function pnpmMapImporter(
 function pnpmMapDependenciesLinks(
   importerPath: string,
   def: ResolvedDependencies,
-  directoryByPackageName: { [packageName: string]: string }
+  directoryByPackageName: { [packageName: string]: string },
 ): ResolvedDependencies {
   return Object.fromEntries(
     Object.entries(def).flatMap(([key, value]) => {
@@ -73,6 +73,6 @@ function pnpmMapDependenciesLinks(
         : `link:./${relativePath}`;
 
       return [[key, linkValue]];
-    })
+    }),
   );
 }

package/src/lib/lockfile/process-lockfile.ts

@@ -69,7 +69,7 @@ export async function processLockfile({
         });
       } else {
         log.warn(
-          "Detected modern version of Yarn. Using NPM lockfile fallback."
+          "Detected modern version of Yarn. Using NPM lockfile fallback.",
         );
 
         await generateNpmLockfile({
@@ -98,7 +98,7 @@ export async function processLockfile({
     }
     case "bun": {
       log.warn(
-        `Ouput lockfiles for Bun are not yet supported. Using NPM for output`
+        `Ouput lockfiles for Bun are not yet supported. Using NPM for output`,
       );
       await generateNpmLockfile({
         workspaceRootDir,
@@ -110,7 +110,7 @@ export async function processLockfile({
     }
     default:
       log.warn(
-        `Unexpected package manager ${name as string}. Using NPM for output`
+        `Unexpected package manager ${name as string}. Using NPM for output`,
       );
       await generateNpmLockfile({
         workspaceRootDir,

package/src/lib/manifest/adapt-target-package-manifest.ts

@@ -46,7 +46,7 @@ export async function adaptTargetPackageManifest({
     ...inputManifest,
     dependencies: await resolveCatalogDependencies(
       inputManifest.dependencies,
-      workspaceRootDir
+      workspaceRootDir,
     ),
   };
 
@@ -59,7 +59,7 @@ export async function adaptTargetPackageManifest({
          */
         await adoptPnpmFieldsFromRoot(
           manifestWithResolvedCatalogs,
-          workspaceRootDir
+          workspaceRootDir,
         )
       : /** For other package managers we replace the links to internal dependencies */
         adaptManifestInternalDeps({

package/src/lib/manifest/helpers/adapt-internal-package-manifests.ts

@@ -39,7 +39,7 @@ export async function adaptInternalPackageManifests({
         ...strippedManifest,
         dependencies: await resolveCatalogDependencies(
           strippedManifest.dependencies,
-          workspaceRootDir
+          workspaceRootDir,
         ),
       };
 
@@ -59,8 +59,8 @@ export async function adaptInternalPackageManifests({
 
       await writeManifest(
         path.join(isolateDir, rootRelativeDir),
-        outputManifest
+        outputManifest,
       );
-    })
+    }),
   );
 }

package/src/lib/manifest/helpers/adapt-manifest-internal-deps.ts

@@ -23,14 +23,14 @@ export function adaptManifestInternalDeps({
       ? patchInternalEntries(
           dependencies,
           packagesRegistry,
-          parentRootRelativeDir
+          parentRootRelativeDir,
         )
       : undefined,
     devDependencies: devDependencies
       ? patchInternalEntries(
           devDependencies,
           packagesRegistry,
-          parentRootRelativeDir
+          parentRootRelativeDir,
         )
       : undefined,
   };

package/src/lib/manifest/helpers/adopt-pnpm-fields-from-root.test.ts

@@ -13,7 +13,7 @@ vi.mock("~/lib/utils", () => ({
 }));
 
 const { isRushWorkspace, readTypedJson } = vi.mocked(
-  await import("~/lib/utils")
+  await import("~/lib/utils"),
 );
 
 describe("adoptPnpmFieldsFromRoot", () => {

package/src/lib/manifest/helpers/adopt-pnpm-fields-from-root.ts

@@ -10,14 +10,14 @@ import { isRushWorkspace, readTypedJson } from "~/lib/utils";
  */
 export async function adoptPnpmFieldsFromRoot(
   targetPackageManifest: PackageManifest,
-  workspaceRootDir: string
+  workspaceRootDir: string,
 ): Promise<PackageManifest> {
   if (isRushWorkspace(workspaceRootDir)) {
     return targetPackageManifest;
   }
 
   const rootPackageManifest = await readTypedJson<ProjectManifest>(
-    path.join(workspaceRootDir, "package.json")
+    path.join(workspaceRootDir, "package.json"),
   );
 
   const { overrides, onlyBuiltDependencies, ignoredBuiltDependencies } =

package/src/lib/manifest/helpers/patch-internal-entries.ts

@@ -6,7 +6,7 @@ import type { PackagesRegistry } from "../../types";
 export function patchInternalEntries(
   dependencies: Record<string, string>,
   packagesRegistry: PackagesRegistry,
-  parentRootRelativeDir?: string
+  parentRootRelativeDir?: string,
 ) {
   const log = useLogger();
   const allWorkspacePackageNames = Object.keys(packagesRegistry);
@@ -37,6 +37,6 @@ export function patchInternalEntries(
       } else {
         return [key, value];
       }
-    })
+    }),
   );
 }

package/src/lib/manifest/helpers/resolve-catalog-dependencies.ts

@@ -14,7 +14,7 @@ import { readTypedJson } from "~/lib/utils";
  */
 export async function resolveCatalogDependencies(
   dependencies: Record<string, string> | undefined,
-  workspaceRootDir: string
+  workspaceRootDir: string,
 ): Promise<Record<string, string> | undefined> {
   if (!dependencies) {
     return undefined;
@@ -61,12 +61,12 @@ export async function resolveCatalogDependencies(
 
       if (catalogVersion) {
         log.debug(
-          `Resolving catalog dependency ${packageName}: "${specifier}" -> "${catalogVersion}"`
+          `Resolving catalog dependency ${packageName}: "${specifier}" -> "${catalogVersion}"`,
         );
         resolved[packageName] = catalogVersion;
       } else {
         log.warn(
-          `Catalog dependency ${packageName} references "${specifier}" but it's not found in the catalog. Keeping original specifier.`
+          `Catalog dependency ${packageName} references "${specifier}" but it's not found in the catalog. Keeping original specifier.`,
         );
       }
     }

package/src/lib/manifest/io.ts

@@ -9,10 +9,10 @@ export async function readManifest(packageDir: string) {
 
 export async function writeManifest(
   outputDir: string,
-  manifest: PackageManifest
+  manifest: PackageManifest,
 ) {
   await fs.writeFile(
     path.join(outputDir, "package.json"),
-    JSON.stringify(manifest, null, 2)
+    JSON.stringify(manifest, null, 2),
   );
 }

package/src/lib/manifest/validate-manifest.test.ts

@@ -21,7 +21,7 @@ describe("validateManifestMandatoryFields", () => {
     };
 
     expect(() =>
-      validateManifestMandatoryFields(validManifest, packagePath)
+      validateManifestMandatoryFields(validManifest, packagePath),
     ).not.toThrow();
   });
 
@@ -32,7 +32,7 @@ describe("validateManifestMandatoryFields", () => {
     };
 
     expect(() =>
-      validateManifestMandatoryFields(devPackageManifest, packagePath, false)
+      validateManifestMandatoryFields(devPackageManifest, packagePath, false),
     ).not.toThrow();
   });
 
@@ -42,7 +42,7 @@ describe("validateManifestMandatoryFields", () => {
     } as PackageManifest;
 
     expect(() =>
-      validateManifestMandatoryFields(invalidDevManifest, packagePath, false)
+      validateManifestMandatoryFields(invalidDevManifest, packagePath, false),
     ).toThrow(/missing mandatory fields: version/);
   });
 
@@ -53,7 +53,7 @@ describe("validateManifestMandatoryFields", () => {
     } as PackageManifest;
 
     expect(() =>
-      validateManifestMandatoryFields(invalidManifest, packagePath)
+      validateManifestMandatoryFields(invalidManifest, packagePath),
     ).toThrow(/missing mandatory fields: version/);
   });
 
@@ -64,7 +64,7 @@ describe("validateManifestMandatoryFields", () => {
     } as PackageManifest;
 
     expect(() =>
-      validateManifestMandatoryFields(invalidManifest, packagePath)
+      validateManifestMandatoryFields(invalidManifest, packagePath),
     ).toThrow(/missing mandatory fields: files/);
   });
 
@@ -76,7 +76,7 @@ describe("validateManifestMandatoryFields", () => {
     };
 
     expect(() =>
-      validateManifestMandatoryFields(invalidManifest, packagePath)
+      validateManifestMandatoryFields(invalidManifest, packagePath),
     ).toThrow(/missing mandatory fields: files/);
   });
 
@@ -88,7 +88,7 @@ describe("validateManifestMandatoryFields", () => {
     };
 
     expect(() =>
-      validateManifestMandatoryFields(invalidManifest, packagePath)
+      validateManifestMandatoryFields(invalidManifest, packagePath),
     ).toThrow(/missing mandatory fields: files/);
   });
 
@@ -98,7 +98,7 @@ describe("validateManifestMandatoryFields", () => {
     } as PackageManifest;
 
     expect(() =>
-      validateManifestMandatoryFields(invalidManifest, packagePath)
+      validateManifestMandatoryFields(invalidManifest, packagePath),
     ).toThrow(/missing mandatory fields: version, files/);
   });
 
@@ -108,11 +108,11 @@ describe("validateManifestMandatoryFields", () => {
     } as PackageManifest;
 
     expect(() =>
-      validateManifestMandatoryFields(invalidManifest, packagePath)
+      validateManifestMandatoryFields(invalidManifest, packagePath),
     ).toThrow(/missing mandatory fields: version, files/);
 
     expect(() =>
-      validateManifestMandatoryFields(invalidManifest, packagePath)
+      validateManifestMandatoryFields(invalidManifest, packagePath),
     ).toThrow(/See the documentation for more details/);
   });
 });

package/src/lib/manifest/validate-manifest.ts

@@ -14,7 +14,7 @@ import type { PackageManifest } from "../types";
 export function validateManifestMandatoryFields(
   manifest: PackageManifest,
   packagePath: string,
-  requireFilesField = true
+  requireFilesField = true,
 ): void {
   const log = useLogger();
   const missingFields: string[] = [];

package/src/lib/output/unpack-dependencies.ts

@@ -9,7 +9,7 @@ export async function unpackDependencies(
   packedFilesByName: Record<string, string>,
   packagesRegistry: PackagesRegistry,
   tmpDir: string,
-  isolateDir: string
+  isolateDir: string,
 ) {
   const log = useLogger();
 
@@ -33,9 +33,9 @@ export async function unpackDependencies(
       log.debug(
         `Moved package files to ${getIsolateRelativeLogPath(
           destinationDir,
-          isolateDir
-        )}`
+          isolateDir,
+        )}`,
       );
-    })
+    }),
   );
 }

package/src/lib/package-manager/helpers/infer-from-files.ts

@@ -18,7 +18,7 @@ export function inferFromFiles(workspaceRoot: string): PackageManager {
       } catch (err) {
         throw new Error(
           `Failed to find package manager version for ${name}: ${getErrorMessage(err)}`,
-          { cause: err }
+          { cause: err },
         );
       }
     }

package/src/lib/package-manager/helpers/infer-from-manifest.ts

@@ -13,7 +13,7 @@ export function inferFromManifest(workspaceRoot: string) {
 
   const { packageManager: packageManagerString } =
     readTypedJsonSync<PackageManifest>(
-      path.join(workspaceRoot, "package.json")
+      path.join(workspaceRoot, "package.json"),
     );
 
   if (!packageManagerString) {
@@ -28,14 +28,14 @@ export function inferFromManifest(workspaceRoot: string) {
 
   assert(
     supportedPackageManagerNames.includes(name),
-    `Package manager "${name}" is not currently supported`
+    `Package manager "${name}" is not currently supported`,
   );
 
   const lockfileName = getLockfileFileName(name);
 
   assert(
     fs.existsSync(path.join(workspaceRoot, lockfileName)),
-    `Manifest declares ${name} to be the packageManager, but failed to find ${lockfileName} in workspace root`
+    `Manifest declares ${name} to be the packageManager, but failed to find ${lockfileName} in workspace root`,
   );
 
   return {

package/src/lib/package-manager/index.ts

@@ -10,7 +10,7 @@ let packageManager: PackageManager | undefined;
 export function usePackageManager() {
   if (!packageManager) {
     throw Error(
-      "No package manager detected. Make sure to call detectPackageManager() before usePackageManager()"
+      "No package manager detected. Make sure to call detectPackageManager() before usePackageManager()",
     );
   }
 
@@ -25,7 +25,7 @@ export function usePackageManager() {
 export function detectPackageManager(workspaceRootDir: string): PackageManager {
   if (isRushWorkspace(workspaceRootDir)) {
     packageManager = inferFromFiles(
-      path.join(workspaceRootDir, "common/config/rush")
+      path.join(workspaceRootDir, "common/config/rush"),
     );
   } else {
     /**

package/src/lib/patches/copy-patches.test.ts

@@ -46,7 +46,7 @@ vi.mock("~/lib/logger", () => ({
 
 const fs = vi.mocked((await import("fs-extra")).default);
 const { filterPatchedDependencies, readTypedJson } = vi.mocked(
-  await import("~/lib/utils")
+  await import("~/lib/utils"),
 );
 
 describe("copyPatches", () => {
@@ -146,7 +146,7 @@ describe("copyPatches", () => {
     expect(fs.ensureDir).toHaveBeenCalledWith("/workspace/isolate/patches");
     expect(fs.copy).toHaveBeenCalledWith(
       "/workspace/patches/lodash.patch",
-      "/workspace/isolate/patches/lodash.patch"
+      "/workspace/isolate/patches/lodash.patch",
     );
   });
 
@@ -190,7 +190,7 @@ describe("copyPatches", () => {
     });
     expect(fs.copy).toHaveBeenCalledWith(
       "/workspace/patches/vitest.patch",
-      "/workspace/isolate/patches/vitest.patch"
+      "/workspace/isolate/patches/vitest.patch",
     );
   });
 
@@ -303,11 +303,11 @@ describe("copyPatches", () => {
     expect(fs.copy).toHaveBeenCalledTimes(2);
     expect(fs.copy).toHaveBeenCalledWith(
       "/workspace/patches/v1/fix.patch",
-      "/workspace/isolate/patches/v1/fix.patch"
+      "/workspace/isolate/patches/v1/fix.patch",
     );
     expect(fs.copy).toHaveBeenCalledWith(
       "/workspace/patches/v2/fix.patch",
-      "/workspace/isolate/patches/v2/fix.patch"
+      "/workspace/isolate/patches/v2/fix.patch",
     );
   });
 
@@ -346,11 +346,11 @@ describe("copyPatches", () => {
       "lodash@4.17.21": { path: "some/nested/path/lodash.patch", hash: "" },
     });
     expect(fs.ensureDir).toHaveBeenCalledWith(
-      "/workspace/isolate/some/nested/path"
+      "/workspace/isolate/some/nested/path",
     );
     expect(fs.copy).toHaveBeenCalledWith(
       "/workspace/some/nested/path/lodash.patch",
-      "/workspace/isolate/some/nested/path/lodash.patch"
+      "/workspace/isolate/some/nested/path/lodash.patch",
     );
   });