Add: Support fully-registered pre/post images

XrmPluginCore.SourceGenerator.Tests/DiagnosticTests/DiagnosticReportingTests.cs

@@ -1064,6 +1064,56 @@ public void HandleUpdate() { }
 			"Namespace2 source should not contain Namespace1 namespace declaration");
 	}
 
+	[Fact]
+	public async Task Should_Report_XPC3005_When_WithPreImage_Has_No_Arguments()
+	{
+		var source = TestFixtures.GetCompleteSource(TestFixtures.PluginWithFullEntityPreImage);
+
+		var diagnostics = await GetAnalyzerDiagnosticsAsync(source, new FullEntityImageAnalyzer());
+
+		var warnings = diagnostics.Where(d => d.Id == "XPC3005").ToArray();
+
+		warnings.Should().NotBeEmpty("XPC3005 should be reported when WithPreImage() is called with no arguments");
+		warnings.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Warning);
+	}
+
+	[Fact]
+	public async Task Should_Report_XPC3005_When_WithPostImage_Has_No_Arguments()
+	{
+		var source = TestFixtures.GetCompleteSource(TestFixtures.PluginWithFullEntityPostImage);
+
+		var diagnostics = await GetAnalyzerDiagnosticsAsync(source, new FullEntityImageAnalyzer());
+
+		var warnings = diagnostics.Where(d => d.Id == "XPC3005").ToArray();
+
+		warnings.Should().NotBeEmpty("XPC3005 should be reported when WithPostImage() is called with no arguments");
+		warnings.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Warning);
+	}
+
+	[Fact]
+	public async Task Should_Not_Report_XPC3005_When_WithPreImage_Has_Arguments()
+	{
+		var source = TestFixtures.GetCompleteSource(TestFixtures.GetPluginWithPreImage());
+
+		var diagnostics = await GetAnalyzerDiagnosticsAsync(source, new FullEntityImageAnalyzer());
+
+		var warnings = diagnostics.Where(d => d.Id == "XPC3005").ToArray();
+
+		warnings.Should().BeEmpty("XPC3005 should NOT be reported when WithPreImage() is called with specific attributes");
+	}
+
+	[Fact]
+	public async Task Should_Not_Report_XPC3005_When_WithPostImage_Has_Arguments()
+	{
+		var source = TestFixtures.GetCompleteSource(TestFixtures.PluginWithPostImage);
+
+		var diagnostics = await GetAnalyzerDiagnosticsAsync(source, new FullEntityImageAnalyzer());
+
+		var warnings = diagnostics.Where(d => d.Id == "XPC3005").ToArray();
+
+		warnings.Should().BeEmpty("XPC3005 should NOT be reported when WithPostImage() is called with specific attributes");
+	}
+
 	private static async Task<ImmutableArray<Diagnostic>> GetAnalyzerDiagnosticsAsync(string source, DiagnosticAnalyzer analyzer)
 	{
 		var compilation = CompilationHelper.CreateCompilation(source);

XrmPluginCore.SourceGenerator.Tests/GenerationTests/WrapperClassGenerationTests.cs

@@ -330,6 +330,84 @@ public void Should_Parse_Parameterless_Method_Reference()
 		generatedSource.Should().Contain("service.HandleUpdate()");
 	}
 
