@atlaspack/core 2.12.1-canary.3354

package/src/requests/ConfigRequest.js

@@ -0,0 +1,287 @@
+// @flow
+import type {
+  Async,
+  Config as IConfig,
+  PluginOptions as IPluginOptions,
+  PluginLogger as IPluginLogger,
+  PluginTracer as IPluginTracer,
+  NamedBundle as INamedBundle,
+  BundleGraph as IBundleGraph,
+} from '@atlaspack/types';
+import {readConfig, hashObject} from '@atlaspack/utils';
+import type {
+  Config,
+  AtlaspackOptions,
+  InternalFileCreateInvalidation,
+} from '../types';
+import type {LoadedPlugin} from '../AtlaspackConfig';
+import type {RequestResult, RunAPI} from '../RequestTracker';
+import type {ProjectPath} from '../projectPath';
+
+import {serializeRaw} from '../serializer.js';
+import {PluginLogger} from '@atlaspack/logger';
+import PluginOptions from '../public/PluginOptions';
+import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
+import PublicConfig from '../public/Config';
+import {optionsProxy} from '../utils';
+import {getInvalidationHash} from '../assetUtils';
+import {hashString, Hash} from '@atlaspack/rust';
+import {PluginTracer} from '@atlaspack/profiler';
+import {requestTypes} from '../RequestTracker';
+import {fromProjectPath, fromProjectPathRelative} from '../projectPath';
+import {createBuildCache} from '../buildCache';
+
+export type PluginWithLoadConfig = {
+  loadConfig?: ({|
+    config: IConfig,
+    options: IPluginOptions,
+    logger: IPluginLogger,
+    tracer: IPluginTracer,
+  |}) => Async<mixed>,
+  ...
+};
+
+export type PluginWithBundleConfig = {
+  loadConfig?: ({|
+    config: IConfig,
+    options: IPluginOptions,
+    logger: IPluginLogger,
+    tracer: IPluginTracer,
+  |}) => Async<mixed>,
+  loadBundleConfig?: ({|
+    bundle: INamedBundle,
+    bundleGraph: IBundleGraph<INamedBundle>,
+    config: IConfig,
+    options: IPluginOptions,
+    logger: IPluginLogger,
+    tracer: IPluginTracer,
+  |}) => Async<mixed>,
+  ...
+};
+
+export type ConfigRequest = {
+  id: string,
+  invalidateOnFileChange: Set<ProjectPath>,
+  invalidateOnConfigKeyChange: Array<{|
+    filePath: ProjectPath,
+    configKey: string,
+  |}>,
+  invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
+  invalidateOnEnvChange: Set<string>,
+  invalidateOnOptionChange: Set<string>,
+  invalidateOnStartup: boolean,
+  invalidateOnBuild: boolean,
+  ...
+};
+
+export type ConfigRequestResult = void;
+
+export async function loadPluginConfig<T: PluginWithLoadConfig>(
+  loadedPlugin: LoadedPlugin<T>,
+  config: Config,
+  options: AtlaspackOptions,
+): Promise<void> {
+  let loadConfig = loadedPlugin.plugin.loadConfig;
+  if (!loadConfig) {
+    return;
+  }
+
+  try {
+    config.result = await loadConfig({
+      config: new PublicConfig(config, options),
+      options: new PluginOptions(
+        optionsProxy(options, option => {
+          config.invalidateOnOptionChange.add(option);
+        }),
+      ),
+      logger: new PluginLogger({origin: loadedPlugin.name}),
+      tracer: new PluginTracer({
+        origin: loadedPlugin.name,
+        category: 'loadConfig',
+      }),
+    });
+  } catch (e) {
+    throw new ThrowableDiagnostic({
+      diagnostic: errorToDiagnostic(e, {
+        origin: loadedPlugin.name,
+      }),
+    });
+  }
+}
+
+const configKeyCache = createBuildCache();
+
+export async function getConfigKeyContentHash(
+  filePath: ProjectPath,
+  configKey: string,
+  options: AtlaspackOptions,
+): Async<string> {
+  let cacheKey = `${fromProjectPathRelative(filePath)}:${configKey}`;
+  let cachedValue = configKeyCache.get(cacheKey);
+
+  if (cachedValue) {
+    return cachedValue;
+  }
+
+  let conf = await readConfig(
+    options.inputFS,
+    fromProjectPath(options.projectRoot, filePath),
+  );
+
+  if (conf == null || conf.config[configKey] == null) {
+    // This can occur when a config key has been removed entirely during `respondToFSEvents`
+    return '';
+  }
+
+  let contentHash =
+    typeof conf.config[configKey] === 'object'
+      ? hashObject(conf.config[configKey])
+      : hashString(JSON.stringify(conf.config[configKey]));
+
+  configKeyCache.set(cacheKey, contentHash);
+
+  return contentHash;
+}
+
+export async function runConfigRequest<TResult: RequestResult>(
+  api: RunAPI<TResult>,
+  configRequest: ConfigRequest,
+) {
+  let {
+    invalidateOnFileChange,
+    invalidateOnConfigKeyChange,
+    invalidateOnFileCreate,
+    invalidateOnEnvChange,
+    invalidateOnOptionChange,
+    invalidateOnStartup,
+    invalidateOnBuild,
+  } = configRequest;
+
+  // If there are no invalidations, then no need to create a node.
+  if (
+    invalidateOnFileChange.size === 0 &&
+    invalidateOnConfigKeyChange.length === 0 &&
+    invalidateOnFileCreate.length === 0 &&
+    invalidateOnOptionChange.size === 0 &&
+    invalidateOnEnvChange.size === 0 &&
+    !invalidateOnStartup &&
+    !invalidateOnBuild
+  ) {
+    return;
+  }
+
+  await api.runRequest<null, void>({
+    id: 'config_request:' + configRequest.id,
+    type: requestTypes.config_request,
+    run: async ({api, options}) => {
+      for (let filePath of invalidateOnFileChange) {
+        api.invalidateOnFileUpdate(filePath);
+        api.invalidateOnFileDelete(filePath);
+      }
+
+      for (let {filePath, configKey} of invalidateOnConfigKeyChange) {
+        let contentHash = await getConfigKeyContentHash(
+          filePath,
+          configKey,
+          options,
+        );
+
+        api.invalidateOnConfigKeyChange(filePath, configKey, contentHash);
+      }
+
+      for (let invalidation of invalidateOnFileCreate) {
+        api.invalidateOnFileCreate(invalidation);
+      }
+
+      for (let env of invalidateOnEnvChange) {
+        api.invalidateOnEnvChange(env);
+      }
+
+      for (let option of invalidateOnOptionChange) {
+        api.invalidateOnOptionChange(option);
+      }
+
+      if (invalidateOnStartup) {
+        api.invalidateOnStartup();
+      }
+
+      if (invalidateOnBuild) {
+        api.invalidateOnBuild();
+      }
+    },
+    input: null,
+  });
+}
+
+export async function getConfigHash(
+  config: Config,
+  pluginName: string,
+  options: AtlaspackOptions,
+): Promise<string> {
+  if (config.result == null) {
+    return '';
+  }
+
+  let hash = new Hash();
+  hash.writeString(config.id);
+
+  // If there is no result hash set by the transformer, default to hashing the included
+  // files if any, otherwise try to hash the config result itself.
+  if (config.cacheKey == null) {
+    if (config.invalidateOnFileChange.size > 0) {
+      hash.writeString(
+        await getInvalidationHash(
+          [...config.invalidateOnFileChange].map(filePath => ({
+            type: 'file',
+            filePath,
+          })),
+          options,
+        ),
+      );
+    } else if (config.result != null) {
+      try {
+        hash.writeBuffer(serializeRaw(config.result));
+      } catch (err) {
+        throw new ThrowableDiagnostic({
+          diagnostic: {
+            message:
+              'Config result is not hashable because it contains non-serializable objects. Please use config.setCacheKey to set the hash manually.',
+            origin: pluginName,
+          },
+        });
+      }
+    }
+  } else {
+    hash.writeString(config.cacheKey ?? '');
+  }
+
+  return hash.finish();
+}
+
+export function getConfigRequests(
+  configs: Array<Config>,
+): Array<ConfigRequest> {
+  return configs
+    .filter(config => {
+      // No need to send to the graph if there are no invalidations.
+      return (
+        config.invalidateOnFileChange.size > 0 ||
+        config.invalidateOnConfigKeyChange.length > 0 ||
+        config.invalidateOnFileCreate.length > 0 ||
+        config.invalidateOnEnvChange.size > 0 ||
+        config.invalidateOnOptionChange.size > 0 ||
+        config.invalidateOnStartup ||
+        config.invalidateOnBuild
+      );
+    })
+    .map(config => ({
+      id: config.id,
+      invalidateOnFileChange: config.invalidateOnFileChange,
+      invalidateOnConfigKeyChange: config.invalidateOnConfigKeyChange,
+      invalidateOnFileCreate: config.invalidateOnFileCreate,
+      invalidateOnEnvChange: config.invalidateOnEnvChange,
+      invalidateOnOptionChange: config.invalidateOnOptionChange,
+      invalidateOnStartup: config.invalidateOnStartup,
+      invalidateOnBuild: config.invalidateOnBuild,
+    }));
+}

