diff --git a/libs/feature-run/src/lib/target/target.component.ts b/libs/feature-run/src/lib/target/target.component.ts
index 5a759b38e6..0bcf0c082c 100644
--- a/libs/feature-run/src/lib/target/target.component.ts
+++ b/libs/feature-run/src/lib/target/target.component.ts
@@ -1,11 +1,31 @@
 import { Architect, Project } from '@angular-console/schema';
-import { CommandOutputComponent, FlagsComponent, TaskRunnerComponent } from '@angular-console/ui';
-import { CommandRunner, IncrementalCommandOutput, Serializer } from '@angular-console/utils';
-import { ChangeDetectionStrategy, Component, OnInit, ViewChild } from '@angular/core';
+import {
+  CommandOutputComponent,
+  FlagsComponent,
+  TaskRunnerComponent
+} from '@angular-console/ui';
+import {
+  CommandRunner,
+  IncrementalCommandOutput,
+  Serializer
+} from '@angular-console/utils';
+import {
+  ChangeDetectionStrategy,
+  Component,
+  OnInit,
+  ViewChild
+} from '@angular/core';
 import { ActivatedRoute } from '@angular/router';
 import { ContextualActionBarService } from '@nrwl/angular-console-enterprise-frontend';
 import { BehaviorSubject, Observable, of, Subject } from 'rxjs';
-import { map, publishReplay, refCount, switchMap, tap, withLatestFrom } from 'rxjs/operators';
+import {
+  map,
+  publishReplay,
+  refCount,
+  switchMap,
+  tap,
+  withLatestFrom
+} from 'rxjs/operators';
 
 import { ProjectsGQL, RunNgGQL } from '../generated/graphql';
 