+	[Fact]
+	public void Should_Generate_PreImage_With_All_Entity_Properties_When_No_Attributes_Specified()
+	{
+		// Arrange - WithPreImage() called with no arguments
+		var source = TestFixtures.GetCompleteSource(
+			TestFixtures.PluginWithFullEntityPreImage);
+
+		// Act
+		var result = GeneratorTestHelper.RunGenerator(
+			CompilationHelper.CreateCompilation(source));
+
+		// Assert
+		result.GeneratedTrees.Should().NotBeEmpty("code should be generated for full entity PreImage");
+		var generatedSource = result.GeneratedTrees[0].GetText().ToString();
+
+		// Verify PreImage class is generated
+		generatedSource.Should().Contain($"public sealed class PreImage : IEntityImageWrapper<{ContextNamespace}.Account>");
+
+		// Verify that multiple entity properties are present (full entity = all properties)
+		generatedSource.Should().Contain("public string? Name => Entity.Name;");
+		generatedSource.Should().Contain("public decimal? Revenue => Entity.Revenue;");
+		generatedSource.Should().Contain("public string? AccountNumber => Entity.AccountNumber;");
+
+		// Verify NO PostImage class is generated
+		generatedSource.Should().NotContain("public sealed class PostImage");
+	}
+
+	[Fact]
+	public void Should_Generate_PostImage_With_All_Entity_Properties_When_No_Attributes_Specified()
+	{
+		// Arrange - WithPostImage() called with no arguments
+		var source = TestFixtures.GetCompleteSource(
+			TestFixtures.PluginWithFullEntityPostImage);
+
+		// Act
+		var result = GeneratorTestHelper.RunGenerator(
+			CompilationHelper.CreateCompilation(source));
+
+		// Assert
+		result.GeneratedTrees.Should().NotBeEmpty("code should be generated for full entity PostImage");
+		var generatedSource = result.GeneratedTrees[0].GetText().ToString();
+
+		// Verify PostImage class is generated
+		generatedSource.Should().Contain($"public sealed class PostImage : IEntityImageWrapper<{ContextNamespace}.Account>");
+
+		// Verify that multiple entity properties are present (full entity = all properties)
+		generatedSource.Should().Contain("public string? Name => Entity.Name;");
+		generatedSource.Should().Contain("public decimal? Revenue => Entity.Revenue;");
+		generatedSource.Should().Contain("public string? AccountNumber => Entity.AccountNumber;");
+
+		// Verify NO PreImage class is generated
+		generatedSource.Should().NotContain("public sealed class PreImage");
+	}
+
+	[Fact]
+	public void Should_Generate_ActionWrapper_With_Full_Entity_PreImage_Call()
+	{
+		// Arrange - WithPreImage() called with no arguments
+		var source = TestFixtures.GetCompleteSource(
+			TestFixtures.PluginWithFullEntityPreImage);
+
+		// Act
+		var result = GeneratorTestHelper.RunGenerator(
+			CompilationHelper.CreateCompilation(source));
+
+		// Assert
+		var generatedSource = result.GeneratedTrees[0].GetText().ToString();
+
+		// Verify ActionWrapper is generated and handles the PreImage
+		generatedSource.Should().Contain("internal sealed class ActionWrapper : IActionWrapper");
+		generatedSource.Should().Contain("var preImageEntity = context?.PreEntityImages?.Values?.FirstOrDefault();");
+		generatedSource.Should().Contain("var preImage = preImageEntity != null ? new PreImage(preImageEntity) : null;");
+		generatedSource.Should().Contain("service.HandleAccountUpdate(preImage)");
+
+		// Should NOT have PostImage retrieval
+		generatedSource.Should().NotContain("PostEntityImages");
+	}
+
 	[System.Text.RegularExpressions.GeneratedRegex(@"namespace\s+TestNamespace\.PluginRegistrations\.TestPlugin\.AccountUpdatePostOperation")]
 	private static partial System.Text.RegularExpressions.Regex IsAccountUpdatePostOperationNamespace();
 

XrmPluginCore.SourceGenerator.Tests/Helpers/TestFixtures.cs

