Handling stored procedure operations which have UDTs.

Author: dandrejvv

Modules/Intent.Modules.EntityFrameworkCore.Repositories/FactoryExtensions/CustomRepositoryMethodsExtension.cs

@@ -46,7 +46,7 @@ protected override void OnAfterTemplateRegistrations(IApplication application)
                 var hasTypeDefinitionResults = repositoryModels
                     .SelectMany(EntityFrameworkRepositoryHelpers.GetStoredProcedureModels)
                     .Where(x => dbContextTemplate.ClassName == x.DbContextInstance.DbContextName)
-                    .Select(x => x.StoredProcedureModel.TypeReference?.Element.AsTypeDefinitionModel())
+                    .Select(x => x.ReturnType?.Element.AsTypeDefinitionModel())
                     .Any(x => x != null);
 
                 if (hasTypeDefinitionResults)

Modules/Intent.Modules.EntityFrameworkCore.Repositories/Intent.EntityFrameworkCore.Repositories.imodspec

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <package>
   <id>Intent.EntityFrameworkCore.Repositories</id>
-  <version>4.7.16</version>
+  <version>4.7.17-pre.0</version>
   <supportedClientVersions>[4.5.15-a,5.0.0)</supportedClientVersions>
   <summary>Generates Repositories for Domain Entities</summary>
   <description>Generates Repositories for Domain Entities</description>

Modules/Intent.Modules.EntityFrameworkCore.Repositories/Templates/DataContractExtensionMethods/DataContractExtensionMethodsTemplateRegistration.cs

@@ -36,12 +36,19 @@ public override ITemplate CreateTemplateInstance(IOutputTarget outputTarget, Dat
         [IntentManaged(Mode.Merge, Body = Mode.Ignore, Signature = Mode.Fully)]
         public override IEnumerable<DataContractModel> GetModels(IApplication application)
         {
-            return _metadataManager.Domain(application).GetRepositoryModels()
+            var spModels = _metadataManager.Domain(application).GetRepositoryModels()
                 .SelectMany(repository => repository.GetStoredProcedureModels())
-                .SelectMany(storedProcedure => storedProcedure.StoredProcedureModel.Parameters
-                    .Where(parameter => parameter.TypeReference.Element.IsDataContractModel())
-                    .Select(parameter => parameter.TypeReference.Element.AsDataContractModel()))
-                .Distinct();
+                .ToArray();
+            var dcModels = spModels
+                .SelectMany(storedProcedure => storedProcedure.Parameters
+                    .Where(parameter => parameter.ParameterType?.Element.IsDataContractModel() == true)
+                    .Select(parameter => parameter.ParameterType.Element.AsDataContractModel()))
+                .Concat(spModels
+                    .Where(m => m.ReturnType?.Element.IsDataContractModel() == true)
+                    .Select(m => m.ReturnType.Element.AsDataContractModel()))
+                .Distinct()
+                .ToList();
+            return dcModels;
         }
     }
 }

Modules/Intent.Modules.EntityFrameworkCore.Repositories/Templates/EntityFrameworkRepositoryHelpers.cs

@@ -27,6 +27,7 @@
 using Intent.Utils;
 using OperationModel = Intent.Modelers.Domain.Api.OperationModel;
 using OperationModelExtensions = Intent.Modelers.Domain.Api.OperationModelExtensions;
+using ParameterModel = Intent.Modelers.Domain.Api.ParameterModel;
 
 namespace Intent.Modules.EntityFrameworkCore.Repositories.Templates;
 
@@ -624,47 +625,75 @@ internal record StoredProcedureModelPair
     {
         public StoredProcedureModelPair(StoredProcedureModel storedProcedureModel)
         {
-            StoredProcedureModel = storedProcedureModel;
+            StoredProcedureName = storedProcedureModel.Name;
+            ReturnType = storedProcedureModel.ReturnType;
+            Parameters = storedProcedureModel.Parameters.Select(x => new StoredProcedureModelParameter(x)).ToArray();
             DbContextInstance = new DbContextInstance(storedProcedureModel.InternalElement.Package.AsDomainPackageModel());
         }
+
+        public StoredProcedureModelPair(OperationModel operationModel)
+        {
+            StoredProcedureName = operationModel.Name;
+            ReturnType = operationModel.ReturnType;
+            Parameters = operationModel.Parameters.Select(x => new StoredProcedureModelParameter(x)).ToArray();
+            DbContextInstance = new DbContextInstance(operationModel.InternalElement.Package.AsDomainPackageModel());
+        }
+        
+        public string StoredProcedureName { get; }
+        public ITypeReference? ReturnType { get; }
+        public IReadOnlyList<StoredProcedureModelParameter> Parameters { get; }
 
-        public StoredProcedureModel StoredProcedureModel { get; }
         public DbContextInstance DbContextInstance { get; }
     }
 
