isolate-package 1.29.0-1 → 1.29.0

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

@@ -4,6 +4,16 @@ 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",

package/src/isolate.ts

@@ -193,12 +193,11 @@ export function createIsolator(config?: IsolateConfig) {
 
     /**
      * Copy patch files before generating lockfile so the lockfile contains the
-     * correct paths. Only copy patches when output uses pnpm or bun, since
-     * patched dependencies are stored in their lockfiles.
+     * correct paths. Only copy patches when output uses pnpm, since patched
+     * dependencies are a pnpm-specific feature.
      */
     const shouldCopyPatches =
-      (packageManager.name === "pnpm" || packageManager.name === "bun") &&
-      !config.forceNpm;
+      packageManager.name === "pnpm" && !config.forceNpm;
 
     const copiedPatches = shouldCopyPatches
       ? await copyPatches({
@@ -292,18 +291,6 @@ export function createIsolator(config?: IsolateConfig) {
       }
     }
 
-    if (packageManager.name === "bun" && !config.forceNpm) {
-      /** Add workspaces field to the manifest so Bun treats the isolate as a workspace */
-      const manifest = await readManifest(isolateDir);
-      const workspaceGlobs = unique(
-        internalPackageNames.map(
-          (name) => path.parse(got(packagesRegistry, name).rootRelativeDir).dir,
-        ),
-      ).map((x) => path.join(x, "/*"));
-      manifest.workspaces = workspaceGlobs;
-      await writeManifest(isolateDir, manifest);
-    }
-
     /**
      * If there is an .npmrc file in the workspace root, copy it to the isolate
      * because the settings there could affect how the lockfile is resolved.
@@ -318,15 +305,6 @@ export function createIsolator(config?: IsolateConfig) {
       log.debug("Copied .npmrc file to the isolate output");
     }
 
-    if (packageManager.name === "bun" && !config.forceNpm) {
-      const bunfigPath = path.join(workspaceRootDir, "bunfig.toml");
-
-      if (fs.existsSync(bunfigPath)) {
-        fs.copyFileSync(bunfigPath, path.join(isolateDir, "bunfig.toml"));
-        log.debug("Copied bunfig.toml file to the isolate output");
-      }
-    }
-
     /**
      * Clean up. Only do this when things succeed, so we can look at the temp
      * folder in case something goes wrong.

package/src/lib/lockfile/helpers/index.ts

@@ -1,4 +1,3 @@
-export * from "./generate-bun-lockfile";
 export * from "./generate-npm-lockfile";
 export * from "./generate-pnpm-lockfile";
 export * from "./generate-yarn-lockfile";

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

@@ -3,7 +3,6 @@ import { useLogger } from "../logger";
 import { usePackageManager } from "../package-manager";
 import type { PackageManifest, PackagesRegistry, PatchFile } from "../types";
 import {
-  generateBunLockfile,
   generateNpmLockfile,
   generatePnpmLockfile,
   generateYarnLockfile,
@@ -98,14 +97,15 @@ export async function processLockfile({
       break;
     }
     case "bun": {
-      await generateBunLockfile({
+      log.warn(
+        `Ouput lockfiles for Bun are not yet supported. Using NPM for output`,
+      );
+      await generateNpmLockfile({
         workspaceRootDir,
-        targetPackageDir,
         isolateDir,
-        internalDepPackageNames,
-        packagesRegistry,
-        includeDevDependencies: config.includeDevDependencies,
       });
+
+      usedFallbackToNpm = true;
       break;
     }
     default:

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

@@ -51,12 +51,11 @@ export async function adaptTargetPackageManifest({
   };
 
   const adaptedManifest =
-    (packageManager.name === "pnpm" || packageManager.name === "bun") &&
-    !forceNpm
+    packageManager.name === "pnpm" && !forceNpm
       ? /**
-         * For PNPM and Bun the output itself is a workspace so we can preserve
-         * the specifiers with "workspace:*" in the output manifest, but we do
-         * want to adopt the pnpm.overrides field from the root package.json.
+         * For PNPM the output itself is a workspace so we can preserve the specifiers
+         * with "workspace:*" in the output manifest, but we do want to adopt the
+         * pnpm.overrides field from the root package.json.
          */
         await adoptPnpmFieldsFromRoot(
           manifestWithResolvedCatalogs,

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

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import type { PackageManifest, PackagesRegistry } from "~/lib/types";
+
+/** Mock dependencies */
+vi.mock("~/lib/package-manager", () => ({
+  usePackageManager: vi.fn(),
+}));
+
+vi.mock("../io", () => ({
+  writeManifest: vi.fn(),
+}));
+
+vi.mock("./adapt-manifest-internal-deps", () => ({
+  adaptManifestInternalDeps: vi.fn(({ manifest }) => manifest),
+}));
+
+vi.mock("./resolve-catalog-dependencies", () => ({
+  resolveCatalogDependencies: vi.fn((deps) => Promise.resolve(deps)),
+}));
+
+const { usePackageManager } = vi.mocked(await import("~/lib/package-manager"));
+
+const { writeManifest } = vi.mocked(await import("../io"));
+
+const { adaptInternalPackageManifests } =
+  await import("./adapt-internal-package-manifests");
+
+describe("adaptInternalPackageManifests", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    usePackageManager.mockReturnValue({
+      name: "pnpm",
+      version: "9.0.0",
+      majorVersion: 9,
+    });
+  });
+
+  function createRegistry(
+    entries: Record<
+      string,
+      { rootRelativeDir: string; manifest: PackageManifest }
+    >,
+  ): PackagesRegistry {
+    const registry: PackagesRegistry = {};
+    for (const [name, { rootRelativeDir, manifest }] of Object.entries(
+      entries,
+    )) {
+      registry[name] = {
+        absoluteDir: `/workspace/${rootRelativeDir}`,
+        rootRelativeDir,
+        manifest,
+      };
+    }
+    return registry;
+  }
+
+  it("should preserve scripts in internal dependency manifests", async () => {
+    const manifest: PackageManifest = {
+      name: "@repo/database",
+      version: "1.0.0",
+      scripts: {
+        postinstall: "prisma generate",
+        build: "tsc",
+      },
+      dependencies: {
+        prisma: "^5.0.0",
+      },
+      devDependencies: {
+        typescript: "^5.0.0",
+      },
+    };
+
+    const packagesRegistry = createRegistry({
+      "@repo/database": {
+        rootRelativeDir: "packages/database",
+        manifest,
+      },
+    });
+
+    await adaptInternalPackageManifests({
+      internalPackageNames: ["@repo/database"],
+      packagesRegistry,
+      isolateDir: "/output",
+      forceNpm: false,
+      workspaceRootDir: "/workspace",
+    });
+
+    expect(writeManifest).toHaveBeenCalledOnce();
+
+    const writtenManifest = writeManifest.mock.calls[0]![1];
+
+    expect(writtenManifest.scripts).toEqual({
+      postinstall: "prisma generate",
+      build: "tsc",
+    });
+  });
+
+  it("should strip devDependencies from internal dependency manifests", async () => {
+    const manifest: PackageManifest = {
+      name: "@repo/shared",
+      version: "1.0.0",
+      dependencies: {
+        lodash: "^4.0.0",
+      },
+      devDependencies: {
+        vitest: "^1.0.0",
+        typescript: "^5.0.0",
+      },
+    };
+
+    const packagesRegistry = createRegistry({
+      "@repo/shared": {
+        rootRelativeDir: "packages/shared",
+        manifest,
+      },
+    });
+
+    await adaptInternalPackageManifests({
+      internalPackageNames: ["@repo/shared"],
+      packagesRegistry,
+      isolateDir: "/output",
+      forceNpm: false,
+      workspaceRootDir: "/workspace",
+    });
+
+    expect(writeManifest).toHaveBeenCalledOnce();
+
+    const writtenManifest = writeManifest.mock.calls[0]![1];
+
+    expect(writtenManifest.devDependencies).toBeUndefined();
+  });
+});

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

