Fix/guid return command

Samples/eCommerce/Basic/API/Carts/Cart.cs

@@ -30,11 +30,12 @@ public class Cart(IGrainFactory grainFactory, ICartQueries cartQueries) : Contro
     /// <param name="addItemToCart">Payload holding the command.</param>
     /// <returns>Awaitable task.</returns>
     [HttpPost("add-item")]
-    public async Task AddItem([FromBody] AddItemToCart addItemToCart)
+    public async Task<Guid> AddItem([FromBody] AddItemToCart addItemToCart)
     {
         var cartId = (CartId)(User.Identity?.GetUserIdAsGuid() ?? Guid.Empty);
         var price = await grainFactory.GetGrain<IProductPrice>(addItemToCart.Sku).GetPrice();
         await grainFactory.GetGrain<ICart>(cartId).AddItem(addItemToCart.Sku, price, addItemToCart.Quantity);
+        return cartId;
     }
 
     /// <summary>

Samples/eCommerce/Basic/Web/API/Carts/AddItem.ts

@@ -6,6 +6,7 @@
 import { Command, CommandValidator, CommandPropertyValidators } from '@cratis/applications/commands';
 import { useCommand, SetCommandValues, ClearCommandValues } from '@cratis/applications.react/commands';
 import { Validator } from '@cratis/applications/validation';
+import { Guid } from '@cratis/fundamentals';
 import Handlebars from 'handlebars';
 
 const routeTemplate = Handlebars.compile('/api/carts/add-item');
@@ -22,7 +23,7 @@ export class AddItemValidator extends CommandValidator {
     };
 }
 
-export class AddItem extends Command<IAddItem> implements IAddItem {
+export class AddItem extends Command<IAddItem, Guid> implements IAddItem {
     readonly route: string = '/api/carts/add-item';
     readonly routeTemplate: Handlebars.TemplateDelegate = routeTemplate;
     readonly validation: CommandValidator = new AddItemValidator();
@@ -31,7 +32,7 @@ export class AddItem extends Command<IAddItem> implements IAddItem {
     private _quantity!: number;
 
     constructor() {
-        super(Object, false);
+        super(Guid, false);
     }
 
     get requestArguments(): string[] {

Source/DotNET/Tools/ProxyGenerator/CommandExtensions.cs

@@ -44,8 +44,11 @@ public static CommandDescriptor ToCommandDescriptor(this MethodInfo method, stri
 
         var propertiesWithComplexTypes = properties.Where(_ => !_.OriginalType.IsKnownType());
         typesInvolved.AddRange(propertiesWithComplexTypes.Select(_ => _.OriginalType));
-        var imports = typesInvolved.GetImports(targetPath, method.DeclaringType!.ResolveTargetPath(segmentsToSkip), segmentsToSkip);
-
+        var imports = typesInvolved.GetImports(targetPath, method.DeclaringType!.ResolveTargetPath(segmentsToSkip), segmentsToSkip).ToList();
+        if (responseModel.Type is not null && responseModel.Type.GetTargetType().TryGetImportStatement(out var responseTypeImportStatement))
+        {
+            imports.Add(responseTypeImportStatement);
+        }
         var additionalTypesInvolved = new List<Type>();
         foreach (var property in propertiesWithComplexTypes)
         {

Source/DotNET/Tools/ProxyGenerator/TargetTypeExtensions.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+using Cratis.Applications.ProxyGenerator.Templates;
+
+namespace Cratis.Applications.ProxyGenerator;
+
+/// <summary>
+/// Extension methods for <see cref="TargetType"/>.
+/// </summary>
+public static class TargetTypeExtensions
+{
+    /// <summary>
+    /// Try to get import statement from target type.
+    /// </summary>
+    /// <param name="targetType">The target type.</param>
+    /// <param name="importStatement">The resulting import statement if it requires so.</param>
+    /// <returns>True if it needs an import statement, false if not.</returns>
+    public static bool TryGetImportStatement(this TargetType targetType, [NotNullWhen(true)]out ImportStatement? importStatement)
+    {
+        importStatement = null;
+        var requiresImport = !string.IsNullOrEmpty(targetType.Module);
+        if (requiresImport)
+        {
+            importStatement = new ImportStatement(targetType.Type, targetType.Module);
+        }
+        return requiresImport;
+    }
+}

Source/DotNET/Tools/ProxyGenerator/TypeExtensions.cs

@@ -362,11 +362,15 @@ public static string ResolveTargetPath(this Type type, int segmentsToSkip)
     public static IEnumerable<ImportStatement> GetImports(this IEnumerable<Type> types, string targetPath, string relativePath, int segmentsToSkip) =>
          types.Select(_ =>
         {
-            var fullPath = Path.Join(targetPath, relativePath);
-            var fullPathForType = Path.Join(targetPath, _.ResolveTargetPath(segmentsToSkip));
-            var importPath = Path.GetRelativePath(fullPath, fullPathForType);
-            importPath = $"{importPath}/{_.Name}";
-            return new ImportStatement(_.GetTargetType().Type, importPath);
+            var targetType = _.GetTargetType();
+            var importPath = targetType.Module;
+            if (string.IsNullOrEmpty(importPath))
+            {
+                var fullPath = Path.Join(targetPath, relativePath);
+                var fullPathForType = Path.Join(targetPath, _.ResolveTargetPath(segmentsToSkip));
+                importPath = $"{Path.GetRelativePath(fullPath, fullPathForType)}/{_.Name}";
+            }
+            return new ImportStatement(targetType.Type, importPath);
         }).ToArray();
 
     /// <summary>