@atlaspack/core 2.30.2 → 2.31.0

package/src/atlaspack-v3/worker/worker.ts

@@ -1,3 +1,10 @@
+/* eslint-disable import/first */
+import {SideEffectDetector} from './side-effect-detector';
+
+// Install side effect detection patches BEFORE importing any modules that use fs
+const sideEffectDetector = new SideEffectDetector();
+sideEffectDetector.install();
+
 import assert from 'assert';
 import * as napi from '@atlaspack/rust';
 // @ts-expect-error TS2305
@@ -10,6 +17,7 @@ import type {
   FilePath,
   FileSystem,
 } from '@atlaspack/types';
+import type {FeatureFlags} from '@atlaspack/feature-flags';
 import {parentPort} from 'worker_threads';
 import * as module from 'module';
 
@@ -25,7 +33,6 @@ import {
   bundleBehaviorMap,
   dependencyPriorityMap,
 } from './compat';
-import {FeatureFlags} from '@atlaspack/feature-flags';
 
 const CONFIG = Symbol.for('parcel-plugin-config');
 
@@ -34,16 +41,25 @@ export class AtlaspackWorker {
   #transformers: Map<string, TransformerState<any>>;
   #fs: FileSystem;
   #packageManager: NodePackageManager;
+  #options: Options | undefined;
+  #sideEffectDetector: SideEffectDetector;
 
   constructor() {
     this.#resolvers = new Map();
     this.#transformers = new Map();
     this.#fs = new NodeFS();
     this.#packageManager = new NodePackageManager(this.#fs, '/');
+    this.#sideEffectDetector = sideEffectDetector; // Use the global detector that was installed before imports
+  }
+
+  clearState() {
+    this.#resolvers.clear();
+    this.#transformers.clear();
+    this.#options = undefined;
   }
 
   loadPlugin: JsCallable<[LoadPluginOptions], Promise<undefined>> = jsCallable(
-    async ({kind, specifier, resolveFrom, featureFlags}) => {
+    async ({kind, specifier, resolveFrom, options}) => {
       // Use packageManager.require() instead of dynamic import() to support TypeScript plugins
       let resolvedModule = await this.#packageManager.require(
         specifier,
@@ -70,26 +86,32 @@ export class AtlaspackWorker {
           `Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`,
         );
       }
-      // Set feature flags in the worker process
-      // if (featureFlags) {
+
+      if (this.#options == null) {
+        this.#options = {
+          ...options,
+          inputFS: this.#fs,
+          outputFS: this.#fs,
+          packageManager: this.#packageManager,
+          shouldAutoInstall: false,
+        };
+      }
+
       // Set feature flags in the worker process
       let featureFlagsModule = await this.#packageManager.require(
         '@atlaspack/feature-flags',
         __filename,
         {shouldAutoInstall: false},
       );
-      featureFlagsModule.setFeatureFlags(featureFlags);
-      // const {setFeatureFlags} = await import('@atlaspack/feature-flags');
-      // setFeatureFlags(featureFlags);
-      // }
+      featureFlagsModule.setFeatureFlags(options.featureFlags);
 
       switch (kind) {
         case 'resolver':
           this.#resolvers.set(specifier, {resolver: instance});
           break;
-        case 'transformer':
-          this.#transformers.set(specifier, {transformer: instance});
-          break;
+        case 'transformer': {
+          return this.initializeTransformer(instance, specifier);
+        }
       }
     },
   );
