isolate-package 1.21.0-1 → 1.23.0-0

package/dist/index.mjs

@@ -1,12 +1,12 @@
 // src/isolate.ts
 import fs16 from "fs-extra";
-import assert6 from "node:assert";
-import path20 from "node:path";
+import assert7 from "node:assert";
+import path21 from "node:path";
 import { unique as unique2 } from "remeda";
 
 // src/lib/config.ts
 import fs8 from "fs-extra";
-import assert2 from "node:assert";
+import assert3 from "node:assert";
 import path6 from "node:path";
 import { isEmpty } from "remeda";
 
@@ -81,17 +81,6 @@ function toErrorWithMessage(maybeError) {
   }
 }
 
-// src/lib/utils/get-relative-path.ts
-import { join } from "node:path";
-function getRootRelativePath(path21, rootPath) {
-  const strippedPath = path21.replace(rootPath, "");
-  return join("(root)", strippedPath);
-}
-function getIsolateRelativePath(path21, isolatePath) {
-  const strippedPath = path21.replace(isolatePath, "");
-  return join("(isolate)", strippedPath);
-}
-
 // src/lib/utils/inspect-value.ts
 import { inspect } from "node:util";
 function inspectValue(value) {
@@ -135,7 +124,19 @@ async function readTypedJson(filePath) {
   }
 }
 
+// src/lib/utils/log-paths.ts
+import { join } from "node:path";
+function getRootRelativeLogPath(path22, rootPath) {
+  const strippedPath = path22.replace(rootPath, "");
+  return join("(root)", strippedPath);
+}
+function getIsolateRelativeLogPath(path22, isolatePath) {
+  const strippedPath = path22.replace(isolatePath, "");
+  return join("(isolate)", strippedPath);
+}
+
 // src/lib/utils/pack.ts
+import assert2 from "node:assert";
 import { exec } from "node:child_process";
 import fs5 from "node:fs";
 import path5 from "node:path";
@@ -288,10 +289,9 @@ async function pack(srcDir, dstDir) {
     );
   });
   const lastLine = stdout.trim().split("\n").at(-1);
-  if (!lastLine) {
-    throw new Error(`Failed to parse last line from stdout: ${stdout.trim()}`);
-  }
+  assert2(lastLine, `Failed to parse last line from stdout: ${stdout.trim()}`);
   const fileName = path5.basename(lastLine);