+    internal record StoredProcedureModelParameter
+    {
+        public StoredProcedureModelParameter(StoredProcedureParameterModel paramModel)
+        {
+            ParameterName = paramModel.Name;
+            ParameterType = paramModel.TypeReference;
+        }
+
+        public StoredProcedureModelParameter(ParameterModel paramModel)
+        {
+            ParameterName = paramModel.Name;
+            ParameterType = paramModel.TypeReference;
+        }
+
+        public string ParameterName { get; }
+        public ITypeReference? ParameterType { get; }
+    }
+
     public static IReadOnlyCollection<StoredProcedureModelPair> GetStoredProcedureModels(this RepositoryModel repositoryModel)
     {
         return repositoryModel.InternalElement.ChildElements
             .SelectMany(childElement =>
             {
                 var storedProcedureModel = childElement.AsStoredProcedureModel();
-                if (storedProcedureModel != null)
+                if (storedProcedureModel is not null)
                 {
                     return [new StoredProcedureModelPair(storedProcedureModel)];
                 }
 
                 var operationModel = OperationModelExtensions.AsOperationModel(childElement);
-                if (operationModel != null)
+                var invokedStoredProcedures = operationModel.StoredProcedureInvocationTargets()
+                    .Select(x => x.TypeReference?.Element?.AsStoredProcedureModel())
+                    .Where(x => x != null)
+                    .Cast<StoredProcedureModel>()
+                    .Select(x => new StoredProcedureModelPair(x))
+                    .ToArray();
+
+                if (invokedStoredProcedures.Length > 0)
                 {
-                    var invokedStoredProcedures = operationModel.StoredProcedureInvocationTargets()
-                        .Select(x => x.TypeReference?.Element?.AsStoredProcedureModel())
-                        .Where(x => x != null)
-                        .Cast<StoredProcedureModel>()
-                        .Select(x => new StoredProcedureModelPair(x))
-                        .ToArray();
-
-                    if (invokedStoredProcedures.Length > 0)
-                    {
-                        return invokedStoredProcedures;
-                    }
+                    return invokedStoredProcedures;
+                }
 
-                    if (operationModel.HasStereotype("Stored Procedure"))
-                    {
-                        return [new StoredProcedureModelPair(new StoredProcedureModel(operationModel.InternalElement, OperationModel.SpecializationType))];
-                    }
+                if (operationModel.HasStereotype("Stored Procedure"))
+                {
+                    return [new StoredProcedureModelPair(operationModel)];
                 }
 
-                return [];
+                return Array.Empty<StoredProcedureModelPair>();
             })
             .ToArray();
     }
@@ -678,8 +707,8 @@ public static IReadOnlyCollection<DataContractModelPair> GetEntityTypeConfigurat
 
         return [.. repositoryModels
                 .SelectMany(GetStoredProcedureModels)
-                .Select(x => x.StoredProcedureModel.TypeReference?.Element.AsDataContractModel() is not null 
-                    ? new DataContractModelPair(x.StoredProcedureModel.TypeReference.Element.AsDataContractModel(), x.DbContextInstance)
+                .Select(x => x.ReturnType?.Element.AsDataContractModel() is not null 
+                    ? new DataContractModelPair(x.ReturnType.Element.AsDataContractModel(), x.DbContextInstance)
                     : null)
                 .Where(x => x != null)
                 .Cast<DataContractModelPair>()

Modules/Intent.Modules.EntityFrameworkCore.Repositories/release-notes.md

@@ -1,3 +1,7 @@
+### Version 4.7.17
+
+- Fixed: Handling stored procedure operations which have UDTs.
+
 ### Version 4.7.16
 
 - Fixed: A software factory exception would occur when references were used in the Visual Studio designer.