@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/src/requests/BundleGraphRequestRust.ts

@@ -0,0 +1,470 @@
+import invariant from 'assert';
+
+import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import type {Async} from '@atlaspack/types';
+import {ContentGraph} from '@atlaspack/graph';
+import {instrument, instrumentAsync, PluginLogger} from '@atlaspack/logger';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+
+import InternalBundleGraph, {bundleGraphEdgeTypes} from '../BundleGraph';
+import {report} from '../ReporterRunner';
+import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
+import nullthrows from 'nullthrows';
+import {hashString} from '@atlaspack/rust';
+import PluginOptions from '../public/PluginOptions';
+import applyRuntimes from '../applyRuntimes';
+import {ATLASPACK_VERSION} from '../constants';
+import {optionsProxy} from '../utils';
+import {
+  createDevDependency,
+  getDevDepRequests,
+  invalidateDevDeps,
+} from './DevDepRequest';
+import {PluginWithLoadConfig} from './ConfigRequest';
+import {requestTypes, StaticRunOpts} from '../RequestTracker';
+import type {AtlaspackV3} from '../atlaspack-v3';
+import type {BundleGraphResult} from './BundleGraphRequest';
+import createAtlaspackConfigRequest, {
+  getCachedAtlaspackConfig,
+  ConfigAndCachePath,
+} from './AtlaspackConfigRequest';
+import {
+  validateBundles,
+  nameBundle,
+  loadPluginConfigWithDevDeps,
+  runDevDepRequest,
+  dumpBundleGraphSnapshot,
+} from './BundleGraphRequestUtils';
+import {toEnvironmentRef} from '../EnvironmentManager';
+import {getEnvironmentHash} from '../Environment';
+import type {
+  Asset,
+  BundleGraphNode,
+  BundleNode,
+  BundleGroupNode,
+  DependencyNode,
+  AssetNode,
+  Environment,
+} from '../types';
+import {tracer, PluginTracer} from '@atlaspack/profiler';
+import ThrowableDiagnostic2, {errorToDiagnostic} from '@atlaspack/diagnostic';
+import type {AtlaspackConfig, LoadedPlugin} from '../AtlaspackConfig';
+import type {RunAPI} from '../RequestTracker';
+import type {
+  Config,
+  DevDepRequest,
+  AtlaspackOptions,
+  DevDepRequestRef,
+  Bundle as InternalBundle,
+} from '../types';
+import type {Namer, Bundle as IBundle} from '@atlaspack/types';
+import BundleGraph from '../public/BundleGraph';
+import {Bundle, NamedBundle} from '../public/Bundle';
+
+type BundleGraphRequestInput = {
+  requestedAssetIds: Set<string>;
+  signal?: AbortSignal;
+  optionsRef: any;
+};
+
+type RunInput = {
+  input: BundleGraphRequestInput;
+} & StaticRunOpts<BundleGraphResult>;
+
+type BundleGraphRequestRust = {
+  id: string;
+  readonly type: typeof requestTypes.bundle_graph_request;
+  run: (arg1: RunInput) => Async<BundleGraphResult>;
+  input: BundleGraphRequestInput;
+};
+
+type SerializedBundleGraph = {
+  nodes: Array<any>;
+  edges: Array<number>;
+  publicIdByAssetId: {[k: string]: string};
+  assetPublicIds: Array<string>;
+  hadPreviousGraph: boolean;
+};
+
+export default function createBundleGraphRequestRust(
+  input: BundleGraphRequestInput,
+): BundleGraphRequestRust {
+  return {
+    type: requestTypes.bundle_graph_request,
+    id: 'BundleGraphRust',
+    run: async (runInput) => {
+      const {api, options, rustAtlaspack} = runInput;
+      invariant(rustAtlaspack, 'BundleGraphRequestRust requires rustAtlaspack');
+
+      let {bundleGraphPromise, commitPromise} =
+        await rustAtlaspack.buildBundleGraph((eventJson: string) => {
+          let event = JSON.parse(eventJson);
+          report(event);
+        });
+      let [serializedBundleGraph, bundleGraphError] =
+        (await bundleGraphPromise) as [SerializedBundleGraph, Error | null];
+
+      if (bundleGraphError) {
+        throw new ThrowableDiagnostic({diagnostic: bundleGraphError});
+      }
+
+      // Don’t reuse previous JS result yet; we just rebuild from scratch.
+      let {bundleGraph, changedAssets} = instrument(
+        'atlaspack_v3_getBundleGraph',
+        () => getBundleGraph(serializedBundleGraph),
+      );
+
+      dumpBundleGraphSnapshot(bundleGraph, 'rust');
+
+      const runner = new NativeBundlerRunner(
+        {api, options} as any,
+        input.optionsRef,
+      );
+      await runner.loadConfigs();
+
+      // Name all bundles
+      const namers = await runner.config.getNamers();
+      const bundles = bundleGraph.getBundles({includeInline: true});
+      await Promise.all(
+        bundles.map((b) =>
+          nameBundle(
+            namers,
+            b,
+            bundleGraph,
+            options,
+            runner.pluginOptions,
+            runner.configs,
+          ),
+        ),
+      );
+
+      // Apply runtimes
+      const changedRuntimes = await instrumentAsync('applyRuntimes', () =>
+        applyRuntimes({
+          bundleGraph,
+          api,
+          config: runner.config,
+          options,
+          optionsRef: input.optionsRef,
+          pluginOptions: runner.pluginOptions,
+          previousDevDeps: runner.previousDevDeps,
+          devDepRequests: runner.devDepRequests,
+          configs: runner.configs,
+        }),
+      );
+
+      // Add dev deps for namers
+      for (const namer of namers) {
+        const devDepRequest = await createDevDependency(
+          {
+            specifier: namer.name,
+            resolveFrom: namer.resolveFrom,
+          },
+          runner.previousDevDeps,
+          options,
+        );
+        await runDevDepRequest(api, devDepRequest, runner.devDepRequests);
+      }
+
+      validateBundles(bundleGraph);
+      bundleGraph.getBundleGraphHash();
+
+      await dumpGraphToGraphViz(
+        // @ts-expect-error Accessing internal graph for debug output
+        bundleGraph._graph,
+        'after_runtimes_native',
+        bundleGraphEdgeTypes,
+      );
+
+      let [_commitResult, commitError] = await commitPromise;
+      if (commitError) {
+        throw new ThrowableDiagnostic({
+          diagnostic: {
+            message:
+              'Error committing bundle graph in Rust: ' + commitError.message,
+          },
+        });
+      }
+
+      return {
+        bundleGraph,
+        changedAssets: changedRuntimes,
+        assetRequests: [],
+        didIncrementallyBundle: false,
+      };
+    },
+    input,
+  };
+}
+
+function mapSymbols({exported, ...symbol}: any) {
+  let jsSymbol: any = {
+    local: symbol.local ?? undefined,
+    loc: symbol.loc ?? undefined,
+    isWeak: symbol.isWeak,
+    meta: {
+      isEsm: symbol.isEsmExport,
+      isStaticBindingSafe: symbol.isStaticBindingSafe,
+    },
+  };
+
+  if (symbol.exported) {
+    jsSymbol.exported = symbol.exported;
+  }
+
+  return [exported, jsSymbol];
+}
+
+function normalizeEnv(env: Environment): any {
+  if (!env) return env;
+  env.id = env.id || getEnvironmentHash(env);
+  return toEnvironmentRef(env);
+}
+
+export function getBundleGraph(serializedGraph: SerializedBundleGraph): {
+  bundleGraph: InternalBundleGraph;
+  changedAssets: Map<string, Asset>;
+} {
+  // Build a fresh internal bundle graph.
+  const publicIdByAssetId = new Map(
+    Object.entries(serializedGraph.publicIdByAssetId ?? {}),
+  );
+  const assetPublicIds = new Set(serializedGraph.assetPublicIds ?? []);
+
+  // BundleGraph constructor expects a ContentGraph under `_graph`.
+  // We reuse the internal graph class by creating an empty instance and then adding nodes.
+  const graph = new InternalBundleGraph({
+    // We intentionally start with an empty graph and add nodes/edges from the Rust payload.
+    // `ContentGraph` will allocate as needed.
+    graph: new ContentGraph(),
+    bundleContentHashes: new Map(),
+    publicIdByAssetId,
+    assetPublicIds,
+    conditions: new Map(),
+  });
+
+  // Root must exist at node id 0.
+  const rootNodeId = graph._graph.addNodeByContentKey('@@root', {
+    id: '@@root',
+    type: 'root',
+    value: null,
+  });
+  graph._graph.setRootNodeId(rootNodeId);
+
+  let entry = 0;
+  const changedAssets = new Map<string, Asset>();
+
+  const decoder = new TextDecoder();
+
+  // Create nodes in order.
+  for (let i = 0; i < serializedGraph.nodes.length; i++) {
+    // Nodes come back as buffers (same as AssetGraphRequestRust)
+    let node = JSON.parse(decoder.decode(serializedGraph.nodes[i]));
+
+    if (node.type === 'root') {
+      continue;
+    }
+
+    if (node.type === 'entry') {
+      let id = 'entry:' + ++entry;
+      graph._graph.addNodeByContentKey(id, {id, type: 'root', value: null});
+      continue;
+    }
+
+    if (node.type === 'asset') {
+      let asset = node.value;
+      let id = asset.id;
+
+      asset.committed = true;
+      asset.contentKey = id;
+      asset.env = {...asset.env};
+      asset.env.id = getFeatureFlag('environmentDeduplication')
+        ? getEnvironmentHash(asset.env)
+        : getEnvironmentHash(asset.env);
+      asset.env = normalizeEnv(asset.env);
+      asset.mapKey = `map:${asset.id}`;
+      asset.dependencies = new Map();
+      asset.meta.isV3 = true;
+      if (asset.symbols != null) {
+        asset.symbols = new Map(asset.symbols.map(mapSymbols));
+      }
+
+      changedAssets.set(id, asset);
+
+      const assetNode: AssetNode = {
+        id,
+        type: 'asset',
+        usedSymbols: new Set(),
+        usedSymbolsDownDirty: true,
+        usedSymbolsUpDirty: true,
+        value: asset,
+      };
+      graph._graph.addNodeByContentKey(id, assetNode);
+      continue;
+    }
+
+    if (node.type === 'dependency') {
+      let {dependency, id} = node.value;
+      dependency.id = id;
+      dependency.env = {...dependency.env};
+      dependency.env.id = getEnvironmentHash(dependency.env);
+      dependency.env = normalizeEnv(dependency.env);
+      if (dependency.symbols != null) {
+        dependency.symbols = new Map(dependency.symbols?.map(mapSymbols));
+      }
+
+      let usedSymbolsDown = new Set();
+      let usedSymbolsUp = new Map();
+      if (dependency.isEntry && dependency.isLibrary) {
+        usedSymbolsDown.add('*');
+        usedSymbolsUp.set('*', undefined);
+      }
+
+      const depNode: DependencyNode = {
+        id,
+        type: 'dependency',
+        deferred: false,
+        excluded: false,
+        hasDeferred: node.has_deferred,
+        // @ts-expect-error Flow types expect a more specific symbol set type
+        usedSymbolsDown,
+        usedSymbolsDownDirty: true,
+        usedSymbolsUp,
+        usedSymbolsUpDirtyDown: true,
+        usedSymbolsUpDirtyUp: true,
+        value: dependency,
+      };
+      graph._graph.addNodeByContentKey(id, depNode);
+      continue;
+    }
+
+    if (node.type === 'bundle') {
+      node.value.env = normalizeEnv(node.value.env);
+      node.value.target.env = normalizeEnv(node.value.target.env);
+      graph._graph.addNodeByContentKey(node.id, node as BundleNode);
+      continue;
+    }
+
+    if (node.type === 'bundle_group' || node.type === 'bundleGroup') {
+      // Rust serializer may emit bundleGroup nodes either as `{id,type,value:{...}}`
+      // or as `{type:"bundleGroup", id, target, entryAssetId}`.
+      if (node.value == null) {
+        node.value = {
+          target: node.target,
+          entryAssetId: node.entryAssetId ?? node.entry_asset_id,
+        };
+      }
+
+      // Normalize entry asset id field naming
+      if (
+        node.value.entryAssetId == null &&
+        node.value.entry_asset_id != null
+      ) {
+        node.value.entryAssetId = node.value.entry_asset_id;
+      }
+
+      node.value.target.env = normalizeEnv(node.value.target.env);
+      // Normalise to the expected snake_case type
+      node.type = 'bundle_group';
+      graph._graph.addNodeByContentKey(node.id, node as BundleGroupNode);
+      continue;
+    }
+  }
+
+  // Apply edges
+  for (let i = 0; i < serializedGraph.edges.length; i += 3) {
+    const from = serializedGraph.edges[i];
+    const to = serializedGraph.edges[i + 1];
+    const type = serializedGraph.edges[i + 2];
+
+    const fromNode = graph._graph.getNode(from);
+    const toNode = graph._graph.getNode(to);
+
+    if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+      fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+    }
+
+    // If we are adding a references edge, remove existing null edge.
+    if (
+      type === bundleGraphEdgeTypes.references &&
+      graph._graph.hasEdge(from, to, bundleGraphEdgeTypes.null)
+    ) {
+      graph._graph.removeEdge(from, to, bundleGraphEdgeTypes.null);
+    }
+
+    graph._graph.addEdge(from, to, type as any);
+  }
+
+  return {bundleGraph: graph, changedAssets};
+}
+
+class NativeBundlerRunner {
+  options: AtlaspackOptions;
+  optionsRef: any;
+  config!: AtlaspackConfig;
+  pluginOptions: PluginOptions;
+  api: RunAPI<BundleGraphResult>;
+  previousDevDeps: Map<string, string>;
+  devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>;
+  configs: Map<string, Config>;
+  cacheKey: string;
+
+  constructor({api, options}: any, optionsRef: any) {
+    this.options = options;
+    this.api = api;
+    this.optionsRef = optionsRef;
+    this.previousDevDeps = new Map();
+    this.devDepRequests = new Map();
+    this.configs = new Map();
+    this.pluginOptions = new PluginOptions(
+      optionsProxy(this.options, api.invalidateOnOptionChange),
+    );
+
+    const key = hashString(
+      `${ATLASPACK_VERSION}:BundleGraph:${
+        JSON.stringify(options.entries) ?? ''
+      }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
+    );
+    this.cacheKey = `BundleGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
+  }
+
+  async loadConfigs() {
+    const configResult = nullthrows(
+      await this.api.runRequest<null, ConfigAndCachePath>(
+        createAtlaspackConfigRequest(),
+      ),
+    );
+
+    this.config = getCachedAtlaspackConfig(configResult, this.options);
+
+    const {devDeps, invalidDevDeps} = await getDevDepRequests(this.api);
+    this.previousDevDeps = devDeps;
+    invalidateDevDeps(invalidDevDeps, this.options, this.config);
+
+    const bundler = await this.config.getBundler();
+    await this.loadPluginConfig(bundler);
+
+    const namers = await this.config.getNamers();
+    for (const namer of namers) {
+      await this.loadPluginConfig(namer);
+    }
+
+    const runtimes = await this.config.getRuntimes();
+    for (const runtime of runtimes) {
+      await this.loadPluginConfig(runtime);
+    }
+  }
+
+  async loadPluginConfig<T extends PluginWithLoadConfig>(
+    plugin: LoadedPlugin<T>,
+  ) {
+    await loadPluginConfigWithDevDeps(
+      plugin,
+      this.options,
+      this.api,
+      this.previousDevDeps,
+      this.devDepRequests,
+      this.configs,
+    );
+  }
+}