@@ -31,8 +31,8 @@ export async function adaptInternalPackageManifests({
     internalPackageNames.map(async (packageName) => {
       const { manifest, rootRelativeDir } = got(packagesRegistry, packageName);
 
-      /** Dev dependencies and scripts are never included for internal deps */
-      const strippedManifest = omit(manifest, ["scripts", "devDependencies"]);
+      /** Dev dependencies are never included for internal deps */
+      const strippedManifest = omit(manifest, ["devDependencies"]);
 
       /** Resolve catalog dependencies before adapting internal deps */
       const manifestWithResolvedCatalogs = {
@@ -44,11 +44,10 @@ export async function adaptInternalPackageManifests({
       };
 
       const outputManifest =
-        (packageManager.name === "pnpm" || packageManager.name === "bun") &&
-        !forceNpm
+        packageManager.name === "pnpm" && !forceNpm
           ? /**
-             * For PNPM and Bun the output itself is a workspace so we can preserve
-             * the specifiers with "workspace:*" in the output manifest.
+             * For PNPM the output itself is a workspace so we can preserve the specifiers
+             * with "workspace:*" in the output manifest.
              */
             manifestWithResolvedCatalogs
           : /** For other package managers we replace the links to internal dependencies */

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

@@ -43,7 +43,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidDevManifest, packagePath, false),
-    ).toThrow(/missing mandatory fields: version/);
+    ).toThrow(/missing the "version" field/);
   });
 
   it("should throw error when version field is missing", () => {
@@ -54,7 +54,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing mandatory fields: version/);
+    ).toThrow(/missing the "version" field/);
   });
 
   it("should throw error when files field is missing", () => {
@@ -65,7 +65,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing mandatory fields: files/);
+    ).toThrow(/missing the "files" field/);
   });
 
   it("should throw error when files field is empty array", () => {
@@ -77,7 +77,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing mandatory fields: files/);
+    ).toThrow(/missing the "files" field/);
   });
 
   it("should throw error when files field is not an array", () => {
@@ -89,7 +89,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing mandatory fields: files/);
+    ).toThrow(/missing the "files" field/);
   });
 
   it("should throw error when both fields are missing", () => {
@@ -99,20 +99,29 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing mandatory fields: version, files/);
+    ).toThrow(/missing mandatory fields in its package\.json: version, files/);
   });
 
