@atlaspack/core 2.12.1-canary.3354

package/src/requests/EntryRequest.js

@@ -0,0 +1,385 @@
+// @flow strict-local
+
+import type {Async, FilePath, PackageJSON, Glob} from '@atlaspack/types';
+import type {StaticRunOpts} from '../RequestTracker';
+import type {Entry, InternalFile, AtlaspackOptions} from '../types';
+import type {FileSystem} from '@atlaspack/fs';
+
+import {
+  isDirectoryInside,
+  isGlob,
+  glob,
+  findAlternativeFiles,
+} from '@atlaspack/utils';
+import ThrowableDiagnostic, {
+  md,
+  generateJSONCodeHighlights,
+  getJSONSourceLocation,
+} from '@atlaspack/diagnostic';
+import path from 'path';
+import {parse, type Mapping} from '@mischnic/json-sourcemap';
+import {requestTypes} from '../RequestTracker';
+import {
+  type ProjectPath,
+  fromProjectPath,
+  fromProjectPathRelative,
+  toProjectPath,
+} from '../projectPath';
+
+type RunOpts<TResult> = {|
+  input: ProjectPath,
+  ...StaticRunOpts<TResult>,
+|};
+
+export type EntryRequest = {|
+  id: string,
+  +type: typeof requestTypes.entry_request,
+  run: (RunOpts<EntryRequestResult>) => Async<EntryRequestResult>,
+  input: ProjectPath,
+|};
+
+export type EntryRequestResult = {|
+  entries: Array<Entry>,
+  files: Array<InternalFile>,
+  globs: Array<Glob>,
+|};
+
+const type = 'entry_request';
+
+export default function createEntryRequest(input: ProjectPath): EntryRequest {
+  return {
+    id: `${type}:${fromProjectPathRelative(input)}`,
+    type: requestTypes.entry_request,
+    run,
+    input,
+  };
+}
+
+async function run({input, api, options}): Promise<EntryRequestResult> {
+  let entryResolver = new EntryResolver(options);
+  let filePath = fromProjectPath(options.projectRoot, input);
+  let result = await entryResolver.resolveEntry(filePath);
+
+  // Connect files like package.json that affect the entry
+  // resolution so we invalidate when they change.
+  for (let file of result.files) {
+    api.invalidateOnFileUpdate(file.filePath);
+    api.invalidateOnFileDelete(file.filePath);
+  }
+
+  // If the entry specifier is a glob, add a glob node so
+  // we invalidate when a new file matches.
+  for (let glob of result.globs) {
+    api.invalidateOnFileCreate({
+      glob: toProjectPath(options.projectRoot, glob),
+    });
+  }
+
+  // Invalidate whenever an entry is deleted.
+  // If the entry was a glob, we'll re-evaluate it, and otherwise
+  // a proper entry error will be thrown.
+  for (let entry of result.entries) {
+    api.invalidateOnFileDelete(entry.filePath);
+  }
+
+  return result;
+}
+
+async function assertFile(
+  fs: FileSystem,
+  entry: FilePath,
+  relativeSource: FilePath,
+  pkgFilePath: FilePath,
+  keyPath: string,
+  options: AtlaspackOptions,
+) {
+  let source = path.join(entry, relativeSource);
+  let stat;
+  try {
+    stat = await fs.stat(source);
+  } catch (err) {
+    let contents = await fs.readFile(pkgFilePath, 'utf8');
+    let alternatives = await findAlternativeFiles(
+      fs,
+      relativeSource,
+      entry,
+      options.projectRoot,
+      false,
+    );
+    throw new ThrowableDiagnostic({
+      diagnostic: {
+        origin: '@atlaspack/core',
+        message: md`${path.relative(process.cwd(), source)} does not exist.`,
+        codeFrames: [
+          {
+            filePath: pkgFilePath,
+            codeHighlights: generateJSONCodeHighlights(contents, [
+              {
+                key: keyPath,
+                type: 'value',
+              },
+            ]),
+          },
+        ],
+        hints: alternatives.map(r => {
+          return md`Did you mean '__${r}__'?`;
+        }),
+      },
+    });
+  }
+
+  if (!stat.isFile()) {
+    let contents = await fs.readFile(pkgFilePath, 'utf8');
+    throw new ThrowableDiagnostic({
+      diagnostic: {
+        origin: '@atlaspack/core',
+        message: md`${path.relative(process.cwd(), source)} is not a file.`,
+        codeFrames: [
+          {
+            filePath: pkgFilePath,
+            codeHighlights: generateJSONCodeHighlights(contents, [
+              {
+                key: keyPath,
+                type: 'value',
+              },
+            ]),
+          },
+        ],
+      },
+    });
+  }
+}
+
+export class EntryResolver {
+  options: AtlaspackOptions;
+
+  constructor(options: AtlaspackOptions) {
+    this.options = options;
+  }
+
+  async resolveEntry(entry: FilePath): Promise<EntryRequestResult> {
+    let stat;
+    try {
+      stat = await this.options.inputFS.stat(entry);
+    } catch (err) {
+      if (!isGlob(entry)) {
+        throw new ThrowableDiagnostic({
+          diagnostic: {
+            message: md`Entry ${entry} does not exist`,
+          },
+        });
+      }
+      let files = await glob(entry, this.options.inputFS, {
+        absolute: true,
+        onlyFiles: false,
+      });
+      let results = await Promise.all(
+        files.map(f => this.resolveEntry(path.normalize(f))),
+      );
+      return results.reduce(
+        (p, res) => ({
+          entries: p.entries.concat(res.entries),
+          files: p.files.concat(res.files),
+          globs: p.globs.concat(res.globs),
+        }),
+        {entries: [], files: [], globs: [entry]},
+      );
+    }
+
+    if (stat.isDirectory()) {
+      let pkg = await this.readPackage(entry);
+
+      if (pkg) {
+        let {filePath} = pkg;
+        let entries = [];
+        let files = [
+          {
+            filePath: toProjectPath(this.options.projectRoot, filePath),
+          },
+        ];
+        let globs = [];
+
+        let targetsWithSources = 0;
+        if (pkg.targets) {
+          for (let targetName in pkg.targets) {
+            let target = pkg.targets[targetName];
+            if (target.source != null) {
+              targetsWithSources++;
+              let targetSources = Array.isArray(target.source)
+                ? target.source
+                : [target.source];
+              let i = 0;
+              for (let source of targetSources) {
+                let sources;
+                if (isGlob(source)) {
+                  globs.push(source);
+                  sources = await glob(source, this.options.inputFS, {
+                    onlyFiles: true,
+                    cwd: entry,
+                  });
+                } else {
+                  sources = [source];
+                }
+                let keyPath = `/targets/${targetName}/source${
+                  Array.isArray(target.source) ? `/${i}` : ''
+                }`;
+                for (let relativeSource of sources) {
+                  let source = path.join(entry, relativeSource);
+                  await assertFile(
+                    this.options.inputFS,
+                    entry,
+                    relativeSource,
+                    filePath,
+                    keyPath,
+                    this.options,
+                  );
+
+                  entries.push({
+                    filePath: toProjectPath(this.options.projectRoot, source),
+                    packagePath: toProjectPath(this.options.projectRoot, entry),
+                    target: targetName,
+                    loc: {
+                      filePath: toProjectPath(
+                        this.options.projectRoot,
+                        pkg.filePath,
+                      ),
+                      ...getJSONSourceLocation(
+                        pkg.map.pointers[keyPath],
+                        'value',
+                      ),
+                    },
+                  });
+                  i++;
+                }
+              }
+            }
+          }
+        }
+
+        let allTargetsHaveSource =
+          targetsWithSources > 0 &&
+          pkg != null &&
+          pkg.targets != null &&
+          Object.keys(pkg.targets).length === targetsWithSources;
+
+        if (!allTargetsHaveSource && pkg.source != null) {
+          let pkgSources = Array.isArray(pkg.source)
+            ? pkg.source
+            : [pkg.source];
+          let i = 0;
+          for (let pkgSource of pkgSources) {
+            let sources;
+            if (isGlob(pkgSource)) {
+              globs.push(pkgSource);
+              sources = await glob(pkgSource, this.options.inputFS, {
+                onlyFiles: true,
+                cwd: path.dirname(filePath),
+              });
+            } else {
+              sources = [pkgSource];
+            }
+            let keyPath = `/source${Array.isArray(pkg.source) ? `/${i}` : ''}`;
+            for (let relativeSource of sources) {
+              let source = path.join(path.dirname(filePath), relativeSource);
+              await assertFile(
+                this.options.inputFS,
+                entry,
+                relativeSource,
+                filePath,
+                keyPath,
+                this.options,
+              );
+              entries.push({
+                filePath: toProjectPath(this.options.projectRoot, source),
+                packagePath: toProjectPath(this.options.projectRoot, entry),
+                loc: {
+                  filePath: toProjectPath(
+                    this.options.projectRoot,
+                    pkg.filePath,
+                  ),
+                  ...getJSONSourceLocation(pkg.map.pointers[keyPath], 'value'),
+                },
+              });
+              i++;
+            }
+          }
+        }
+
+        // Only return if we found any valid entries
+        if (entries.length && files.length) {
+          return {
+            entries,
+            files,
+            globs,
+          };
+        }
+      }
+
+      throw new ThrowableDiagnostic({
+        diagnostic: {
+          message: md`Could not find entry: ${entry}`,
+        },
+      });
+    } else if (stat.isFile()) {
+      let projectRoot = this.options.projectRoot;
+      let packagePath = isDirectoryInside(
+        this.options.inputFS.cwd(),
+        projectRoot,
+      )
+        ? this.options.inputFS.cwd()
+        : projectRoot;
+
+      return {
+        entries: [
+          {
+            filePath: toProjectPath(this.options.projectRoot, entry),
+            packagePath: toProjectPath(this.options.projectRoot, packagePath),
+          },
+        ],
+        files: [],
+        globs: [],
+      };
+    }
+
+    throw new ThrowableDiagnostic({
+      diagnostic: {
+        message: md`Unknown entry: ${entry}`,
+      },
+    });
+  }
+
+  async readPackage(entry: FilePath): Promise<?{
+    ...PackageJSON,
+    filePath: FilePath,
+    map: {|data: mixed, pointers: {|[string]: Mapping|}|},
+    ...
+  }> {
+    let content, pkg;
+    let pkgFile = path.join(entry, 'package.json');
+    try {
+      content = await this.options.inputFS.readFile(pkgFile, 'utf8');
+    } catch (err) {
+      return null;
+    }
+
+    try {
+      pkg = JSON.parse(content);
+    } catch (err) {
+      // TODO: code frame?
+      throw new ThrowableDiagnostic({
+        diagnostic: {
+          message: md`Error parsing ${path.relative(
+            this.options.inputFS.cwd(),
+            pkgFile,
+          )}: ${err.message}`,
+        },
+      });
+    }
+
+    return {
+      ...pkg,
+      filePath: pkgFile,
+      map: parse(content, undefined, {tabWidth: 1}),
+    };
+  }
+}