+  assert2(fileName, `Failed to parse file name from: ${lastLine}`);
   const filePath = path5.join(dstDir, fileName);
   if (!fs5.existsSync(filePath)) {
     log.error(
@@ -442,7 +442,7 @@ async function generateNpmLockfile({
 }
 
 // src/lib/lockfile/helpers/generate-pnpm-lockfile.ts
-import assert3 from "node:assert";
+import assert4 from "node:assert";
 import path9 from "node:path";
 import {
   getLockfileImporterId as getLockfileImporterId_v8,
@@ -484,10 +484,7 @@ function pnpmMapDependenciesLinks(importerPath, def, directoryByPackageName) {
     if (!value.startsWith("link:")) {
       return value;
     }
-    const relativePath = path8.relative(
-      importerPath,
-      directoryByPackageName[key]
-    );
+    const relativePath = path8.relative(importerPath, directoryByPackageName[key]).replace(path8.sep, path8.posix.sep);
     return relativePath.startsWith(".") ? `link:${relativePath}` : `link:./${relativePath}`;
   });
 }
@@ -519,12 +516,12 @@ async function generatePnpmLockfile({
         ignoreIncompatible: false
       }
     );
-    assert3(lockfile, `No input lockfile found at ${workspaceRootDir}`);
+    assert4(lockfile, `No input lockfile found at ${workspaceRootDir}`);
     const targetImporterId = useVersion9 ? getLockfileImporterId_v9(workspaceRootDir, targetPackageDir) : getLockfileImporterId_v8(workspaceRootDir, targetPackageDir);
     const directoryByPackageName = Object.fromEntries(
       internalDepPackageNames.map((name) => {
         const pkg = packagesRegistry[name];
-        assert3(pkg, `Package ${name} not found in packages registry`);
+        assert4(pkg, `Package ${name} not found in packages registry`);
         return [name, pkg.rootRelativeDir];
       })
     );
@@ -535,7 +532,17 @@ async function generatePnpmLockfile({
        * importer ids in the context of a lockfile.
        */
       ...Object.values(directoryByPackageName)
-    ];
+      /**
+       * Split the path by the OS separator and join it back with the POSIX
+       * separator.
+       *
+       * The importerIds are built from directory names, so Windows Git Bash
+       * environments will have double backslashes in their ids:
+       * "packages\common" vs. "packages/common". Without this split & join, any
+       * packages not on the top-level will have ill-formatted importerIds and
+       * their entries will be missing from the lockfile.importers list.
+       */
+    ].map((x) => x.split(path9.sep).join(path9.posix.sep));
     log.debug("Relevant importer ids:", relevantImporterIds);
     const relevantImporterIdsWithPrefix = relevantImporterIds.map(
       (x) => isRush ? `../../${x}` : x
@@ -854,7 +861,7 @@ async function adaptTargetPackageManifest({
 }
 
 // src/lib/output/get-build-output-dir.ts
-import fs12 from "fs-extra";
+import { getTsconfig } from "get-tsconfig";
 import path15 from "node:path";
 import outdent from "outdent";
 async function getBuildOutputDir(targetPackageDir) {
@@ -865,10 +872,10 @@ async function getBuildOutputDir(targetPackageDir) {
     return path15.join(targetPackageDir, config.buildDirName);
   }
   const tsconfigPath = path15.join(targetPackageDir, config.tsconfigPath);
-  if (fs12.existsSync(tsconfigPath)) {
-    log.debug("Found tsconfig at:", config.tsconfigPath);
-    const tsconfig = await readTypedJson(tsconfigPath);
-    const outDir = tsconfig.compilerOptions?.outDir;
+  const tsconfig = getTsconfig(tsconfigPath);
+  if (tsconfig) {
+    log.debug("Found tsconfig at:", tsconfig.path);
+    const outDir = tsconfig.config.compilerOptions?.outDir;
     if (outDir) {
       return path15.join(targetPackageDir, outDir);
     } else {
@@ -884,8 +891,62 @@ async function getBuildOutputDir(targetPackageDir) {
   }
 }
 
+// src/lib/output/handle-firebase-config.ts
+import fs12 from "fs-extra";
+import path16 from "node:path";
+import { omit as omit3 } from "remeda";
+async function handleFirebaseConfig({
+  targetPackageDir,
+  workspaceRootDir,
+  isolateDir
+}) {
+  const log = useLogger();
+  const targetHasFirebaseConfig = fs12.existsSync(
+    path16.join(targetPackageDir, "firebase.json")
+  );
+  if (targetHasFirebaseConfig) {
+    const firebaseConfig = await readTypedJson(path16.join(targetPackageDir, "firebase.json"));
+    if (firebaseConfig.functions.predeploy) {
+      log.warn(
+        "The firebase predeploy phase is not supported by isolate-package and will be ignored. Please execute the predeploy commands before executing isolate."
+      );
+    }
+    fs12.writeJsonSync(path16.join(isolateDir, "firebase.json"), {
+      ...firebaseConfig,
+      functions: omit3(firebaseConfig.functions, ["predeploy"])
+    });
+    log.info("Included firebase config from the target package");
+  }
+  if (!targetHasFirebaseConfig) {
+    const rootHasFirebaseConfig = fs12.existsSync(
+      path16.join(workspaceRootDir, "firebase.json")
+    );
+    if (rootHasFirebaseConfig) {
+      log.debug("Attempting to extract firebase config from the root");
+      const firebaseConfig = await readTypedJson(path16.join(workspaceRootDir, "firebase.json"));
+      const targetFolderName = path16.basename(targetPackageDir);
+      const extractedFunctionsConfig = firebaseConfig.functions.find(
+        (x) => x.source.includes(targetFolderName)
+      );
+      if (extractedFunctionsConfig) {
+        fs12.writeJsonSync(path16.join(isolateDir, "firebase.json"), {
+          functions: {
+            ...extractedFunctionsConfig,
+            source: "."
+          }
+        });
+        log.info("Included firebase config extracted from the root");
+      } else {
+        log.debug(
+          `No functions config found for ${targetFolderName} in the root firebase.json`
+        );
+      }
+    }
+  }
+}
+
 // src/lib/output/pack-dependencies.ts
-import assert4 from "node:assert";
+import assert5 from "node:assert";
 async function packDependencies({
   /** All packages found in the monorepo by workspaces declaration */
   packagesRegistry,
@@ -903,7 +964,7 @@ async function packDependencies({
   const packedFileByName = {};
   for (const dependency of internalPackageNames) {
     const def = packagesRegistry[dependency];
-    assert4(dependency, `Failed to find package definition for ${dependency}`);
+    assert5(dependency, `Failed to find package definition for ${dependency}`);
     const { name } = def.manifest;
     if (packedFileByName[name]) {
       log.debug(`Skipping ${name} because it has already been packed`);
@@ -916,7 +977,7 @@ async function packDependencies({
 
 // src/lib/output/process-build-output-files.ts
 import fs13 from "fs-extra";
-import path16 from "node:path";
+import path17 from "node:path";
 var TIMEOUT_MS = 5e3;
 async function processBuildOutputFiles({
   targetPackageDir,
@@ -925,7 +986,7 @@ async function processBuildOutputFiles({
 }) {
   const log = useLogger();
   const packedFilePath = await pack(targetPackageDir, tmpDir);
-  const unpackDir = path16.join(tmpDir, "target");
+  const unpackDir = path17.join(tmpDir, "target");
   const now = Date.now();
   let isWaitingYet = false;
   while (!fs13.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
@@ -936,19 +997,19 @@ async function processBuildOutputFiles({
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   await unpack(packedFilePath, unpackDir);
-  await fs13.copy(path16.join(unpackDir, "package"), isolateDir);
+  await fs13.copy(path17.join(unpackDir, "package"), isolateDir);
 }
 
 // src/lib/output/unpack-dependencies.ts
 import fs14 from "fs-extra";
-import path17, { join as join2 } from "node:path";
+import path18, { join as join2 } from "node:path";
 async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, isolateDir) {
   const log = useLogger();
   await Promise.all(
     Object.entries(packedFilesByName).map(async ([packageName, filePath]) => {
       const dir = packagesRegistry[packageName].rootRelativeDir;
       const unpackDir = join2(tmpDir, dir);
-      log.debug("Unpacking", `(temp)/${path17.basename(filePath)}`);
+      log.debug("Unpacking", `(temp)/${path18.basename(filePath)}`);
       await unpack(filePath, unpackDir);
       const destinationDir = join2(isolateDir, dir);
       await fs14.ensureDir(destinationDir);
@@ -956,7 +1017,7 @@ async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, i
         overwrite: true
       });
       log.debug(
-        `Moved package files to ${getIsolateRelativePath(
+        `Moved package files to ${getIsolateRelativeLogPath(
           destinationDir,
           isolateDir
         )}`
@@ -968,18 +1029,18 @@ async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, i
 // src/lib/registry/create-packages-registry.ts
 import fs15 from "fs-extra";
 import { globSync } from "glob";
-import path19 from "node:path";
+import path20 from "node:path";
 
 // src/lib/registry/helpers/find-packages-globs.ts
-import assert5 from "node:assert";
-import path18 from "node:path";
+import assert6 from "node:assert";
+import path19 from "node:path";
 function findPackagesGlobs(workspaceRootDir) {
   const log = useLogger();
   const packageManager2 = usePackageManager();
   switch (packageManager2.name) {
     case "pnpm": {
       const { packages: globs } = readTypedYamlSync(
-        path18.join(workspaceRootDir, "pnpm-workspace.yaml")
+        path19.join(workspaceRootDir, "pnpm-workspace.yaml")
       );
       log.debug("Detected pnpm packages globs:", inspectValue(globs));
       return globs;
@@ -987,7 +1048,7 @@ function findPackagesGlobs(workspaceRootDir) {
     case "bun":
     case "yarn":
     case "npm": {
-      const workspaceRootManifestPath = path18.join(
+      const workspaceRootManifestPath = path19.join(
         workspaceRootDir,
         "package.json"
       );
@@ -1003,7 +1064,7 @@ function findPackagesGlobs(workspaceRootDir) {
         return workspaces;
       } else {
         const workspacesObject = workspaces;
-        assert5(
+        assert6(
           workspacesObject.packages,
           "workspaces.packages must be an array"
         );
@@ -1027,8 +1088,8 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
   );
   const registry = (await Promise.all(
     allPackages.map(async (rootRelativeDir) => {
-      const absoluteDir = path19.join(workspaceRootDir, rootRelativeDir);
-      const manifestPath = path19.join(absoluteDir, "package.json");
+      const absoluteDir = path20.join(workspaceRootDir, rootRelativeDir);
+      const manifestPath = path20.join(absoluteDir, "package.json");
       if (!fs15.existsSync(manifestPath)) {
         log.warn(
           `Ignoring directory ${rootRelativeDir} because it does not contain a package.json file`
@@ -1037,7 +1098,7 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
       } else {
         log.debug(`Registering package ${rootRelativeDir}`);
         const manifest = await readTypedJson(
-          path19.join(absoluteDir, "package.json")
+          path20.join(absoluteDir, "package.json")
         );
         return {
           manifest,
@@ -1057,7 +1118,7 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
 function listWorkspacePackages(workspacePackagesOverride, workspaceRootDir) {
   if (isRushWorkspace(workspaceRootDir)) {
     const rushConfig = readTypedJsonSync(
-      path19.join(workspaceRootDir, "rush.json")
+      path20.join(workspaceRootDir, "rush.json")
     );
     return rushConfig.projects.map(({ projectFolder }) => projectFolder);
   } else {
@@ -1101,35 +1162,35 @@ async function isolate(options = {}) {
   setLogLevel(config.logLevel);
   const log = useLogger();
   const { version: libraryVersion } = await readTypedJson(
-    path20.join(path20.join(__dirname, "..", "package.json"))
+    path21.join(path21.join(__dirname, "..", "package.json"))
   );
   log.info("Using isolate-package version", libraryVersion);
-  const targetPackageDir = config.targetPackagePath ? path20.join(process.cwd(), config.targetPackagePath) : process.cwd();
-  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path20.join(targetPackageDir, config.workspaceRoot);
+  const targetPackageDir = config.targetPackagePath ? path21.join(process.cwd(), config.targetPackagePath) : process.cwd();
+  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path21.join(targetPackageDir, config.workspaceRoot);
   const buildOutputDir = await getBuildOutputDir(targetPackageDir);
-  assert6(
+  assert7(
     fs16.existsSync(buildOutputDir),
     `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",
-    getRootRelativePath(targetPackageDir, workspaceRootDir)
+    getRootRelativeLogPath(targetPackageDir, workspaceRootDir)
   );
-  const isolateDir = path20.join(targetPackageDir, config.isolateDirName);
+  const isolateDir = path21.join(targetPackageDir, config.isolateDirName);
   log.debug(
     "Isolate output directory",
-    getRootRelativePath(isolateDir, workspaceRootDir)
+    getRootRelativeLogPath(isolateDir, workspaceRootDir)
   );
   if (fs16.existsSync(isolateDir)) {
     await fs16.remove(isolateDir);
     log.debug("Cleaned the existing isolate output directory");
   }
   await fs16.ensureDir(isolateDir);
-  const tmpDir = path20.join(isolateDir, "__tmp");
+  const tmpDir = path21.join(isolateDir, "__tmp");
   await fs16.ensureDir(tmpDir);
   const targetPackageManifest = await readTypedJson(
-    path20.join(targetPackageDir, "package.json")
+    path21.join(targetPackageDir, "package.json")
   );
   const packageManager2 = detectPackageManager(workspaceRootDir);
   log.debug(
@@ -1197,30 +1258,35 @@ async function isolate(options = {}) {
     if (isRushWorkspace(workspaceRootDir)) {
       const packagesFolderNames = unique2(
         internalPackageNames.map(
-          (name) => path20.parse(packagesRegistry[name].rootRelativeDir).dir
+          (name) => path21.parse(packagesRegistry[name].rootRelativeDir).dir
         )
       );
       log.debug("Generating pnpm-workspace.yaml for Rush workspace");
       log.debug("Packages folder names:", packagesFolderNames);
-      const packages = packagesFolderNames.map((x) => path20.join(x, "/*"));
-      await writeTypedYamlSync(path20.join(isolateDir, "pnpm-workspace.yaml"), {
+      const packages = packagesFolderNames.map((x) => path21.join(x, "/*"));
+      await writeTypedYamlSync(path21.join(isolateDir, "pnpm-workspace.yaml"), {
         packages
       });
     } else {
       fs16.copyFileSync(
-        path20.join(workspaceRootDir, "pnpm-workspace.yaml"),
-        path20.join(isolateDir, "pnpm-workspace.yaml")
+        path21.join(workspaceRootDir, "pnpm-workspace.yaml"),
+        path21.join(isolateDir, "pnpm-workspace.yaml")
       );
     }
   }
-  const npmrcPath = path20.join(workspaceRootDir, ".npmrc");
+  const npmrcPath = path21.join(workspaceRootDir, ".npmrc");
   if (fs16.existsSync(npmrcPath)) {
-    fs16.copyFileSync(npmrcPath, path20.join(isolateDir, ".npmrc"));
+    fs16.copyFileSync(npmrcPath, path21.join(isolateDir, ".npmrc"));
     log.debug("Copied .npmrc file to the isolate output");
   }
+  await handleFirebaseConfig({
+    targetPackageDir,
+    workspaceRootDir,
+    isolateDir
+  });
   log.debug(
     "Deleting temp directory",
-    getRootRelativePath(tmpDir, workspaceRootDir)
+    getRootRelativeLogPath(tmpDir, workspaceRootDir)
   );
   await fs16.remove(tmpDir);
   log.info("Isolate completed at", isolateDir);