@@ -198,6 +198,90 @@ public void HandleUpdate() { }
 				}
 		""";
 
+	/// <summary>
+	/// Plugin with full entity PreImage (no attributes specified — captures all entity attributes).
+	/// </summary>
+	public const string PluginWithFullEntityPreImage = """
+
+		using XrmPluginCore;
+		using XrmPluginCore.Abstractions;
+		using XrmPluginCore.Enums;
+		using Microsoft.Extensions.DependencyInjection;
+		using TestNamespace;
+		using TestNamespace.PluginRegistrations.TestPlugin.AccountUpdatePostOperation;
+
+		namespace TestNamespace
+		{
+		    public class TestPlugin : Plugin
+		    {
+		        public TestPlugin()
+		        {
+		            RegisterStep<Account, ITestService>(EventOperation.Update, ExecutionStage.PostOperation,
+		                nameof(ITestService.HandleAccountUpdate))
+		                .AddFilteredAttributes(x => x.Name)
+		                .WithPreImage();
+		        }
+
+		        protected override IServiceCollection OnBeforeBuildServiceProvider(IServiceCollection services)
+		        {
+		            return services.AddScoped<ITestService, TestService>();
+		        }
+		    }
+
+		    public interface ITestService
+		    {
+		        void HandleAccountUpdate(PreImage preImage);
+		    }
+
+		    public class TestService : ITestService
+		    {
+		        public void HandleAccountUpdate(PreImage preImage) { }
+		    }
+		}
+		""";
+
+	/// <summary>
+	/// Plugin with full entity PostImage (no attributes specified — captures all entity attributes).
+	/// </summary>
+	public const string PluginWithFullEntityPostImage = """
+
+		using XrmPluginCore;
+		using XrmPluginCore.Abstractions;
+		using XrmPluginCore.Enums;
+		using Microsoft.Extensions.DependencyInjection;
+		using TestNamespace;
+		using TestNamespace.PluginRegistrations.TestPlugin.AccountUpdatePostOperation;
+
+		namespace TestNamespace
+		{
+		    public class TestPlugin : Plugin
+		    {
+		        public TestPlugin()
+		        {
+		            RegisterStep<Account, ITestService>(EventOperation.Update, ExecutionStage.PostOperation,
+		                nameof(ITestService.HandleAccountUpdate))
+		                .AddFilteredAttributes(x => x.Name)
+		                .WithPostImage();
+		        }
+
+		        protected override IServiceCollection OnBeforeBuildServiceProvider(IServiceCollection services)
+		        {
+		            return services.AddScoped<ITestService, TestService>();
+		        }
+		    }
+
+		    public interface ITestService
+		    {
+		        void HandleAccountUpdate(PostImage postImage);
+		    }
+
+		    public class TestService : ITestService
+		    {
+		        public void HandleAccountUpdate(PostImage postImage) { }
+		    }
+		}
+		""";
+
 	/// <summary>
 	/// Plugin using old AddImage API for backward compatibility testing.
 	/// </summary>

XrmPluginCore.SourceGenerator/AnalyzerReleases.Unshipped.md

@@ -3,6 +3,7 @@
 Rule ID | Category | Severity | Notes
 --------|----------|----------|-------
 XPC3004 | XrmPluginCore.SourceGenerator | Error | Do not use LocalPluginContext as TService in RegisterStep
+XPC3005 | XrmPluginCore.SourceGenerator | Warning | Full entity image registration without specifying attributes
 
 ### Removed Rules
 

XrmPluginCore.SourceGenerator/Analyzers/FullEntityImageAnalyzer.cs

@@ -0,0 +1,47 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using System.Collections.Immutable;
+
+namespace XrmPluginCore.SourceGenerator.Analyzers;
+
+/// <summary>
+/// Analyzer that reports XPC3005 when WithPreImage or WithPostImage is called
+/// without specifying any attributes, resulting in a full entity image registration.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class FullEntityImageAnalyzer : DiagnosticAnalyzer
+{
+	public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
+		ImmutableArray.Create(DiagnosticDescriptors.FullEntityImage);
+
+	public override void Initialize(AnalysisContext context)
+	{
+		context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+		context.EnableConcurrentExecution();
+		context.RegisterSyntaxNodeAction(AnalyzeInvocation, SyntaxKind.InvocationExpression);
+	}
+
+	private void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
+	{
+		var invocation = (InvocationExpressionSyntax)context.Node;
+
+		if (invocation.Expression is not MemberAccessExpressionSyntax memberAccess)
+			return;
+
+		var methodName = memberAccess.Name.Identifier.Text;
+
+		if (methodName != Constants.WithPreImageMethodName && methodName != Constants.WithPostImageMethodName)
+			return;
+
+		// Only report when called with no arguments (full entity image)
+		if (invocation.ArgumentList.Arguments.Count > 0)
+			return;
+
+		context.ReportDiagnostic(Diagnostic.Create(
+			DiagnosticDescriptors.FullEntityImage,
+			invocation.GetLocation(),
+			methodName));
+	}
+}

XrmPluginCore.SourceGenerator/DiagnosticDescriptors.cs

@@ -106,6 +106,16 @@ public static class DiagnosticDescriptors
 		DiagnosticSeverity.Warning,
 		isEnabledByDefault: true);
 
+	public static readonly DiagnosticDescriptor FullEntityImage = new(
+		id: "XPC3005",
+		title: "Full entity image registration",
+		messageFormat: "'{0}' registered without specifying attributes will capture all entity attributes. Consider specifying only the attributes your handler needs for better performance.",
+		category: Category,
+		defaultSeverity: DiagnosticSeverity.Warning,
+		isEnabledByDefault: true,
+		description: "Registering an image without specifying attributes causes Dynamics 365 to serialize all entity attributes into the image, which may impact performance. Specify only the attributes your handler needs.",
+		helpLinkUri: $"{HelpLinkBaseUri}/XPC3005.md");
+
 	public static readonly DiagnosticDescriptor GenerationError = new(
 		id: "XPC5002",
 		title: "Failed to generate wrapper classes",

XrmPluginCore.SourceGenerator/Parsers/RegistrationParser.cs

@@ -244,9 +244,29 @@ private static ImageMetadata ParseImageInvocation(
 			imageMetadata.ImageName = imageMetadata.ImageType;
 		}
 
+		// For WithPreImage/WithPostImage with no attributes specified, capture all entity attributes
+		if (!imageMetadata.Attributes.Any() &&
+			(methodName == Constants.WithPreImageMethodName || methodName == Constants.WithPostImageMethodName))
+		{
+			imageMetadata.Attributes.AddRange(GetAllEntityAttributes(entityType));
+		}
+
 		return imageMetadata.Attributes.Any() ? imageMetadata : null;
 	}
 
+	/// <summary>
+	/// Gets all attribute metadata for all entity properties that have an AttributeLogicalName attribute.
+	/// Used for full entity images where no specific attributes are specified.
+	/// </summary>
+	private static IEnumerable<AttributeMetadata> GetAllEntityAttributes(ITypeSymbol entityType)
+	{
+		return entityType.GetMembers()
+			.OfType<IPropertySymbol>()
+			.Where(p => p.GetAttributes().Any(a => a.AttributeClass?.Name == Constants.LogicalNameAttributeName))
+			.Select(p => GetAttributeMetadata(p.Name, entityType))
+			.Where(a => a != null);
+	}
+
 	/// <summary>
 	/// Gets attribute metadata (property name, logical name, type) for a property
 	/// </summary>