package/src/requests/PackageRequest.js

@@ -0,0 +1,105 @@
+// @flow strict-local
+
+import type {ContentKey} from '@atlaspack/graph';
+import type {Async} from '@atlaspack/types';
+import type {SharedReference} from '@atlaspack/workers';
+
+import type {StaticRunOpts} from '../RequestTracker';
+import {requestTypes} from '../RequestTracker';
+import type {Bundle} from '../types';
+import type BundleGraph from '../BundleGraph';
+import type {BundleInfo, RunPackagerRunnerResult} from '../PackagerRunner';
+import type {ConfigAndCachePath} from './AtlaspackConfigRequest';
+
+import nullthrows from 'nullthrows';
+import {runConfigRequest} from './ConfigRequest';
+import {getDevDepRequests, runDevDepRequest} from './DevDepRequest';
+import createAtlaspackConfigRequest from './AtlaspackConfigRequest';
+
+type PackageRequestInput = {|
+  bundleGraph: BundleGraph,
+  bundle: Bundle,
+  bundleGraphReference: SharedReference,
+  optionsRef: SharedReference,
+  useMainThread?: boolean,
+|};
+
+export type PackageRequestResult = BundleInfo;
+
+type RunInput<TResult> = {|
+  input: PackageRequestInput,
+  ...StaticRunOpts<TResult>,
+|};
+
+export type PackageRequest = {|
+  id: ContentKey,
+  +type: typeof requestTypes.package_request,
+  run: (RunInput<BundleInfo>) => Async<BundleInfo>,
+  input: PackageRequestInput,
+|};
+
+export function createPackageRequest(
+  input: PackageRequestInput,
+): PackageRequest {
+  return {
+    type: requestTypes.package_request,
+    id: input.bundleGraph.getHash(input.bundle),
+    run,
+    input,
+  };
+}
+
+async function run({input, api, farm}) {
+  let {bundleGraphReference, optionsRef, bundle, useMainThread} = input;
+  let runPackage = farm.createHandle('runPackage', useMainThread);
+
+  let start = Date.now();
+  let {devDeps, invalidDevDeps} = await getDevDepRequests(api);
+  let {cachePath} = nullthrows(
+    await api.runRequest<null, ConfigAndCachePath>(
+      createAtlaspackConfigRequest(),
+    ),
+  );
+
+  let {devDepRequests, configRequests, bundleInfo, invalidations} =
+    (await runPackage({
+      bundle,
+      bundleGraphReference,
+      optionsRef,
+      configCachePath: cachePath,
+      previousDevDeps: devDeps,
+      invalidDevDeps,
+      previousInvalidations: api.getInvalidations(),
+    }): RunPackagerRunnerResult);
+
+  for (let devDepRequest of devDepRequests) {
+    await runDevDepRequest(api, devDepRequest);
+  }
+
+  for (let configRequest of configRequests) {
+    await runConfigRequest(api, configRequest);
+  }
+
+  for (let invalidation of invalidations) {
+    switch (invalidation.type) {
+      case 'file':
+        api.invalidateOnFileUpdate(invalidation.filePath);
+        api.invalidateOnFileDelete(invalidation.filePath);
+        break;
+      case 'env':
+        api.invalidateOnEnvChange(invalidation.key);
+        break;
+      case 'option':
+        api.invalidateOnOptionChange(invalidation.key);
+        break;
+      default:
+        throw new Error(`Unknown invalidation type: ${invalidation.type}`);
+    }
+  }
+
+  // $FlowFixMe[cannot-write] time is marked read-only, but this is the exception
+  bundleInfo.time = Date.now() - start;
+
+  api.storeResult(bundleInfo);
+  return bundleInfo;
+}