-  it("should include helpful error message", () => {
+  it("should include documentation URL in error message", () => {
     const invalidManifest = {
       name: "test-package",
     } as PackageManifest;
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing mandatory fields: version, files/);
+    ).toThrow(
+      /See https:\/\/isolate-package\.codecompose\.dev\/getting-started#prerequisites/,
+    );
+
+    const singleFieldManifest = {
+      name: "test-package",
+      version: "1.0.0",
+    } as PackageManifest;
 
     expect(() =>
-      validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/See the documentation for more details/);
+      validateManifestMandatoryFields(singleFieldManifest, packagePath),
+    ).toThrow(
+      /See https:\/\/isolate-package\.codecompose\.dev\/getting-started#define-files-field-in-each-package-manifest/,
+    );
   });
 });

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

@@ -1,6 +1,14 @@
 import { useLogger } from "../logger";
 import type { PackageManifest } from "../types";
 
+/** Maps field names to their documentation URLs */
+const fieldDocUrls: Record<string, string> = {
+  version:
+    "https://isolate-package.codecompose.dev/getting-started#define-version-field-in-each-package-manifest",
+  files:
+    "https://isolate-package.codecompose.dev/getting-started#define-files-field-in-each-package-manifest",
+};
+
 /**
  * Validate that mandatory fields are present in the package manifest. These
  * fields are required for the isolate process to work properly.
@@ -38,7 +46,11 @@ export function validateManifestMandatoryFields(
   }
 
   if (missingFields.length > 0) {
-    const errorMessage = `Package at ${packagePath} is missing mandatory fields: ${missingFields.join(", ")}. See the documentation for more details.`;
+    const field = missingFields[0]!;
+    const errorMessage =
+      missingFields.length === 1
+        ? `Package at ${packagePath} is missing the "${field}" field in its package.json. See ${fieldDocUrls[field] ?? "https://isolate-package.codecompose.dev/getting-started#prerequisites"}`
+        : `Package at ${packagePath} is missing mandatory fields in its package.json: ${missingFields.join(", ")}. See https://isolate-package.codecompose.dev/getting-started#prerequisites`;
 
     log.error(errorMessage);
     throw new Error(errorMessage);