package/src/requests/DevDepRequest.js

@@ -0,0 +1,246 @@
+// @flow
+import type {
+  DependencySpecifier,
+  SemverRange,
+  Invalidations,
+} from '@atlaspack/types';
+import type AtlaspackConfig from '../AtlaspackConfig';
+import type {
+  DevDepRequest,
+  AtlaspackOptions,
+  InternalDevDepOptions,
+} from '../types';
+import type {RequestResult, RunAPI} from '../RequestTracker';
+import type {ProjectPath} from '../projectPath';
+
+import nullthrows from 'nullthrows';
+import {getInvalidationHash} from '../assetUtils';
+import {createBuildCache} from '../buildCache';
+import {invalidateOnFileCreateToInternal} from '../utils';
+import {
+  fromProjectPath,
+  fromProjectPathRelative,
+  toProjectPath,
+} from '../projectPath';
+import {requestTypes} from '../RequestTracker';
+
+// A cache of dev dep requests keyed by invalidations.
+// If the package manager returns the same invalidation object, then
+// we can reuse the dev dep request rather than recomputing the project
+// paths and hashes.
+const devDepRequestCache: WeakMap<Invalidations, DevDepRequest> = new WeakMap();
+
+export async function createDevDependency(
+  opts: InternalDevDepOptions,
+  requestDevDeps: Map<string, string>,
+  options: AtlaspackOptions,
+): Promise<DevDepRequest> {
+  let {specifier, resolveFrom, additionalInvalidations} = opts;
+  let key = `${specifier}:${fromProjectPathRelative(resolveFrom)}`;
+
+  // If the request sent us a hash, we know the dev dep and all of its dependencies didn't change.
+  // Reuse the same hash in the response. No need to send back invalidations as the request won't
+  // be re-run anyway.
+  let hash = requestDevDeps.get(key);
+  if (hash != null) {
+    return {
+      specifier,
+      resolveFrom,
+      hash,
+    };
+  }
+
+  let resolveFromAbsolute = fromProjectPath(options.projectRoot, resolveFrom);
+
+  // Ensure that the package manager has an entry for this resolution.
+  try {
+    await options.packageManager.resolve(specifier, resolveFromAbsolute);
+  } catch (err) {
+    // ignore
+  }
+
+  let invalidations = options.packageManager.getInvalidations(
+    specifier,
+    resolveFromAbsolute,
+  );
+
+  let cached = devDepRequestCache.get(invalidations);
+  if (cached != null) {
+    return cached;
+  }
+
+  let invalidateOnFileChangeProject = [
+    ...invalidations.invalidateOnFileChange,
+  ].map(f => toProjectPath(options.projectRoot, f));
+
+  // It is possible for a transformer to have multiple different hashes due to
+  // different dependencies (e.g. conditional requires) so we must always
+  // recompute the hash and compare rather than only sending a transformer
+  // dev dependency once.
+  hash = await getInvalidationHash(
+    invalidateOnFileChangeProject.map(f => ({
+      type: 'file',
+      filePath: f,
+    })),
+    options,
+  );
+
+  let devDepRequest: DevDepRequest = {
+    specifier,
+    resolveFrom,
+    hash,
+    invalidateOnFileCreate: invalidations.invalidateOnFileCreate.map(i =>
+      invalidateOnFileCreateToInternal(options.projectRoot, i),
+    ),
+    invalidateOnFileChange: new Set(invalidateOnFileChangeProject),
+    invalidateOnStartup: invalidations.invalidateOnStartup,
+    additionalInvalidations,
+  };
+
+  devDepRequestCache.set(invalidations, devDepRequest);
+  return devDepRequest;
+}
+
+export type DevDepSpecifier = {|
+  specifier: DependencySpecifier,
+  resolveFrom: ProjectPath,
+|};
+
+type DevDepRequests = {|
+  devDeps: Map<string, string>,
+  invalidDevDeps: Array<DevDepSpecifier>,
+|};
+
+export async function getDevDepRequests<TResult: RequestResult>(
+  api: RunAPI<TResult>,
+): Promise<DevDepRequests> {
+  let previousDevDepRequests: Map<string, DevDepRequestResult> = new Map(
+    await Promise.all(
+      api
+        .getSubRequests()
+        .filter(req => req.requestType === requestTypes.dev_dep_request)
+        .map(async req => [
+          req.id,
+          nullthrows(await api.getRequestResult<DevDepRequestResult>(req.id)),
+        ]),
+    ),
+  );
+
+  return {
+    devDeps: new Map(
+      [...previousDevDepRequests.entries()]
+        .filter(([id]) => api.canSkipSubrequest(id))
+        .map(([, req]: [string, DevDepRequestResult]) => [
+          `${req.specifier}:${fromProjectPathRelative(req.resolveFrom)}`,
+          req.hash,
+        ]),
+    ),
+    invalidDevDeps: await Promise.all(
+      [...previousDevDepRequests.entries()]
+        .filter(([id]) => !api.canSkipSubrequest(id))
+        .flatMap(([, req]: [string, DevDepRequestResult]) => {
+          return [
+            {
+              specifier: req.specifier,
+              resolveFrom: req.resolveFrom,
+            },
+            ...(req.additionalInvalidations ?? []).map(i => ({
+              specifier: i.specifier,
+              resolveFrom: i.resolveFrom,
+            })),
+          ];
+        }),
+    ),
+  };
+}
+
+// Tracks dev deps that have been invalidated during this build
+// so we don't invalidate the require cache more than once.
+const invalidatedDevDeps = createBuildCache();
+
+export function invalidateDevDeps(
+  invalidDevDeps: Array<DevDepSpecifier>,
+  options: AtlaspackOptions,
+  config: AtlaspackConfig,
+) {
+  for (let {specifier, resolveFrom} of invalidDevDeps) {
+    let key = `${specifier}:${fromProjectPathRelative(resolveFrom)}`;
+    if (!invalidatedDevDeps.has(key)) {
+      config.invalidatePlugin(specifier);
+      options.packageManager.invalidate(
+        specifier,
+        fromProjectPath(options.projectRoot, resolveFrom),
+      );
+      invalidatedDevDeps.set(key, true);
+    }
+  }
+}
+
+export type DevDepRequestResult = {|
+  specifier: DependencySpecifier,
+  resolveFrom: ProjectPath,
+  hash: string,
+  additionalInvalidations: void | Array<{|
+    range?: ?SemverRange,
+    resolveFrom: ProjectPath,
+    specifier: DependencySpecifier,
+  |}>,
+|};
+
+export async function runDevDepRequest<TResult: RequestResult>(
+  api: RunAPI<TResult>,
+  devDepRequest: DevDepRequest,
+) {
+  await api.runRequest<null, DevDepRequestResult | void>({
+    id: 'dev_dep_request:' + devDepRequest.specifier + ':' + devDepRequest.hash,
+    type: requestTypes.dev_dep_request,
+    run: ({api}) => {
+      for (let filePath of nullthrows(
+        devDepRequest.invalidateOnFileChange,
+        'DevDepRequest missing invalidateOnFileChange',
+      )) {
+        api.invalidateOnFileUpdate(filePath);
+        api.invalidateOnFileDelete(filePath);
+      }
+
+      for (let invalidation of nullthrows(
+        devDepRequest.invalidateOnFileCreate,
+        'DevDepRequest missing invalidateOnFileCreate',
+      )) {
+        api.invalidateOnFileCreate(invalidation);
+      }
+
+      if (devDepRequest.invalidateOnStartup) {
+        api.invalidateOnStartup();
+      }
+
+      api.storeResult({
+        specifier: devDepRequest.specifier,
+        resolveFrom: devDepRequest.resolveFrom,
+        hash: devDepRequest.hash,
+        additionalInvalidations: devDepRequest.additionalInvalidations,
+      });
+    },
+    input: null,
+  });
+}
+
+// A cache of plugin dependency hashes that we've already sent to the main thread.
+// Automatically cleared before each build.
+const pluginCache = createBuildCache();
+
+export function getWorkerDevDepRequests(
+  devDepRequests: Array<DevDepRequest>,
+): Array<DevDepRequest> {
+  return devDepRequests.map(devDepRequest => {
+    // If we've already sent a matching transformer + hash to the main thread during this build,
+    // there's no need to repeat ourselves.
+    let {specifier, resolveFrom, hash} = devDepRequest;
+    if (hash === pluginCache.get(specifier)) {
+      return {specifier, resolveFrom, hash};
+    } else {
+      pluginCache.set(specifier, hash);
+      return devDepRequest;
+    }
+  });
+}