Statically type all request results (#9750)

* Statically type all request results

This PR adds a union type for all request results. It fixes a case which
was mistyped and was caught by this change, in DevDepRequest.

* Remove unused type import

---------

Co-authored-by: pyamada (Remote Dev Environment) <[email protected]>

Author: yamadapc

packages/core/core/src/PackagerRunner.js

@@ -71,7 +71,7 @@ type Opts = {|
   previousInvalidations: Array<RequestInvalidation>,
 |};
 
-export type PackageRequestResult = {|
+export type RunPackagerRunnerResult = {|
   bundleInfo: BundleInfo,
   configRequests: Array<ConfigRequest>,
   devDepRequests: Array<DevDepRequest>,
@@ -142,7 +142,7 @@ export default class PackagerRunner {
     bundleGraph: InternalBundleGraph,
     bundle: InternalBundle,
     invalidDevDeps: Array<DevDepSpecifier>,
-  ): Promise<PackageRequestResult> {
+  ): Promise<RunPackagerRunnerResult> {
     invalidateDevDeps(invalidDevDeps, this.options, this.config);
 
     let {configs, bundleConfigs} = await this.loadConfigs(bundleGraph, bundle);

packages/core/core/src/RequestTracker.js

@@ -59,6 +59,19 @@ import {
   storeRequestTrackerCacheInfo,
   clearRequestTrackerCacheInfo,
 } from './RequestTrackerCacheInfo';
+import type {AssetGraphRequestResult} from './requests/AssetGraphRequest';
+import type {PackageRequestResult} from './requests/PackageRequest';
+import type {ConfigRequestResult} from './requests/ConfigRequest';
+import type {DevDepRequestResult} from './requests/DevDepRequest';
+import type {WriteBundlesRequestResult} from './requests/WriteBundlesRequest';
+import type {WriteBundleRequestResult} from './requests/WriteBundleRequest';
+import type {TargetRequestResult} from './requests/TargetRequest';
+import type {PathRequestResult} from './requests/PathRequest';
+import type {ParcelConfigRequestResult} from './requests/ParcelConfigRequest';
+import type {ParcelBuildRequestResult} from './requests/ParcelBuildRequest';
+import type {EntryRequestResult} from './requests/EntryRequest';
+import type {BundleGraphResult} from './requests/BundleGraphRequest';
+import type {AssetRequestResult} from './types';
 
 export const requestGraphEdgeTypes = {
   subrequest: 2,
@@ -144,13 +157,28 @@ type Request<TInput, TResult> = {|
   run: ({|input: TInput, ...StaticRunOpts<TResult>|}) => Async<TResult>,
 |};
 
+export type RequestResult =
+  | AssetGraphRequestResult
+  | PackageRequestResult
+  | ConfigRequestResult
+  | DevDepRequestResult
+  | WriteBundlesRequestResult
+  | WriteBundleRequestResult
+  | TargetRequestResult
+  | PathRequestResult
+  | ParcelConfigRequestResult
+  | ParcelBuildRequestResult
+  | EntryRequestResult
+  | BundleGraphResult
+  | AssetRequestResult;
+
 type InvalidateReason = number;
 type RequestNode = {|
   id: ContentKey,
   +type: typeof REQUEST,
   +requestType: RequestType,
   invalidateReason: InvalidateReason,
-  result?: mixed,
+  result?: RequestResult,
   resultCacheKey?: ?string,
   hash?: string,
 |};
@@ -184,7 +212,7 @@ type RequestGraphNode =
   | OptionNode
   | ConfigKeyNode;
 
-export type RunAPI<TResult> = {|
+export type RunAPI<TResult: RequestResult> = {|
   invalidateOnFileCreate: InternalFileCreateInvalidation => void,
   invalidateOnFileDelete: ProjectPath => void,
   invalidateOnFileUpdate: ProjectPath => void,
@@ -199,12 +227,12 @@ export type RunAPI<TResult> = {|
   invalidateOnOptionChange: string => void,
   getInvalidations(): Array<RequestInvalidation>,
   storeResult(result: TResult, cacheKey?: string): void,
-  getRequestResult<T>(contentKey: ContentKey): Async<?T>,
-  getPreviousResult<T>(ifMatch?: string): Async<?T>,
+  getRequestResult<T: RequestResult>(contentKey: ContentKey): Async<?T>,
+  getPreviousResult<T: RequestResult>(ifMatch?: string): Async<?T>,
   getSubRequests(): Array<RequestNode>,
   getInvalidSubRequests(): Array<RequestNode>,
   canSkipSubrequest(ContentKey): boolean,
-  runRequest: <TInput, TResult>(
+  runRequest: <TInput, TResult: RequestResult>(
     subRequest: Request<TInput, TResult>,
     opts?: RunRequestOpts,
   ) => Promise<TResult>,
@@ -1096,7 +1124,7 @@ export default class RequestTracker {
   }
 
   // If a cache key is provided, the result will be removed from the node and stored in a separate cache entry
-  storeResult(nodeId: NodeId, result: mixed, cacheKey: ?string) {
+  storeResult(nodeId: NodeId, result: RequestResult, cacheKey: ?string) {
     let node = this.graph.getNode(nodeId);
     if (node && node.type === REQUEST) {
       node.result = result;
@@ -1112,7 +1140,7 @@ export default class RequestTracker {
     );
   }
 
-  async getRequestResult<T>(
+  async getRequestResult<T: RequestResult>(
     contentKey: ContentKey,
     ifMatch?: string,
   ): Promise<?T> {
@@ -1184,7 +1212,7 @@ export default class RequestTracker {
     this.graph.replaceSubrequests(requestNodeId, subrequestContextKeys);
   }
 
-  async runRequest<TInput, TResult>(
+  async runRequest<TInput, TResult: RequestResult>(
     request: Request<TInput, TResult>,
     opts?: ?RunRequestOpts,
   ): Promise<TResult> {
@@ -1289,7 +1317,7 @@ export default class RequestTracker {
     return formattedStats;
   }
 
-  createAPI<TResult>(
+  createAPI<TResult: RequestResult>(
     requestId: NodeId,
     previousInvalidations: Array<RequestInvalidation>,
   ): {|api: RunAPI<TResult>, subRequestContentKeys: Set<ContentKey>|} {
@@ -1324,11 +1352,12 @@ export default class RequestTracker {
       },
       getSubRequests: () => this.graph.getSubRequests(requestId),
       getInvalidSubRequests: () => this.graph.getInvalidSubRequests(requestId),
-      getPreviousResult: <T>(ifMatch?: string): Async<?T> => {
+      getPreviousResult: <T: RequestResult>(ifMatch?: string): Async<?T> => {
         let contentKey = nullthrows(this.graph.getNode(requestId)?.id);
         return this.getRequestResult<T>(contentKey, ifMatch);
       },
-      getRequestResult: <T>(id): Async<?T> => this.getRequestResult<T>(id),
+      getRequestResult: <T: RequestResult>(id): Async<?T> =>
+        this.getRequestResult<T>(id),
       canSkipSubrequest: contentKey => {
         if (
           this.graph.hasContentKey(contentKey) &&
@@ -1340,7 +1369,7 @@ export default class RequestTracker {
 
         return false;
       },
-      runRequest: <TInput, TResult>(
+      runRequest: <TInput, TResult: RequestResult>(
         subRequest: Request<TInput, TResult>,
         opts?: RunRequestOpts,
       ): Promise<TResult> => {

packages/core/core/src/applyRuntimes.js

@@ -13,7 +13,7 @@ import type {
 } from './types';
 import type ParcelConfig from './ParcelConfig';
 import type PluginOptions from './public/PluginOptions';
-import type {RunAPI} from './RequestTracker';
+import type {RequestResult, RunAPI} from './RequestTracker';
 
 import path from 'path';
 import assert from 'assert';
@@ -60,7 +60,7 @@ function nameRuntimeBundle(
   bundle.displayName = name.replace(hashReference, '[hash]');
 }
 
-export default async function applyRuntimes<TResult>({
+export default async function applyRuntimes<TResult: RequestResult>({
   bundleGraph,
   config,
   options,
@@ -324,7 +324,7 @@ export default async function applyRuntimes<TResult>({
   return changedAssets;
 }
 
-function reconcileNewRuntimes<TResult>(
+function reconcileNewRuntimes<TResult: RequestResult>(
   api: RunAPI<TResult>,
   connections: Array<RuntimeConnection>,
   optionsRef: SharedReference,

packages/core/core/src/requests/AssetGraphRequest.js

@@ -13,7 +13,7 @@ import type {
   Target,
 } from '../types';
 import type {StaticRunOpts, RunAPI} from '../RequestTracker';
-import type {EntryResult} from './EntryRequest';
+import type {EntryRequestResult} from './EntryRequest';
 import type {PathRequestInput} from './PathRequest';
 import type {Diagnostic} from '@parcel/diagnostic';
 import logger from '@parcel/logger';
@@ -46,7 +46,7 @@ type AssetGraphRequestInput = {|
   requestedAssetIds?: Set<string>,
 |};
 
-type AssetGraphRequestResult = {|
+export type AssetGraphRequestResult = {|
   assetGraph: AssetGraph,
   /** Assets added/modified since the last successful build. */
   changedAssets: Map<string, Asset>,
@@ -468,9 +468,12 @@ export class AssetGraphBuilder {
       : [];
 
     let request = createEntryRequest(input);
-    let result = await this.api.runRequest<ProjectPath, EntryResult>(request, {
-      force: true,
-    });
+    let result = await this.api.runRequest<ProjectPath, EntryRequestResult>(
+      request,
+      {
+        force: true,
+      },
+    );
     this.assetGraph.resolveEntry(request.input, result.entries, request.id);
 
     if (this.assetGraph.safeToIncrementallyBundle) {

packages/core/core/src/requests/AssetRequest.js

@@ -6,7 +6,6 @@ import type {StaticRunOpts} from '../RequestTracker';
 import type {
   AssetRequestInput,
   AssetRequestResult,
-  DevDepRequest,
   TransformationRequest,
 } from '../types';
 import type {ConfigAndCachePath} from './ParcelConfigRequest';
@@ -21,6 +20,7 @@ import {runConfigRequest} from './ConfigRequest';
 import {fromProjectPath, fromProjectPathRelative} from '../projectPath';
 import {report} from '../ReporterRunner';
 import {requestTypes} from '../RequestTracker';
+import type {DevDepRequestResult} from './DevDepRequest';
 
 type RunInput<TResult> = {|
   input: AssetRequestInput,
@@ -78,14 +78,14 @@ async function run({input, api, farm, invalidateReason, options}) {
     await api.runRequest<null, ConfigAndCachePath>(createParcelConfigRequest()),
   );
 
-  let previousDevDepRequests = new Map(
+  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<DevDepRequest>(req.id)),
+          nullthrows(await api.getRequestResult<DevDepRequestResult>(req.id)),
         ]),
     ),
   );
@@ -96,15 +96,15 @@ async function run({input, api, farm, invalidateReason, options}) {
     devDeps: new Map(
       [...previousDevDepRequests.entries()]
         .filter(([id]) => api.canSkipSubrequest(id))
-        .map(([, req]) => [
+        .map(([, req]: [string, DevDepRequestResult]) => [
           `${req.specifier}:${fromProjectPathRelative(req.resolveFrom)}`,
           req.hash,
         ]),
     ),
     invalidDevDeps: await Promise.all(
       [...previousDevDepRequests.entries()]
         .filter(([id]) => !api.canSkipSubrequest(id))
-        .flatMap(([, req]) => {
+        .flatMap(([, req]: [string, DevDepRequestResult]) => {
           return [
             {
               specifier: req.specifier,

packages/core/core/src/requests/BundleGraphRequest.js

@@ -71,6 +71,7 @@ type RunInput = {|
   ...StaticRunOpts<BundleGraphResult>,
 |};
 
+// TODO: Rename to BundleGraphRequestResult
 export type BundleGraphResult = {|
   bundleGraph: InternalBundleGraph,
   changedAssets: Map<string, Asset>,

packages/core/core/src/requests/ConfigRequest.js

@@ -15,7 +15,7 @@ import type {
   InternalFileCreateInvalidation,
 } from '../types';
 import type {LoadedPlugin} from '../ParcelConfig';
-import type {RunAPI} from '../RequestTracker';
+import type {RequestResult, RunAPI} from '../RequestTracker';
 import type {ProjectPath} from '../projectPath';
 import {napiRunConfigRequest} from '@parcel/rust';
 
@@ -76,6 +76,8 @@ export type ConfigRequest = {
   ...
 };
 
+export type ConfigRequestResult = void;
+
 export async function loadPluginConfig<T: PluginWithLoadConfig>(
   loadedPlugin: LoadedPlugin<T>,
   config: Config,
@@ -143,7 +145,7 @@ export async function getConfigKeyContentHash(
   return contentHash;
 }
 
-export async function runConfigRequest<TResult>(
+export async function runConfigRequest<TResult: RequestResult>(
   api: RunAPI<TResult>,
   configRequest: ConfigRequest,
 ) {

packages/core/core/src/requests/DevDepRequest.js

@@ -1,12 +1,16 @@
 // @flow
-import type {DependencySpecifier, SemverRange} from '@parcel/types';
+import type {
+  DependencySpecifier,
+  SemverRange,
+  Invalidations,
+} from '@parcel/types';
 import type ParcelConfig from '../ParcelConfig';
 import type {
   DevDepRequest,
   ParcelOptions,
   InternalDevDepOptions,
 } from '../types';
-import type {RunAPI} from '../RequestTracker';
+import type {RequestResult, RunAPI} from '../RequestTracker';
 import type {ProjectPath} from '../projectPath';
 
 import nullthrows from 'nullthrows';
@@ -24,7 +28,7 @@ import {requestTypes} from '../RequestTracker';
 // 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 = new WeakMap();
+const devDepRequestCache: WeakMap<Invalidations, DevDepRequest> = new WeakMap();
 
 export async function createDevDependency(
   opts: InternalDevDepOptions,
@@ -107,17 +111,17 @@ type DevDepRequests = {|
   invalidDevDeps: Array<DevDepSpecifier>,
 |};
 
-export async function getDevDepRequests<TResult>(
+export async function getDevDepRequests<TResult: RequestResult>(
   api: RunAPI<TResult>,
 ): Promise<DevDepRequests> {
-  let previousDevDepRequests = new Map(
+  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<DevDepRequest>(req.id)),
+          nullthrows(await api.getRequestResult<DevDepRequestResult>(req.id)),
         ]),
     ),
   );
@@ -126,15 +130,15 @@ export async function getDevDepRequests<TResult>(
     devDeps: new Map(
       [...previousDevDepRequests.entries()]
         .filter(([id]) => api.canSkipSubrequest(id))
-        .map(([, req]) => [
+        .map(([, req]: [string, DevDepRequestResult]) => [
           `${req.specifier}:${fromProjectPathRelative(req.resolveFrom)}`,
           req.hash,
         ]),
     ),
     invalidDevDeps: await Promise.all(
       [...previousDevDepRequests.entries()]
         .filter(([id]) => !api.canSkipSubrequest(id))
-        .flatMap(([, req]) => {
+        .flatMap(([, req]: [string, DevDepRequestResult]) => {
           return [
             {
               specifier: req.specifier,
@@ -172,7 +176,7 @@ export function invalidateDevDeps(
   }
 }
 
-type DevDepRequestResult = {|
+export type DevDepRequestResult = {|
   specifier: DependencySpecifier,
   resolveFrom: ProjectPath,
   hash: string,
@@ -183,7 +187,7 @@ type DevDepRequestResult = {|
   |}>,
 |};
 
-export async function runDevDepRequest<TResult>(
+export async function runDevDepRequest<TResult: RequestResult>(
   api: RunAPI<TResult>,
   devDepRequest: DevDepRequest,
 ) {