@@ -158,6 +178,10 @@ export class TargetComponent implements OnInit {
   }
 
   initSourceMapAndStatsJson(architect: Architect) {
+    if (architect.name !== 'build') {
+      return;
+    }
+
     const defaultValues = architect.configurations[0]
       ? architect.configurations[0].defaultValues
       : [];
diff --git a/libs/schema/src/lib/generated/graphql-types.ts b/libs/schema/src/lib/generated/graphql-types.ts
index 9d8203e01d..1956bac6d6 100644
--- a/libs/schema/src/lib/generated/graphql-types.ts
+++ b/libs/schema/src/lib/generated/graphql-types.ts
@@ -462,24 +462,24 @@ export interface OpenDocMutationArgs {
 
 import { GraphQLResolveInfo } from 'graphql';
 
-export type Resolver<Result, Parent = {}, Context = {}, Args = {}> = (
+export type Resolver<Result, Parent = {}, TContext = {}, Args = {}> = (
   parent: Parent,
   args: Args,
-  context: Context,
+  context: TContext,
   info: GraphQLResolveInfo
 ) => Promise<Result> | Result;
 
-export interface ISubscriptionResolverObject<Result, Parent, Context, Args> {
+export interface ISubscriptionResolverObject<Result, Parent, TContext, Args> {
   subscribe<R = Result, P = Parent>(
     parent: P,
     args: Args,
-    context: Context,
+    context: TContext,
     info: GraphQLResolveInfo
   ): AsyncIterator<R | Result> | Promise<AsyncIterator<R | Result>>;
   resolve?<R = Result, P = Parent>(
     parent: P,
     args: Args,
-    context: Context,
+    context: TContext,
     info: GraphQLResolveInfo
   ): R | Result | Promise<R | Result>;
 }
@@ -487,17 +487,17 @@ export interface ISubscriptionResolverObject<Result, Parent, Context, Args> {
 export type SubscriptionResolver<
   Result,
   Parent = {},
-  Context = {},
+  TContext = {},
   Args = {}
 > =
   | ((
       ...args: any[]
-    ) => ISubscriptionResolverObject<Result, Parent, Context, Args>)
-  | ISubscriptionResolverObject<Result, Parent, Context, Args>;
+    ) => ISubscriptionResolverObject<Result, Parent, TContext, Args>)
+  | ISubscriptionResolverObject<Result, Parent, TContext, Args>;
 
-export type TypeResolveFn<Types, Parent = {}, Context = {}> = (
+export type TypeResolveFn<Types, Parent = {}, TContext = {}> = (
   parent: Parent,
-  context: Context,
+  context: TContext,
   info: GraphQLResolveInfo
 ) => Maybe<Types>;
 
@@ -512,64 +512,63 @@ export type DirectiveResolverFn<TResult, TArgs = {}, TContext = {}> = (
 ) => TResult | Promise<TResult>;
 
 export namespace QueryResolvers {
-  export interface Resolvers<Context = any, TypeParent = {}> {
-    settings?: SettingsResolver<any, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = {}> {
+    settings?: SettingsResolver<any, TypeParent, TContext>;
 
     schematicCollections?: SchematicCollectionsResolver<
       any[],
       TypeParent,
-      Context
+      TContext
     >;
 
-    workspace?: WorkspaceResolver<any, TypeParent, Context>;
+    workspace?: WorkspaceResolver<any, TypeParent, TContext>;
 
-    editors?: EditorsResolver<any[], TypeParent, Context>;
+    editors?: EditorsResolver<any[], TypeParent, TContext>;
 
     availableExtensions?: AvailableExtensionsResolver<
       any[],
       TypeParent,
-      Context
+      TContext
     >;
 
     isNodejsInstalled?: IsNodejsInstalledResolver<
       Maybe<any>,
       TypeParent,
-      Context
+      TContext
     >;
 
-    commands?: CommandsResolver<any[], TypeParent, Context>;
+    commands?: CommandsResolver<any[], TypeParent, TContext>;
   }
 
-  export type SettingsResolver<R = any, Parent = {}, Context = any> = Resolver<
+  export type SettingsResolver<R = any, Parent = {}, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type SchematicCollectionsResolver<
     R = any[],
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type WorkspaceResolver<R = any, Parent = {}, Context = any> = Resolver<
-    R,
-    Parent,
-    Context,
-    WorkspaceArgs
-  >;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type WorkspaceResolver<
+    R = any,
+    Parent = {},
+    TContext = any
+  > = Resolver<R, Parent, TContext, WorkspaceArgs>;
   export interface WorkspaceArgs {
     path: string;
   }
 
-  export type EditorsResolver<R = any[], Parent = {}, Context = any> = Resolver<
-    R,
-    Parent,
-    Context
-  >;
+  export type EditorsResolver<
+    R = any[],
+    Parent = {},
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type AvailableExtensionsResolver<
     R = any[],
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, AvailableExtensionsArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, AvailableExtensionsArgs>;
   export interface AvailableExtensionsArgs {
     name?: Maybe<string>;
   }
@@ -577,13 +576,13 @@ export namespace QueryResolvers {
   export type IsNodejsInstalledResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type CommandsResolver<
     R = any[],
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, CommandsArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, CommandsArgs>;
   export interface CommandsArgs {
     id?: Maybe<string>;
 
@@ -592,306 +591,306 @@ export namespace QueryResolvers {
 }
 
 export namespace SettingsResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    canCollectData?: CanCollectDataResolver<boolean, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    canCollectData?: CanCollectDataResolver<boolean, TypeParent, TContext>;
 
-    isConnectUser?: IsConnectUserResolver<Maybe<boolean>, TypeParent, Context>;
+    isConnectUser?: IsConnectUserResolver<Maybe<boolean>, TypeParent, TContext>;
 
     disableAnimations?: DisableAnimationsResolver<
       Maybe<boolean>,
       TypeParent,
-      Context
+      TContext
     >;
 
     showSupportPlugin?: ShowSupportPluginResolver<
       Maybe<boolean>,
       TypeParent,
-      Context
+      TContext
     >;
 
     installNodeManually?: InstallNodeManuallyResolver<
       Maybe<boolean>,
       TypeParent,
-      Context
+      TContext
     >;
 
     enableDetailedStatus?: EnableDetailedStatusResolver<
       Maybe<boolean>,
       TypeParent,
-      Context
+      TContext
     >;
 
-    channel?: ChannelResolver<Maybe<string>, TypeParent, Context>;
+    channel?: ChannelResolver<Maybe<string>, TypeParent, TContext>;
 
     workspaceSchematicsDirectory?: WorkspaceSchematicsDirectoryResolver<
       Maybe<string>,
       TypeParent,
-      Context
+      TContext
     >;
 
     workspaceSchematicsNpmScript?: WorkspaceSchematicsNpmScriptResolver<
       Maybe<string>,
       TypeParent,
-      Context
+      TContext
     >;
 
-    recent?: RecentResolver<any[], TypeParent, Context>;
+    recent?: RecentResolver<any[], TypeParent, TContext>;
 
-    isWsl?: IsWslResolver<Maybe<boolean>, TypeParent, Context>;
+    isWsl?: IsWslResolver<Maybe<boolean>, TypeParent, TContext>;
 
-    isWindows?: IsWindowsResolver<Maybe<boolean>, TypeParent, Context>;
+    isWindows?: IsWindowsResolver<Maybe<boolean>, TypeParent, TContext>;
 
-    useNvm?: UseNvmResolver<Maybe<boolean>, TypeParent, Context>;
+    useNvm?: UseNvmResolver<Maybe<boolean>, TypeParent, TContext>;
   }
 
   export type CanCollectDataResolver<
     R = boolean,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type IsConnectUserResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type DisableAnimationsResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type ShowSupportPluginResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type InstallNodeManuallyResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type EnableDetailedStatusResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type ChannelResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type WorkspaceSchematicsDirectoryResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type WorkspaceSchematicsNpmScriptResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type RecentResolver<R = any[], Parent = any, Context = any> = Resolver<
-    R,
-    Parent,
-    Context
-  >;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type RecentResolver<
+    R = any[],
+    Parent = any,
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type IsWslResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type IsWindowsResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type UseNvmResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace WorkspaceDefinitionResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    path?: PathResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    path?: PathResolver<string, TypeParent, TContext>;
 
-    name?: NameResolver<string, TypeParent, Context>;
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    favorite?: FavoriteResolver<Maybe<boolean>, TypeParent, Context>;
+    favorite?: FavoriteResolver<Maybe<boolean>, TypeParent, TContext>;
 
     pinnedProjectNames?: PinnedProjectNamesResolver<
       string[],
       TypeParent,
-      Context
+      TContext
     >;
   }
 
-  export type PathResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type PathResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type FavoriteResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type PinnedProjectNamesResolver<
     R = string[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace SchematicCollectionForNgNewResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    description?: DescriptionResolver<string, TypeParent, Context>;
+    description?: DescriptionResolver<string, TypeParent, TContext>;
 
-    schema?: SchemaResolver<any[], TypeParent, Context>;
+    schema?: SchemaResolver<any[], TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type DescriptionResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type SchemaResolver<R = any[], Parent = any, Context = any> = Resolver<
-    R,
-    Parent,
-    Context
-  >;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type SchemaResolver<
+    R = any[],
+    Parent = any,
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace SchemaResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    type?: TypeResolver<string, TypeParent, Context>;
+    type?: TypeResolver<string, TypeParent, TContext>;
 
-    description?: DescriptionResolver<string, TypeParent, Context>;
+    description?: DescriptionResolver<string, TypeParent, TContext>;
 
-    defaultValue?: DefaultValueResolver<Maybe<string>, TypeParent, Context>;
+    defaultValue?: DefaultValueResolver<Maybe<string>, TypeParent, TContext>;
 
-    important?: ImportantResolver<Maybe<boolean>, TypeParent, Context>;
+    important?: ImportantResolver<Maybe<boolean>, TypeParent, TContext>;
 
-    completion?: CompletionResolver<Maybe<string>, TypeParent, Context>;
+    completion?: CompletionResolver<Maybe<string>, TypeParent, TContext>;
 
-    required?: RequiredResolver<boolean, TypeParent, Context>;
+    required?: RequiredResolver<boolean, TypeParent, TContext>;
 
-    positional?: PositionalResolver<boolean, TypeParent, Context>;
+    positional?: PositionalResolver<boolean, TypeParent, TContext>;
 
-    enum?: EnumResolver<Maybe<string[]>, TypeParent, Context>;
+    enum?: EnumResolver<Maybe<string[]>, TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
-  export type TypeResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type TypeResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type DescriptionResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type DefaultValueResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type ImportantResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type CompletionResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type RequiredResolver<
     R = boolean,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type PositionalResolver<
     R = boolean,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type EnumResolver<
     R = Maybe<string[]>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace WorkspaceResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    path?: PathResolver<string, TypeParent, Context>;
+    path?: PathResolver<string, TypeParent, TContext>;
 
-    dependencies?: DependenciesResolver<any[], TypeParent, Context>;
+    dependencies?: DependenciesResolver<any[], TypeParent, TContext>;
 
-    extensions?: ExtensionsResolver<any[], TypeParent, Context>;
+    extensions?: ExtensionsResolver<any[], TypeParent, TContext>;
 
     schematicCollections?: SchematicCollectionsResolver<
       any[],
       TypeParent,
-      Context
+      TContext
     >;
 
-    npmScripts?: NpmScriptsResolver<any[], TypeParent, Context>;
+    npmScripts?: NpmScriptsResolver<any[], TypeParent, TContext>;
 
-    projects?: ProjectsResolver<any[], TypeParent, Context>;
+    projects?: ProjectsResolver<any[], TypeParent, TContext>;
 
-    docs?: DocsResolver<any, TypeParent, Context>;
+    docs?: DocsResolver<any, TypeParent, TContext>;
 
-    completions?: CompletionsResolver<Maybe<any>, TypeParent, Context>;
+    completions?: CompletionsResolver<Maybe<any>, TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
-  export type PathResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type PathResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type DependenciesResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type ExtensionsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type SchematicCollectionsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context, SchematicCollectionsArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, SchematicCollectionsArgs>;
   export interface SchematicCollectionsArgs {
     name?: Maybe<string>;
   }
@@ -899,8 +898,8 @@ export namespace WorkspaceResolvers {
   export type NpmScriptsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context, NpmScriptsArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, NpmScriptsArgs>;
   export interface NpmScriptsArgs {
     name?: Maybe<string>;
   }
@@ -908,208 +907,208 @@ export namespace WorkspaceResolvers {
   export type ProjectsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context, ProjectsArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, ProjectsArgs>;
   export interface ProjectsArgs {
     name?: Maybe<string>;
   }
 
-  export type DocsResolver<R = any, Parent = any, Context = any> = Resolver<
+  export type DocsResolver<R = any, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type CompletionsResolver<
     R = Maybe<any>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace DependenciesResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    version?: VersionResolver<string, TypeParent, Context>;
+    version?: VersionResolver<string, TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type VersionResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace ExtensionResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    description?: DescriptionResolver<string, TypeParent, Context>;
+    description?: DescriptionResolver<string, TypeParent, TContext>;
 
     detailedDescription?: DetailedDescriptionResolver<
       Maybe<string>,
       TypeParent,
-      Context
+      TContext
     >;
 
-    installed?: InstalledResolver<Maybe<boolean>, TypeParent, Context>;
+    installed?: InstalledResolver<Maybe<boolean>, TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type DescriptionResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type DetailedDescriptionResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type InstalledResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace SchematicCollectionResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    schematics?: SchematicsResolver<any[], TypeParent, Context>;
+    schematics?: SchematicsResolver<any[], TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type SchematicsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context, SchematicsArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, SchematicsArgs>;
   export interface SchematicsArgs {
     name?: Maybe<string>;
   }
 }
 
 export namespace SchematicResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    collection?: CollectionResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    collection?: CollectionResolver<string, TypeParent, TContext>;
 
-    name?: NameResolver<string, TypeParent, Context>;
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    description?: DescriptionResolver<string, TypeParent, Context>;
+    description?: DescriptionResolver<string, TypeParent, TContext>;
 
-    npmClient?: NpmClientResolver<Maybe<string>, TypeParent, Context>;
+    npmClient?: NpmClientResolver<Maybe<string>, TypeParent, TContext>;
 
-    npmScript?: NpmScriptResolver<Maybe<string>, TypeParent, Context>;
+    npmScript?: NpmScriptResolver<Maybe<string>, TypeParent, TContext>;
 
-    schema?: SchemaResolver<any[], TypeParent, Context>;
+    schema?: SchemaResolver<any[], TypeParent, TContext>;
   }
 
   export type CollectionResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type DescriptionResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type NpmClientResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type NpmScriptResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type SchemaResolver<R = any[], Parent = any, Context = any> = Resolver<
-    R,
-    Parent,
-    Context
-  >;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type SchemaResolver<
+    R = any[],
+    Parent = any,
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace NpmScriptResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    npmClient?: NpmClientResolver<Maybe<string>, TypeParent, Context>;
+    npmClient?: NpmClientResolver<Maybe<string>, TypeParent, TContext>;
 
-    schema?: SchemaResolver<any[], TypeParent, Context>;
+    schema?: SchemaResolver<any[], TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type NpmClientResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type SchemaResolver<R = any[], Parent = any, Context = any> = Resolver<
-    R,
-    Parent,
-    Context
-  >;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type SchemaResolver<
+    R = any[],
+    Parent = any,
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace ProjectResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    root?: RootResolver<string, TypeParent, Context>;
+    root?: RootResolver<string, TypeParent, TContext>;
 
-    projectType?: ProjectTypeResolver<string, TypeParent, Context>;
+    projectType?: ProjectTypeResolver<string, TypeParent, TContext>;
 
-    architect?: ArchitectResolver<any[], TypeParent, Context>;
+    architect?: ArchitectResolver<any[], TypeParent, TContext>;
 
-    recentActions?: RecentActionsResolver<any[], TypeParent, Context>;
+    recentActions?: RecentActionsResolver<any[], TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
-  export type RootResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type RootResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type ProjectTypeResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type ArchitectResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context, ArchitectArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, ArchitectArgs>;
   export interface ArchitectArgs {
     name?: Maybe<string>;
   }
@@ -1117,150 +1116,150 @@ export namespace ProjectResolvers {
   export type RecentActionsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace ArchitectResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    project?: ProjectResolver<string, TypeParent, Context>;
+    project?: ProjectResolver<string, TypeParent, TContext>;
 
-    builder?: BuilderResolver<string, TypeParent, Context>;
+    builder?: BuilderResolver<string, TypeParent, TContext>;
 
-    description?: DescriptionResolver<string, TypeParent, Context>;
+    description?: DescriptionResolver<string, TypeParent, TContext>;
 
-    options?: OptionsResolver<any, TypeParent, Context>;
+    options?: OptionsResolver<any, TypeParent, TContext>;
 
-    configurations?: ConfigurationsResolver<any[], TypeParent, Context>;
+    configurations?: ConfigurationsResolver<any[], TypeParent, TContext>;
 
-    schema?: SchemaResolver<any[], TypeParent, Context>;
+    schema?: SchemaResolver<any[], TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type ProjectResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type BuilderResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type DescriptionResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type OptionsResolver<R = any, Parent = any, Context = any> = Resolver<
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type OptionsResolver<R = any, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type ConfigurationsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type SchemaResolver<R = any[], Parent = any, Context = any> = Resolver<
-    R,
-    Parent,
-    Context
-  >;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type SchemaResolver<
+    R = any[],
+    Parent = any,
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace OptionsResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    defaultValues?: DefaultValuesResolver<any[], TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    defaultValues?: DefaultValuesResolver<any[], TypeParent, TContext>;
   }
 
   export type DefaultValuesResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace FieldValueResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    defaultValue?: DefaultValueResolver<Maybe<string>, TypeParent, Context>;
+    defaultValue?: DefaultValueResolver<Maybe<string>, TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type DefaultValueResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace ArchitectConfigurationsResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    defaultValues?: DefaultValuesResolver<any[], TypeParent, Context>;
+    defaultValues?: DefaultValuesResolver<any[], TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type DefaultValuesResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace RecentActionResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    actionName?: ActionNameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    actionName?: ActionNameResolver<string, TypeParent, TContext>;
 
-    schematicName?: SchematicNameResolver<Maybe<string>, TypeParent, Context>;
+    schematicName?: SchematicNameResolver<Maybe<string>, TypeParent, TContext>;
   }
 
   export type ActionNameResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type SchematicNameResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace DocsResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    workspaceDocs?: WorkspaceDocsResolver<any[], TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    workspaceDocs?: WorkspaceDocsResolver<any[], TypeParent, TContext>;
 
-    schematicDocs?: SchematicDocsResolver<any[], TypeParent, Context>;
+    schematicDocs?: SchematicDocsResolver<any[], TypeParent, TContext>;
   }
 
   export type WorkspaceDocsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type SchematicDocsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context, SchematicDocsArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, SchematicDocsArgs>;
   export interface SchematicDocsArgs {
     collectionName: string;
 
@@ -1271,46 +1270,46 @@ export namespace DocsResolvers {
 }
 
 export namespace DocResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    prop?: PropResolver<Maybe<string>, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    prop?: PropResolver<Maybe<string>, TypeParent, TContext>;
 
-    description?: DescriptionResolver<Maybe<string>, TypeParent, Context>;
+    description?: DescriptionResolver<Maybe<string>, TypeParent, TContext>;
 
-    id?: IdResolver<string, TypeParent, Context>;
+    id?: IdResolver<string, TypeParent, TContext>;
   }
 
   export type PropResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type DescriptionResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type IdResolver<R = string, Parent = any, Context = any> = Resolver<
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type IdResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
 }
 
 export namespace CompletionsTypesResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    files?: FilesResolver<any[], TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    files?: FilesResolver<any[], TypeParent, TContext>;
 
-    projects?: ProjectsResolver<any[], TypeParent, Context>;
+    projects?: ProjectsResolver<any[], TypeParent, TContext>;
 
-    localModules?: LocalModulesResolver<any[], TypeParent, Context>;
+    localModules?: LocalModulesResolver<any[], TypeParent, TContext>;
 
-    absoluteModules?: AbsoluteModulesResolver<any[], TypeParent, Context>;
+    absoluteModules?: AbsoluteModulesResolver<any[], TypeParent, TContext>;
   }
 
-  export type FilesResolver<R = any[], Parent = any, Context = any> = Resolver<
+  export type FilesResolver<R = any[], Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context,
+    TContext,
     FilesArgs
   >;
   export interface FilesArgs {
@@ -1320,8 +1319,8 @@ export namespace CompletionsTypesResolvers {
   export type ProjectsResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context, ProjectsArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, ProjectsArgs>;
   export interface ProjectsArgs {
     input: string;
   }
@@ -1329,8 +1328,8 @@ export namespace CompletionsTypesResolvers {
   export type LocalModulesResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context, LocalModulesArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, LocalModulesArgs>;
   export interface LocalModulesArgs {
     input: string;
   }
@@ -1338,171 +1337,175 @@ export namespace CompletionsTypesResolvers {
   export type AbsoluteModulesResolver<
     R = any[],
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context, AbsoluteModulesArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, AbsoluteModulesArgs>;
   export interface AbsoluteModulesArgs {
     input: string;
   }
 }
 
 export namespace CompletionResultTypeResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    value?: ValueResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    value?: ValueResolver<string, TypeParent, TContext>;
 
-    display?: DisplayResolver<Maybe<string>, TypeParent, Context>;
+    display?: DisplayResolver<Maybe<string>, TypeParent, TContext>;
   }
 
-  export type ValueResolver<R = string, Parent = any, Context = any> = Resolver<
-    R,
-    Parent,
-    Context
-  >;
+  export type ValueResolver<
+    R = string,
+    Parent = any,
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type DisplayResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace EditorSupportResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    name?: NameResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    name?: NameResolver<string, TypeParent, TContext>;
 
-    icon?: IconResolver<string, TypeParent, Context>;
+    icon?: IconResolver<string, TypeParent, TContext>;
   }
 
-  export type NameResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type NameResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
-  export type IconResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type IconResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
 }
 
 export namespace IsNodeInstalledResultResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    result?: ResultResolver<boolean, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    result?: ResultResolver<boolean, TypeParent, TContext>;
   }
 
   export type ResultResolver<
     R = boolean,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace CommandResponseResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    id?: IdResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    id?: IdResolver<string, TypeParent, TContext>;
 
-    workspace?: WorkspaceResolver<Maybe<string>, TypeParent, Context>;
+    workspace?: WorkspaceResolver<Maybe<string>, TypeParent, TContext>;
 
-    command?: CommandResolver<string, TypeParent, Context>;
+    command?: CommandResolver<string, TypeParent, TContext>;
 
-    status?: StatusResolver<string, TypeParent, Context>;
+    status?: StatusResolver<string, TypeParent, TContext>;
 
-    detailedStatus?: DetailedStatusResolver<Maybe<string>, TypeParent, Context>;
+    detailedStatus?: DetailedStatusResolver<
+      Maybe<string>,
+      TypeParent,
+      TContext
+    >;
 
-    outChunk?: OutChunkResolver<string, TypeParent, Context>;
+    outChunk?: OutChunkResolver<string, TypeParent, TContext>;
 
-    out?: OutResolver<string, TypeParent, Context>;
+    out?: OutResolver<string, TypeParent, TContext>;
   }
 
-  export type IdResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type IdResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
   export type WorkspaceResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type CommandResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type StatusResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type DetailedStatusResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type OutChunkResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
-  export type OutResolver<R = string, Parent = any, Context = any> = Resolver<
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
+  export type OutResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
 }
 
 export namespace MutationResolvers {
-  export interface Resolvers<Context = any, TypeParent = {}> {
-    ngAdd?: NgAddResolver<Maybe<any>, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = {}> {
+    ngAdd?: NgAddResolver<Maybe<any>, TypeParent, TContext>;
 
-    ngNew?: NgNewResolver<Maybe<any>, TypeParent, Context>;
+    ngNew?: NgNewResolver<Maybe<any>, TypeParent, TContext>;
 
-    generate?: GenerateResolver<Maybe<any>, TypeParent, Context>;
+    generate?: GenerateResolver<Maybe<any>, TypeParent, TContext>;
 
     generateUsingNpm?: GenerateUsingNpmResolver<
       Maybe<any>,
       TypeParent,
-      Context
+      TContext
     >;
 
-    runNg?: RunNgResolver<Maybe<any>, TypeParent, Context>;
+    runNg?: RunNgResolver<Maybe<any>, TypeParent, TContext>;
 
-    runNpm?: RunNpmResolver<Maybe<any>, TypeParent, Context>;
+    runNpm?: RunNpmResolver<Maybe<any>, TypeParent, TContext>;
 
-    stopCommand?: StopCommandResolver<Maybe<any>, TypeParent, Context>;
+    stopCommand?: StopCommandResolver<Maybe<any>, TypeParent, TContext>;
 
-    removeCommand?: RemoveCommandResolver<Maybe<any>, TypeParent, Context>;
+    removeCommand?: RemoveCommandResolver<Maybe<any>, TypeParent, TContext>;
 
     removeAllCommands?: RemoveAllCommandsResolver<
       Maybe<any>,
       TypeParent,
-      Context
+      TContext
     >;
 
-    restartCommand?: RestartCommandResolver<Maybe<any>, TypeParent, Context>;
+    restartCommand?: RestartCommandResolver<Maybe<any>, TypeParent, TContext>;
 
-    openInEditor?: OpenInEditorResolver<Maybe<any>, TypeParent, Context>;
+    openInEditor?: OpenInEditorResolver<Maybe<any>, TypeParent, TContext>;
 
-    updateSettings?: UpdateSettingsResolver<any, TypeParent, Context>;
+    updateSettings?: UpdateSettingsResolver<any, TypeParent, TContext>;
 
-    saveRecentAction?: SaveRecentActionResolver<any[], TypeParent, Context>;
+    saveRecentAction?: SaveRecentActionResolver<any[], TypeParent, TContext>;
 
-    openInBrowser?: OpenInBrowserResolver<Maybe<any>, TypeParent, Context>;
+    openInBrowser?: OpenInBrowserResolver<Maybe<any>, TypeParent, TContext>;
 
-    selectDirectory?: SelectDirectoryResolver<Maybe<any>, TypeParent, Context>;
+    selectDirectory?: SelectDirectoryResolver<Maybe<any>, TypeParent, TContext>;
 
     showItemInFolder?: ShowItemInFolderResolver<
       Maybe<any>,
       TypeParent,
-      Context
+      TContext
     >;
 
-    openDoc?: OpenDocResolver<Maybe<any>, TypeParent, Context>;
+    openDoc?: OpenDocResolver<Maybe<any>, TypeParent, TContext>;
   }
 
   export type NgAddResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, NgAddArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, NgAddArgs>;
   export interface NgAddArgs {
     path: string;
 
@@ -1512,8 +1515,8 @@ export namespace MutationResolvers {
   export type NgNewResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, NgNewArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, NgNewArgs>;
   export interface NgNewArgs {
     path: string;
 
@@ -1527,8 +1530,8 @@ export namespace MutationResolvers {
   export type GenerateResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, GenerateArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, GenerateArgs>;
   export interface GenerateArgs {
     path: string;
 
@@ -1540,8 +1543,8 @@ export namespace MutationResolvers {
   export type GenerateUsingNpmResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, GenerateUsingNpmArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, GenerateUsingNpmArgs>;
   export interface GenerateUsingNpmArgs {
     path: string;
 
@@ -1555,8 +1558,8 @@ export namespace MutationResolvers {
   export type RunNgResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, RunNgArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, RunNgArgs>;
   export interface RunNgArgs {
     path: string;
 
@@ -1566,8 +1569,8 @@ export namespace MutationResolvers {
   export type RunNpmResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, RunNpmArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, RunNpmArgs>;
   export interface RunNpmArgs {
     path: string;
 
@@ -1579,8 +1582,8 @@ export namespace MutationResolvers {
   export type StopCommandResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, StopCommandArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, StopCommandArgs>;
   export interface StopCommandArgs {
     id: string;
   }
@@ -1588,8 +1591,8 @@ export namespace MutationResolvers {
   export type RemoveCommandResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, RemoveCommandArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, RemoveCommandArgs>;
   export interface RemoveCommandArgs {
     id: string;
   }
@@ -1597,13 +1600,13 @@ export namespace MutationResolvers {
   export type RemoveAllCommandsResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type RestartCommandResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, RestartCommandArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, RestartCommandArgs>;
   export interface RestartCommandArgs {
     id: string;
   }
@@ -1611,8 +1614,8 @@ export namespace MutationResolvers {
   export type OpenInEditorResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, OpenInEditorArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, OpenInEditorArgs>;
   export interface OpenInEditorArgs {
     editor: string;
 
@@ -1622,8 +1625,8 @@ export namespace MutationResolvers {
   export type UpdateSettingsResolver<
     R = any,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, UpdateSettingsArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, UpdateSettingsArgs>;
   export interface UpdateSettingsArgs {
     data: string;
   }
@@ -1631,8 +1634,8 @@ export namespace MutationResolvers {
   export type SaveRecentActionResolver<
     R = any[],
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, SaveRecentActionArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, SaveRecentActionArgs>;
   export interface SaveRecentActionArgs {
     workspacePath: string;
 
@@ -1646,8 +1649,8 @@ export namespace MutationResolvers {
   export type OpenInBrowserResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, OpenInBrowserArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, OpenInBrowserArgs>;
   export interface OpenInBrowserArgs {
     url: string;
   }
@@ -1655,8 +1658,8 @@ export namespace MutationResolvers {
   export type SelectDirectoryResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, SelectDirectoryArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, SelectDirectoryArgs>;
   export interface SelectDirectoryArgs {
     dialogTitle: string;
 
@@ -1668,8 +1671,8 @@ export namespace MutationResolvers {
   export type ShowItemInFolderResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, ShowItemInFolderArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, ShowItemInFolderArgs>;
   export interface ShowItemInFolderArgs {
     item: string;
   }
@@ -1677,118 +1680,118 @@ export namespace MutationResolvers {
   export type OpenDocResolver<
     R = Maybe<any>,
     Parent = {},
-    Context = any
-  > = Resolver<R, Parent, Context, OpenDocArgs>;
+    TContext = any
+  > = Resolver<R, Parent, TContext, OpenDocArgs>;
   export interface OpenDocArgs {
     id: string;
   }
 }
 
 export namespace CommandStartedResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    id?: IdResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    id?: IdResolver<string, TypeParent, TContext>;
   }
 
-  export type IdResolver<R = string, Parent = any, Context = any> = Resolver<
+  export type IdResolver<R = string, Parent = any, TContext = any> = Resolver<
     R,
     Parent,
-    Context
+    TContext
   >;
 }
 
 export namespace StopResultResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    result?: ResultResolver<Maybe<boolean>, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    result?: ResultResolver<Maybe<boolean>, TypeParent, TContext>;
   }
 
   export type ResultResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace RemoveResultResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    result?: ResultResolver<Maybe<boolean>, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    result?: ResultResolver<Maybe<boolean>, TypeParent, TContext>;
   }
 
   export type ResultResolver<
     R = Maybe<boolean>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace OpenInEditorResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    response?: ResponseResolver<string, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    response?: ResponseResolver<string, TypeParent, TContext>;
   }
 
   export type ResponseResolver<
     R = string,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace OpenInBrowserResultResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    result?: ResultResolver<boolean, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    result?: ResultResolver<boolean, TypeParent, TContext>;
   }
 
   export type ResultResolver<
     R = boolean,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace SelectDirectoryResultResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
+  export interface Resolvers<TContext = any, TypeParent = any> {
     selectedDirectoryPath?: SelectedDirectoryPathResolver<
       Maybe<string>,
       TypeParent,
-      Context
+      TContext
     >;
 
-    error?: ErrorResolver<Maybe<string>, TypeParent, Context>;
+    error?: ErrorResolver<Maybe<string>, TypeParent, TContext>;
   }
 
   export type SelectedDirectoryPathResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
   export type ErrorResolver<
     R = Maybe<string>,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace ShowItemInFolderResultResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    result?: ResultResolver<boolean, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    result?: ResultResolver<boolean, TypeParent, TContext>;
   }
 
   export type ResultResolver<
     R = boolean,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 export namespace OpenDocResultResolvers {
-  export interface Resolvers<Context = any, TypeParent = any> {
-    result?: ResultResolver<boolean, TypeParent, Context>;
+  export interface Resolvers<TContext = any, TypeParent = any> {
+    result?: ResultResolver<boolean, TypeParent, TContext>;
   }
 
   export type ResultResolver<
     R = boolean,
     Parent = any,
-    Context = any
-  > = Resolver<R, Parent, Context>;
+    TContext = any
+  > = Resolver<R, Parent, TContext>;
 }
 
 /** Directs the executor to skip this field or fragment when the `if` argument is true. */
@@ -1824,46 +1827,48 @@ export interface DeprecatedDirectiveArgs {
   reason?: string;
 }
 
-export interface IResolvers<Context = any> {
-  Query?: QueryResolvers.Resolvers<Context>;
-  Settings?: SettingsResolvers.Resolvers<Context>;
-  WorkspaceDefinition?: WorkspaceDefinitionResolvers.Resolvers<Context>;
+export type IResolvers<TContext = any> = {
+  Query?: QueryResolvers.Resolvers<TContext>;
+  Settings?: SettingsResolvers.Resolvers<TContext>;
+  WorkspaceDefinition?: WorkspaceDefinitionResolvers.Resolvers<TContext>;
   SchematicCollectionForNgNew?: SchematicCollectionForNgNewResolvers.Resolvers<
-    Context
+    TContext
+  >;
+  Schema?: SchemaResolvers.Resolvers<TContext>;
+  Workspace?: WorkspaceResolvers.Resolvers<TContext>;
+  Dependencies?: DependenciesResolvers.Resolvers<TContext>;
+  Extension?: ExtensionResolvers.Resolvers<TContext>;
+  SchematicCollection?: SchematicCollectionResolvers.Resolvers<TContext>;
+  Schematic?: SchematicResolvers.Resolvers<TContext>;
+  NpmScript?: NpmScriptResolvers.Resolvers<TContext>;
+  Project?: ProjectResolvers.Resolvers<TContext>;
+  Architect?: ArchitectResolvers.Resolvers<TContext>;
+  Options?: OptionsResolvers.Resolvers<TContext>;
+  FieldValue?: FieldValueResolvers.Resolvers<TContext>;
+  ArchitectConfigurations?: ArchitectConfigurationsResolvers.Resolvers<
+    TContext
   >;
-  Schema?: SchemaResolvers.Resolvers<Context>;
-  Workspace?: WorkspaceResolvers.Resolvers<Context>;
-  Dependencies?: DependenciesResolvers.Resolvers<Context>;
-  Extension?: ExtensionResolvers.Resolvers<Context>;
-  SchematicCollection?: SchematicCollectionResolvers.Resolvers<Context>;
-  Schematic?: SchematicResolvers.Resolvers<Context>;
-  NpmScript?: NpmScriptResolvers.Resolvers<Context>;
-  Project?: ProjectResolvers.Resolvers<Context>;
-  Architect?: ArchitectResolvers.Resolvers<Context>;
-  Options?: OptionsResolvers.Resolvers<Context>;
-  FieldValue?: FieldValueResolvers.Resolvers<Context>;
-  ArchitectConfigurations?: ArchitectConfigurationsResolvers.Resolvers<Context>;
-  RecentAction?: RecentActionResolvers.Resolvers<Context>;
-  Docs?: DocsResolvers.Resolvers<Context>;
-  Doc?: DocResolvers.Resolvers<Context>;
-  CompletionsTypes?: CompletionsTypesResolvers.Resolvers<Context>;
-  CompletionResultType?: CompletionResultTypeResolvers.Resolvers<Context>;
-  EditorSupport?: EditorSupportResolvers.Resolvers<Context>;
-  IsNodeInstalledResult?: IsNodeInstalledResultResolvers.Resolvers<Context>;
-  CommandResponse?: CommandResponseResolvers.Resolvers<Context>;
-  Mutation?: MutationResolvers.Resolvers<Context>;
-  CommandStarted?: CommandStartedResolvers.Resolvers<Context>;
-  StopResult?: StopResultResolvers.Resolvers<Context>;
-  RemoveResult?: RemoveResultResolvers.Resolvers<Context>;
-  OpenInEditor?: OpenInEditorResolvers.Resolvers<Context>;
-  OpenInBrowserResult?: OpenInBrowserResultResolvers.Resolvers<Context>;
-  SelectDirectoryResult?: SelectDirectoryResultResolvers.Resolvers<Context>;
-  ShowItemInFolderResult?: ShowItemInFolderResultResolvers.Resolvers<Context>;
-  OpenDocResult?: OpenDocResultResolvers.Resolvers<Context>;
-}
-
-export interface IDirectiveResolvers<Result> {
+  RecentAction?: RecentActionResolvers.Resolvers<TContext>;
+  Docs?: DocsResolvers.Resolvers<TContext>;
+  Doc?: DocResolvers.Resolvers<TContext>;
+  CompletionsTypes?: CompletionsTypesResolvers.Resolvers<TContext>;
+  CompletionResultType?: CompletionResultTypeResolvers.Resolvers<TContext>;
+  EditorSupport?: EditorSupportResolvers.Resolvers<TContext>;
+  IsNodeInstalledResult?: IsNodeInstalledResultResolvers.Resolvers<TContext>;
+  CommandResponse?: CommandResponseResolvers.Resolvers<TContext>;
+  Mutation?: MutationResolvers.Resolvers<TContext>;
+  CommandStarted?: CommandStartedResolvers.Resolvers<TContext>;
+  StopResult?: StopResultResolvers.Resolvers<TContext>;
+  RemoveResult?: RemoveResultResolvers.Resolvers<TContext>;
+  OpenInEditor?: OpenInEditorResolvers.Resolvers<TContext>;
+  OpenInBrowserResult?: OpenInBrowserResultResolvers.Resolvers<TContext>;
+  SelectDirectoryResult?: SelectDirectoryResultResolvers.Resolvers<TContext>;
+  ShowItemInFolderResult?: ShowItemInFolderResultResolvers.Resolvers<TContext>;
+  OpenDocResult?: OpenDocResultResolvers.Resolvers<TContext>;
+} & { [typeName: string]: never };
+
+export type IDirectiveResolvers<Result> = {
   skip?: SkipDirectiveResolver<Result>;
   include?: IncludeDirectiveResolver<Result>;
   deprecated?: DeprecatedDirectiveResolver<Result>;
-}
+} & { [directiveName: string]: never };
diff --git a/libs/server/src/lib/api/run-command.ts b/libs/server/src/lib/api/run-command.ts
index 9c194dd873..77c96a57d5 100644
--- a/libs/server/src/lib/api/run-command.ts
+++ b/libs/server/src/lib/api/run-command.ts
@@ -11,7 +11,7 @@ export const commands = new Commands(5, 15);
 export function runCommand(
   type: string,
   cwd: string,
-  displayCommand: string,
+  programName: string,
   program: string,
   cmds: string[],
   pseudoTerminalFactory: PseudoTerminalFactory,
@@ -21,21 +21,22 @@ export function runCommand(
   const workspace =
     type === 'new' ? null : readJsonFile('./package.json', cwd).json.name;
   const id = `${program} ${cmds.join(' ')} ${commandRunIndex++}`;
+  let command = `${programName} ${cmds.join(' ')}`;
 
   const supportsNVM = fileUtils.isWsl()
     ? fileUtils.wslSupportsNvm()
     : Boolean(process.env.NVM_DIR);
 
-  // We currently don't support the windows implementation of NVM.
+  // We currently don't suppor the windows implementation of NVM.
   if (supportsNVM && fileUtils.useNvm()) {
-    displayCommand = `nvm exec -- ${displayCommand}`;
-    cmds = ['exec', '--', program, ...cmds];
+    command = `nvm exec ${command}`;
+    cmds = ['exec', program, ...cmds];
     program = 'nvm';
   }
 
   const factory = () => {
     const commandRunning = pseudoTerminalFactory({
-      displayCommand: displayCommand,
+      displayCommand: command,
       name: id,
       program,
       args: normalizeCommands(cwd, cmds),
@@ -57,7 +58,7 @@ export function runCommand(
     type,
     id,
     workspace,
-    displayCommand,
+    command,
     factory,
     statusCalculator,
     addToRecent
diff --git a/libs/server/src/lib/resolvers/mutation.resolver.ts b/libs/server/src/lib/resolvers/mutation.resolver.ts
index 48efa92773..c088285807 100644
--- a/libs/server/src/lib/resolvers/mutation.resolver.ts
+++ b/libs/server/src/lib/resolvers/mutation.resolver.ts
@@ -31,7 +31,7 @@ export class MutationResolver {
       return runCommand(
         'add',
         p,
-        `ng add ${name}`,
+        'ng',
         this.fileUtils.findClosestNg(p),
         ['add', name, '--no-interactive'],
         this.pseudoTerminalFactory,
@@ -54,7 +54,7 @@ export class MutationResolver {
       return runCommand(
         'new',
         p,
-        `new-workspace --collection=${collection} ${newCommand.join(' ')}`,
+        'new-workspace',
         path.join(
           __dirname,
           'assets',
@@ -89,7 +89,7 @@ export class MutationResolver {
       return runCommand(
         'generate',
         p,
-        `ng generate ${[...genCommand, ...dryRun].join(' ')}`,
+        'ng',
         this.fileUtils.findClosestNg(p),
         ['generate', ...genCommand, ...dryRun, '--no-interactive'],
         this.pseudoTerminalFactory,
@@ -116,7 +116,7 @@ export class MutationResolver {
       return runCommand(
         'npm',
         p,
-        `${npmClient} ${[...genCommand, ...dryRun].join(' ')}`,
+        npmClient,
         this.fileUtils.findExecutable(npmClient, p),
         [...genCommand, ...dryRun, '--no-interactive'],
         this.pseudoTerminalFactory,
@@ -135,9 +135,9 @@ export class MutationResolver {
       return runCommand(
         'ng',
         p,
-        `ng ${rc.join(' ')}`,
-        'node',
-        ['--max-old-space-size=4048', this.fileUtils.findClosestNg(p), ...rc],
+        'ng',
+        this.fileUtils.findClosestNg(p),
+        rc,
         this.pseudoTerminalFactory,
         this.fileUtils
       );
@@ -157,7 +157,7 @@ export class MutationResolver {
       return runCommand(
         'npm',
         p,
-        `${npmClient} ${rc.join(' ')}`,
+        npmClient,
         this.fileUtils.findExecutable(npmClient, p),
         rc,
         this.pseudoTerminalFactory,
diff --git a/libs/server/src/lib/utils/stats.ts b/libs/server/src/lib/utils/stats.ts
index 49b1f50d6f..e29602b540 100644
--- a/libs/server/src/lib/utils/stats.ts
+++ b/libs/server/src/lib/utils/stats.ts
@@ -1,12 +1,13 @@
 import { readFileSync } from 'fs';
 import { join } from 'path';
 import { ls } from 'shelljs';
-import * as exploreSourceMap from 'source-map-explorer';
 import { gzipSync } from 'zlib';
 
 import { SPECIAL_SOURCE_FILE_MAPPINGS } from './stats.constants';
 
 // @ts-ignore
+import * as exploreSourceMap from 'source-map-explorer';
+
 export interface Module {
   file: string;
   size: string;