@@ -98,53 +120,33 @@ export class AtlaspackWorker {
     [RunResolverResolveOptions],
     Promise<RunResolverResolveResult>
   > = jsCallable(
-    async ({
-      key,
-      dependency: napiDependency,
-      specifier,
-      pipeline,
-      pluginOptions,
-    }) => {
+    async ({key, dependency: napiDependency, specifier, pipeline}) => {
       const state = this.#resolvers.get(key);
       if (!state) {
         throw new Error(`Resolver not found: ${key}`);
       }
 
-      let packageManager = state.packageManager;
-      if (!packageManager) {
-        packageManager = new NodePackageManager(
-          this.#fs,
-          pluginOptions.projectRoot,
-        );
-        state.packageManager = packageManager;
-      }
-
       const env = new Environment(napiDependency.env);
       const dependency = new Dependency(napiDependency, env);
 
       const defaultOptions = {
         logger: new PluginLogger(),
         tracer: new PluginTracer(),
-        options: new PluginOptions({
-          ...pluginOptions,
-          packageManager,
-          shouldAutoInstall: false,
-          inputFS: this.#fs,
-          outputFS: this.#fs,
-        }),
+        options: new PluginOptions(this.options),
       } as const;
 
       if (!('config' in state)) {
         // @ts-expect-error TS2345
         state.config = await state.resolver.loadConfig?.({
-          config: new PluginConfig({
-            env,
-            isSource: true,
-            searchPath: specifier,
-            projectRoot: pluginOptions.projectRoot,
-            fs: this.#fs,
-            packageManager,
-          }),
+          config: new PluginConfig(
+            {
+              env: napiDependency.env,
+              plugin: key,
+              isSource: true,
+              searchPath: 'index',
+            },
+            this.options,
+          ),
           ...defaultOptions,
         });
       }
@@ -192,155 +194,248 @@ export class AtlaspackWorker {
   runTransformerTransform: JsCallable<
     [RunTransformerTransformOptions, Buffer, string | null | undefined],
     Promise<RunTransformerTransformResult>
-  > = jsCallable(
-    async ({key, env: napiEnv, options, asset: innerAsset}, contents, map) => {
-      const state = this.#transformers.get(key);
-      if (!state) {
-        throw new Error(`Transformer not found: ${key}`);
-      }
+  > = jsCallable(async ({key, asset: innerAsset}, contents, map) => {
+    const instance = this.#transformers.get(key);
+    if (!instance) {
+      throw new Error(`Transformer not found: ${key}`);
+    }
 
-      let packageManager = state.packageManager;
-      if (!packageManager) {
-        packageManager = new NodePackageManager(this.#fs, options.projectRoot);
-        state.packageManager = packageManager;
-      }
+    let {transformer, config, allowedEnv = new Set()} = instance;
 
-      const transformer: Transformer<any> = state.transformer;
-      const resolveFunc = (from: string, to: string): Promise<any> => {
-        let customRequire = module.createRequire(from);
-        let resolvedPath = customRequire.resolve(to);
+    let cacheBailouts = [];
 
-        return Promise.resolve(resolvedPath);
-      };
+    const resolveFunc = (from: string, to: string): Promise<any> => {
+      let customRequire = module.createRequire(from);
+      let resolvedPath = customRequire.resolve(to);
+      // Tranformer not cacheable due to use of the resolve function
 
-      const env = new Environment(napiEnv);
-      const mutableAsset = new MutableAsset(
-        innerAsset,
-        // @ts-expect-error TS2345
-        contents,
-        env,
-        this.#fs,
-        map,
-        options.projectRoot,
-      );
+      cacheBailouts.push(`resolve(${from}, ${to})`);
 
-      const defaultOptions = {
-        logger: new PluginLogger(),
-        tracer: new PluginTracer(),
-        options: new PluginOptions({
-          ...options,
-          packageManager,
-          shouldAutoInstall: false,
-          inputFS: this.#fs,
-          outputFS: this.#fs,
-        }),
-      } as const;
+      return Promise.resolve(resolvedPath);
+    };
 
+    const env = new Environment(innerAsset.env);
+    let mutableAsset = new MutableAsset(
+      innerAsset,
       // @ts-expect-error TS2345
-      const config = await transformer.loadConfig?.({
-        config: new PluginConfig({
-          env,
-          isSource: true,
-          searchPath: innerAsset.filePath,
-          projectRoot: options.projectRoot,
-          fs: this.#fs,
-          packageManager,
-        }),
+      contents,
+      env,
+      this.#fs,
+      map,
+      this.options.projectRoot,
+    );
+
+    const pluginOptions = new PluginOptions(this.options);
+    const defaultOptions = {
+      logger: new PluginLogger(),
+      tracer: new PluginTracer(),
+      options: pluginOptions,
+    } as const;
+
+    if (transformer.loadConfig) {
+      if (config != null) {
+        throw new Error(
+          `Transformer (${key}) should not implement 'setup' and 'loadConfig'`,
+        );
+      }
+      // @ts-expect-error TS2345
+      config = await transformer.loadConfig({
+        config: new PluginConfig(
+          {
+            plugin: key,
+            isSource: innerAsset.isSource,
+            searchPath: innerAsset.filePath,
+            env,
+          },
+          this.options,
+        ),
         ...defaultOptions,
       });
 
-      if (transformer.parse) {
-        const ast = await transformer.parse({
-          // @ts-expect-error TS2322
-          asset: mutableAsset,
-          config,
-          resolve: resolveFunc,
-          ...defaultOptions,
-        });
-        if (ast) {
-          mutableAsset.setAST(ast);
-        }
-      }
+      // Transformer uses the deprecated loadConfig API, so mark as not
+      // cachable
+      cacheBailouts.push(`Transformer.loadConfig`);
+    }
 
-      const result = await state.transformer.transform({
+    if (transformer.parse) {
+      const ast = await transformer.parse({
         // @ts-expect-error TS2322
         asset: mutableAsset,
         config,
         resolve: resolveFunc,
         ...defaultOptions,
       });
+      if (ast) {
+        mutableAsset.setAST(ast);
+      }
+      cacheBailouts.push(`Transformer.parse`);
+    }
+
+    const [result, sideEffects] =
+      await this.#sideEffectDetector.monitorSideEffects(key, () =>
+        transformer.transform({
+          // @ts-expect-error TS2322
+          asset: mutableAsset,
+          config,
+          resolve: resolveFunc,
+          ...defaultOptions,
+        }),
+      );
+
+    if (sideEffects.envUsage.didEnumerate) {
+      cacheBailouts.push(`Env access: enumeration of process.env`);
+    }
 
-      if (transformer.generate) {
-        const ast = await mutableAsset.getAST();
-        if (ast) {
-          const output = await transformer.generate({
-            // @ts-expect-error TS2322
-            asset: mutableAsset,
-            ast,
-            ...defaultOptions,
-          });
-
-          if (typeof output.content === 'string') {
-            mutableAsset.setCode(output.content);
-          } else if (output.content instanceof Buffer) {
-            mutableAsset.setBuffer(output.content);
-          } else {
-            // @ts-expect-error TS2345
-            mutableAsset.setStream(output.content);
-          }
-
-          if (output.map) {
-            mutableAsset.setMap(output.map);
-          }
+    for (let variable of sideEffects.envUsage.vars) {
+      if (variable in allowedEnv) {
+        continue;
+      }
+
+      cacheBailouts.push(`Env access: ${variable}`);
+    }
+
+    for (let {method, path} of sideEffects.fsUsage) {
+      cacheBailouts.push(`FS usage: ${method}(${path})`);
+    }
+
+    assert(
+      result.length === 1,
+      '[V3] Unimplemented: Multiple asset return from Node transformer',
+    );
+
+    assert(
+      result[0] === mutableAsset,
+      '[V3] Unimplemented: New asset returned from Node transformer',
+    );
+
+    if (transformer.generate) {
+      const ast = await mutableAsset.getAST();
+      if (ast) {
+        const output = await transformer.generate({
+          // @ts-expect-error TS2322
+          asset: mutableAsset,
+          ast,
+          ...defaultOptions,
+        });
+
+        if (typeof output.content === 'string') {
+          mutableAsset.setCode(output.content);
+        } else if (output.content instanceof Buffer) {
+          mutableAsset.setBuffer(output.content);
+        } else {
+          // @ts-expect-error TS2345
+          mutableAsset.setStream(output.content);
+        }
+
+        if (output.map) {
+          mutableAsset.setMap(output.map);
         }
       }
+    }
+
+    let assetBuffer: Buffer | null = await mutableAsset.getBuffer();
+
+    // If the asset has no code, we set the buffer to null, which we can
+    // detect in Rust, to avoid passing back an empty buffer, which we can't.
+    if (assetBuffer.length === 0) {
+      assetBuffer = null;
+    }
+
+    if (pluginOptions.used) {
+      // Plugin options accessed, so not cachable
+      cacheBailouts.push(`Plugin options accessed`);
+    }
+
+    return [
+      {
+        id: mutableAsset.id,
+        bundleBehavior: bundleBehaviorMap.intoNullable(
+          mutableAsset.bundleBehavior,
+        ),
+        code: [],
+        filePath: mutableAsset.filePath,
+        isBundleSplittable: mutableAsset.isBundleSplittable,
+        isSource: mutableAsset.isSource,
+        meta: mutableAsset.meta,
+        pipeline: mutableAsset.pipeline,
+        // Query should be undefined if it's empty
+        query: mutableAsset.query.toString() || undefined,
+        sideEffects: mutableAsset.sideEffects,
+        symbols: mutableAsset.symbols.intoNapi(),
+        type: mutableAsset.type,
+        uniqueKey: mutableAsset.uniqueKey,
+      },
+      assetBuffer,
+      // Only send back the map if it has changed
+      mutableAsset.isMapDirty
+        ? // @ts-expect-error TS2533
+          JSON.stringify((await mutableAsset.getMap()).toVLQ())
+        : '',
+      // Limit to first 10 bailouts
+      cacheBailouts.slice(0, 10),
+    ];
+  });
+
+  get options() {
+    if (this.#options == null) {
+      throw new Error('Plugin options have not been initialized');
+    }
+    return this.#options;
+  }
 
-      assert(
-        result.length === 1,
-        '[V3] Unimplemented: Multiple asset return from Node transformer',
-      );
+  async initializeTransformer(instance: Transformer<any>, specifier: string) {
+    let transformer = instance;
+    let setup, config, allowedEnv;
+
+    let packageManager = new NodePackageManager(
+      this.#fs,
+      this.options.projectRoot,
+    );
 
-      assert(
-        result[0] === mutableAsset,
-        '[V3] Unimplemented: New asset returned from Node transformer',
+    if (transformer.setup) {
+      let setupResult = await transformer.setup({
+        logger: new PluginLogger(),
+        options: new PluginOptions({
+          ...this.options,
+          shouldAutoInstall: false,
+          inputFS: this.#fs,
+          outputFS: this.#fs,
+          packageManager,
+        }),
+        config: new PluginConfig(
+          {
+            plugin: specifier,
+            searchPath: 'index',
+            // Consider project setup config as source
+            isSource: true,
+          },
+          this.options,
+        ),
+      });
+      config = setupResult?.config;
+      allowedEnv = Object.fromEntries(
+        setupResult?.env?.map((env) => [env, process.env[env]]) || [],
       );
 
-      let assetBuffer: Buffer | null = await mutableAsset.getBuffer();
+      // Always add the following env vars to the cache key
+      allowedEnv['NODE_ENV'] = process.env['NODE_ENV'];
 
-      // If the asset has no code, we set the buffer to null, which we can
-      // detect in Rust, to avoid passing back an empty buffer, which we can't.
-      if (assetBuffer.length === 0) {
-        assetBuffer = null;
-      }
+      setup = {
+        conditions: setupResult?.conditions,
+        config,
+        env: allowedEnv,
+      };
+    }
 
-      return [
-        {
-          id: mutableAsset.id,
-          bundleBehavior: bundleBehaviorMap.intoNullable(
-            mutableAsset.bundleBehavior,
-          ),
-          code: [],
-          filePath: mutableAsset.filePath,
-          isBundleSplittable: mutableAsset.isBundleSplittable,
-          isSource: mutableAsset.isSource,
-          meta: mutableAsset.meta,
-          pipeline: mutableAsset.pipeline,
-          // Query should be undefined if it's empty
-          query: mutableAsset.query.toString() || undefined,
-          sideEffects: mutableAsset.sideEffects,
-          symbols: mutableAsset.symbols.intoNapi(),
-          type: mutableAsset.type,
-          uniqueKey: mutableAsset.uniqueKey,
-        },
-        assetBuffer,
-        // Only send back the map if it has changed
-        mutableAsset.isMapDirty
-          ? // @ts-expect-error TS2533
-            JSON.stringify((await mutableAsset.getMap()).toVLQ())
-          : '',
-      ];
-    },
-  );
+    this.#transformers.set(specifier, {
+      transformer,
+      config,
+      packageManager,
+      allowedEnv,
+    });
+
+    return setup;
+  }
 }
 
 // Create napi worker and send it back to main thread
@@ -348,27 +443,45 @@ const worker = new AtlaspackWorker();
 const napiWorker = napi.newNodejsWorker(worker);
 parentPort?.postMessage(napiWorker);
 
+parentPort?.setMaxListeners(parentPort.getMaxListeners() + 1);
+parentPort?.addListener('message', (message: unknown) => {
+  if (message === 'clearState') {
+    worker.clearState();
+    parentPort?.postMessage('stateCleared');
+  }
+});
+
 type ResolverState<T> = {
   resolver: Resolver<T>;
   config?: T;
   packageManager?: NodePackageManager;
 };
 
-type TransformerState<T> = {
+type TransformerState<ConfigType> = {
   packageManager?: NodePackageManager;
-  transformer: Transformer<T>;
+  transformer: Transformer<ConfigType>;
+  config?: ConfigType;
+  allowedEnv?: Record<string, string | undefined>;
 };
 
 type LoadPluginOptions = {
   kind: 'resolver' | 'transformer';
   specifier: string;
   resolveFrom: string;
-  featureFlags?: FeatureFlags;
+  options: RpcPluginOptions;
 };
 
 type RpcPluginOptions = {
   projectRoot: string;
   mode: string;
+  featureFlags: FeatureFlags;
+};
+
+type Options = RpcPluginOptions & {
+  inputFS: FileSystem;
+  outputFS: FileSystem;
+  packageManager: NodePackageManager;
+  shouldAutoInstall: boolean;
 };
 
 type RunResolverResolveOptions = {
@@ -377,7 +490,6 @@ type RunResolverResolveOptions = {
   dependency: napi.Dependency;
   specifier: FilePath;
   pipeline: string | null | undefined;
-  pluginOptions: RpcPluginOptions;
 };
 
 type RunResolverResolveResult = {
@@ -406,10 +518,14 @@ type RunTransformerTransformOptions = {
   key: string;
   // @ts-expect-error TS2724
   env: napi.Environment;
-  options: RpcPluginOptions;
   // @ts-expect-error TS2694
   asset: napi.Asset;
 };
 
-// @ts-expect-error TS2694
-type RunTransformerTransformResult = [napi.RpcAssetResult, Buffer, string];
+type RunTransformerTransformResult = [
+  // @ts-expect-error TS2694
+  napi.RpcAssetResult,
+  Buffer,
+  string,
+  boolean,
+];

package/src/requests/ConfigRequest.ts

@@ -6,6 +6,7 @@ import type {
   PluginTracer as IPluginTracer,
   NamedBundle as INamedBundle,
   BundleGraph as IBundleGraph,
+  TransformerSetup,
 } from '@atlaspack/types';
 import {readConfig, hashObject} from '@atlaspack/utils';
 import type {
@@ -29,6 +30,13 @@ import {PluginTracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {fromProjectPath, fromProjectPathRelative} from '../projectPath';
 
+type Setup<T> = (arg1: {
+  config: IConfig;
+  options: IPluginOptions;
+  logger: IPluginLogger;
+  tracer: IPluginTracer;
+}) => Async<TransformerSetup<T>>;
+
 export type PluginWithLoadConfig = {
   loadConfig?: (arg1: {
     config: IConfig;
@@ -104,6 +112,37 @@ export async function loadPluginConfig<T extends PluginWithLoadConfig>(
   }
 }
 
+export async function loadPluginSetup<T>(
+  pluginName: string,
+  setup: Setup<T>,
+  config: Config,
+  options: AtlaspackOptions,
+): Promise<void> {
+  try {
+    let result = await setup({
+      config: new PublicConfig(config, options),
+      options: new PluginOptions(
+        optionsProxy(options, (option) => {
+          config.invalidateOnOptionChange.add(option);
+        }),
+      ),
+      logger: new PluginLogger({origin: pluginName}),
+      tracer: new PluginTracer({
+        origin: pluginName,
+        category: 'setup',
+      }),
+    });
+
+    config.result = result.config;
+  } catch (e: any) {
+    throw new ThrowableDiagnostic({
+      diagnostic: errorToDiagnostic(e, {
+        origin: pluginName,
+      }),
+    });
+  }
+}
+
 /**
  * Return value at a given key path within an object.
  *