fix: implemented CR suggestions

Author: zkochan

scopes/dependencies/dependency-resolver/dependency-resolver.main.runtime.ts

@@ -89,7 +89,7 @@ import { DependenciesFragment, DevDependenciesFragment, PeerDependenciesFragment
 import { dependencyResolverSchema } from './dependency-resolver.graphql';
 import type { DependencyDetector } from './detector-hook';
 import { DependenciesService } from './dependencies.service';
-import { EnvPolicy } from './policy/env-policy';
+import { EnvPolicy, type EnvJsoncPolicyEntry } from './policy/env-policy';
 import type { ConfigStoreMain } from '@teambit/config-store';
 import { ConfigStoreAspect } from '@teambit/config-store';
 
@@ -1570,21 +1570,20 @@ as an alternative, you can use "+" to keep the same version installed in the wor
       if (!envJsonc.policy) return;
 
       const policies = [
-        { field: 'peers', targetField: 'peerDependencies' },
-        { field: 'dev', targetField: 'devDependencies' },
-        { field: 'runtime', targetField: 'dependencies' },
+        { field: 'peers', targetField: 'peerDependencies' as const },
+        { field: 'dev', targetField: 'devDependencies' as const },
+        { field: 'runtime', targetField: 'dependencies' as const },
       ];
 
       policies.forEach(({ field, targetField }) => {
-        // @ts-ignore
-        const deps = envJsonc.policy?.[field] || [];
+        const deps: EnvJsoncPolicyEntry[] = envJsonc.policy?.[field] || [];
         deps.forEach((dep: any) => {
           pkgs.push({
             name: dep.name,
             currentRange: dep.version,
             source: 'env-jsonc',
             componentId: component.id,
-            targetField: targetField as any,
+            targetField,
           });
         });
       });

scopes/dependencies/dependency-resolver/policy/env-policy/index.ts

@@ -1 +1 @@
-export { EnvPolicy, EnvPolicyConfigObject } from './env-policy';
+export { EnvPolicy, EnvPolicyConfigObject, EnvJsoncPolicyEntry } from './env-policy';

scopes/toolbox/json/jsonc-utils/jsonc-utils.ts

@@ -50,11 +50,11 @@ export function stringifyJsonc(data: any, formatting: JsoncFormatting): string {
  * });
  * ```
  */
-export function updateJsoncPreservingFormatting(
+export function updateJsoncPreservingFormatting<T>(
   originalContent: string,
-  updateFn: (data: any) => any
+  updateFn: (data: T) => T
 ): string {
   const { data, formatting } = parseJsoncWithFormatting(originalContent);
   const updatedData = updateFn(data);
   return stringifyJsonc(updatedData, formatting);
-}
+}

scopes/workspace/install/install.main.runtime.ts

@@ -23,6 +23,7 @@ import { VariantsAspect } from '@teambit/variants';
 import type { Component } from '@teambit/component';
 import { ComponentID, ComponentMap } from '@teambit/component';
 import { PackageJsonFile } from '@teambit/component.sources';
+import { type EnvJsonc } from '@teambit/envs'
 import { updateJsoncPreservingFormatting } from '@teambit/toolbox.json.jsonc-utils';
 import { createLinks } from '@teambit/dependencies.fs.linked-dependencies';
 import pMapSeries from 'p-map-series';
@@ -1010,44 +1011,54 @@ export class InstallMain {
   }
 
   async updateEnvJsoncPolicies(outdatedPkgs: MergedOutdatedPkg[]) {
-    const updatesByComponentId = groupBy(outdatedPkgs, (pkg) => pkg.componentId?.toString());
+    // Group packages by componentId, skipping those without one
+    const updatesByComponentId = new Map<string, MergedOutdatedPkg[]>();
+    for (const pkg of outdatedPkgs) {
+      if (!pkg.componentId) continue;
+      const key = pkg.componentId.toString();
+      const existing = updatesByComponentId.get(key);
+      if (existing) {
+        existing.push(pkg);
+      } else {
+        updatesByComponentId.set(key, [pkg]);
+      }
+    }
 
-    await pMapSeries(Object.entries(updatesByComponentId), async ([componentIdStr, pkgs]) => {
-      const componentId = await this.workspace.resolveComponentId(componentIdStr);
+    await Promise.all(Array.from(updatesByComponentId.values()).map(async (pkgs) => {
+      const componentId = pkgs[0].componentId!;
       const component = await this.workspace.get(componentId);
       const envJsoncFile = component.filesystem.files.find((file) => file.relative === 'env.jsonc');
       if (!envJsoncFile) return;
 
       const envJsoncContent = envJsoncFile.contents.toString();
-      const updatedContent = updateJsoncPreservingFormatting(envJsoncContent, (envJsonc) => {
+      const updatedContent = updateJsoncPreservingFormatting(envJsoncContent, (envJsonc: EnvJsonc): EnvJsonc => {
         pkgs.forEach((pkg) => {
-        let field: string | undefined;
-        if (pkg.targetField === 'devDependencies') field = 'dev';
-        if (pkg.targetField === 'dependencies') field = 'runtime';
-        if (pkg.targetField === 'peerDependencies') field = 'peers';
-
-        if (!field) return;
-
-        // @ts-ignore
-        const deps = envJsonc.policy?.[field];
-        if (!Array.isArray(deps)) return;
-
-        const depEntry = deps.find((d: any) => d.name === pkg.name);
-        if (depEntry) {
-          depEntry.version = pkg.latestRange;
-          if (field === 'peers' && depEntry.supportedRange) {
-            if (!semver.intersects(pkg.latestRange, depEntry.supportedRange)) {
-              depEntry.supportedRange = `${depEntry.supportedRange} || ${pkg.latestRange}`;
+          let field: string | undefined;
+          if (pkg.targetField === 'devDependencies') field = 'dev';
+          if (pkg.targetField === 'dependencies') field = 'runtime';
+          if (pkg.targetField === 'peerDependencies') field = 'peers';
+
+          if (!field) return;
+
+          const deps = envJsonc.policy?.[field];
+          if (!Array.isArray(deps)) return;
+
+          const depEntry = deps.find(({ name }) => name === pkg.name);
+          if (depEntry) {
+            depEntry.version = pkg.latestRange;
+            if (field === 'peers' && depEntry.supportedRange) {
+              if (!semver.intersects(pkg.latestRange, depEntry.supportedRange)) {
+                depEntry.supportedRange = `${depEntry.supportedRange} || ${pkg.latestRange}`;
+              }
             }
           }
-        }
         });
         return envJsonc;
       });
 
       const absPath = path.join(this.workspace.componentDir(component.id), 'env.jsonc');
       await fs.writeFile(absPath, updatedContent);
-    });
+    }));
   }
 
   private async _getAllUsedEnvIds(): Promise<ComponentID[]> {