Bug fixes, docs

JamesRandall · JamesRandall · commit 773a0b4e0d20 · 2020-02-09T14:40:16.000Z
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -1,5 +1,5 @@
 <Project>
  <PropertyGroup>
-   <CommonPackageVersion>4.0.41-beta.4</CommonPackageVersion>
+   <CommonPackageVersion>4.0.44-beta.4</CommonPackageVersion>
  </PropertyGroup>
 </Project>
diff --git a/Source/FunctionMonkey.Abstractions/Extensions/TypeExtensions.cs b/Source/FunctionMonkey.Abstractions/Extensions/TypeExtensions.cs
@@ -58,7 +58,15 @@ void ExpandType(Type currentType, bool includeNamespace)
                 }
                 else
                 {
-                    retType.Append(includeNamespace ? currentType.ToString() : currentType.Name);
+                    // Not sure if this is correct, its to deal with F# array types as in the ToDo example
+                    if (currentType.IsArray && currentType.ToString().Contains('+'))
+                    {
+                        retType.Append(includeNamespace ? currentType.ToString().Replace("+", ".") : currentType.Name);
+                    }
+                    else
+                    {
+                        retType.Append(includeNamespace ? currentType.ToString() : currentType.Name);
+                    }
                 }
             }
             
diff --git a/Source/FunctionMonkey.Compiler.Core/Compiler.cs b/Source/FunctionMonkey.Compiler.Core/Compiler.cs
@@ -117,6 +117,8 @@ public bool Compile()
                     CompilerOptions = builder.Options
                 };
             }
+
+            PostBuildPatcher.EnsureFunctionsHaveUniqueNames(functionCompilerMetadata.FunctionDefinitions);
             
             IReadOnlyCollection<string> externalAssemblies =
                 GetExternalAssemblyLocations(functionCompilerMetadata.FunctionDefinitions);
@@ -131,7 +133,7 @@ public bool Compile()
                 externalAssemblies,
                 _outputBinaryFolder);
         }
-        
+
         private bool VerifyOutputBindings(IFunctionHostBuilder builder)
         {
             bool foundErrors = false;
diff --git a/Source/FunctionMonkey.Compiler/FunctionMonkey.Compiler.nuspec b/Source/FunctionMonkey.Compiler/FunctionMonkey.Compiler.nuspec
@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
   <metadata>
     <id>FunctionMonkey.Compiler</id>
-    <version>4.0.41-beta.4</version>
+    <version>4.0.44-beta.4</version>
     <authors>James Randall</authors>
     <description>Generates Azure Functions from command registrations</description>
     <licenseUrl>https://raw.githubusercontent.com/JamesRandall/FunctionMonkey/master/LICENSE</licenseUrl>
diff --git a/Source/FunctionMonkey.FSharp/FunctionCompilerMetadata.fs b/Source/FunctionMonkey.FSharp/FunctionCompilerMetadata.fs
@@ -408,6 +408,7 @@ module internal FunctionCompilerMetadata =
                                |> Seq.map (fun f -> f |> createTimerFunctionDefinition configuration) |> Seq.cast<AbstractFunctionDefinition>)
                 |> Seq.append(configuration.functions.cosmosDbFunctions
                               |> Seq.map (fun f -> f |> createCosmosDbFunctionDefinition configuration) |> Seq.cast<AbstractFunctionDefinition>)
+                //|> Seq.mapi(fun index functionDefinition -> functionDefinition.Name <- sprintf "%s%d" functionDefinition.Name index ; functionDefinition)
                 |> Seq.toList
             backlinkReferenceType = configuration.backlinkPropertyInfo.DeclaringType
             backlinkPropertyInfo = configuration.backlinkPropertyInfo
diff --git a/Source/FunctionMonkey/Infrastructure/PostBuildPatcher.cs b/Source/FunctionMonkey/Infrastructure/PostBuildPatcher.cs
@@ -29,6 +29,23 @@ public PostBuildPatcher(IMediatorResultTypeExtractor resultTypeExtractor)
         {
             _resultTypeExtractor = resultTypeExtractor;
         }
+        
+        public static void EnsureFunctionsHaveUniqueNames(IReadOnlyCollection<AbstractFunctionDefinition> functionDefinitions)
+        {
+            var groups = functionDefinitions.GroupBy(x => x.Name)
+                .Where(x => x.Count() > 1)
+                .Select(x => x.ToArray())
+                .ToArray();
+            foreach (var group in groups)
+            {
+                int index = 0;
+                foreach (AbstractFunctionDefinition functionDefinition in group)
+                {
+                    functionDefinition.Name = $"{functionDefinition.Name}{index}";
+                    index++;
+                }
+            }
+        }
 
         public Type CalculateCommandResultType(AbstractFunctionDefinition definition)
         {
diff --git a/Source/FunctionMonkey/Model/HttpFunctionDefinition.cs b/Source/FunctionMonkey/Model/HttpFunctionDefinition.cs
@@ -11,11 +11,11 @@ namespace FunctionMonkey.Model
 {
     public class HttpFunctionDefinition : AbstractFunctionDefinition
     {
-        public HttpFunctionDefinition(Type commandType) : base("", commandType)
+        public HttpFunctionDefinition(Type commandType) : base("Http", commandType)
         {
         }
         
-        public HttpFunctionDefinition(Type commandType, Type explicitCommandResultType) : base("", commandType, explicitCommandResultType)
+        public HttpFunctionDefinition(Type commandType, Type explicitCommandResultType) : base("Http", commandType, explicitCommandResultType)
         {
         }
 
diff --git a/Source/FunctionMonkey/RuntimeInstance.cs b/Source/FunctionMonkey/RuntimeInstance.cs
@@ -123,6 +123,8 @@ public RuntimeInstance(Assembly functionAppConfigurationAssembly,
                 FunctionDefinitions = functionCompilerMetadata.FunctionDefinitions;
                 compileTarget = functionCompilerMetadata.CompilerOptions.HttpTarget;
             }
+            
+            PostBuildPatcher.EnsureFunctionsHaveUniqueNames(FunctionDefinitions);
 
             RegisterCoreDependencies(builder?.MediatorType ?? typeof(DefaultMediatorDecorator), FunctionDefinitions, compileTarget);
 
diff --git a/Tests/FunctionMonkey.FSharp.Tests.Integration.Functions/EntryPoint.fs b/Tests/FunctionMonkey.FSharp.Tests.Integration.Functions/EntryPoint.fs
@@ -58,7 +58,7 @@ let validateToken (bearerToken:string) =
     ]))
 
 let app = functionApp {
-    outputSourcePath "/Users/jamesrandall/code/authoredSource"
+    outputSourcePath "/Users/jamesrandall/Code/authoredSource"
     defaultAuthorizationMode Anonymous
     openApi "F# Integration Test Functions" "1.0.0"
     openApiUserInterface "/openapi"
diff --git a/Tests/FunctionMonkey.FSharp.Tests.Integration.Functions/HttpVerbFunctions.fs b/Tests/FunctionMonkey.FSharp.Tests.Integration.Functions/HttpVerbFunctions.fs
@@ -70,9 +70,16 @@ let private patchRespond (command : HttpPatchCommand) : SimpleResponse =
     
 let private postWithBytesRespond (command : HttpPostWithBytesCommand) =
     command
+    
+let private getWithNoParameters () : SimpleResponse =
+    {
+        value = 42
+        message = "Some text"
+    }
 
 let httpVerbFunctions = functions {
     httpRoute "verbs" [
+        azureFunction.http (Handler(getWithNoParameters), Get)
         azureFunction.http (Handler(getRespond), Get, subRoute = "/{value}")
         azureFunction.http (Handler(postRespond), Post)
         azureFunction.http (Handler(postWithBytesRespond), Post, subRoute = "/bytes")
diff --git a/Tests/FunctionMonkey.Tests.Integration/Http/HttpFunctionWithNoRouteShould.cs b/Tests/FunctionMonkey.Tests.Integration/Http/HttpFunctionWithNoRouteShould.cs
@@ -13,7 +13,7 @@ public class HttpFunctionWithNoRouteShould : AbstractHttpFunctionTest
         public async Task Return200()
         {
             HttpResponseMessage response = await Settings.Host
-                .AppendPathSegment("HttpCommandWithNoRoute")
+                .AppendPathSegment("HttpHttpCommandWithNoRoute")
                 .GetAsync();
 
             Assert.Equal(HttpStatusCode.OK, response.StatusCode);
diff --git a/fsharpdocs/content/quickstarts/_index.md b/fsharpdocs/content/quickstarts/_index.md
@@ -5,12 +5,104 @@ draft: false
 weight: 3
 ---
 
+To demonstrate how to use Function Monkey we'll build a super simple ToDo application. The full source for this, along with a demonstration of how to validate inputs, [can be found on GitHub](https://wwww.github.com).
+
 First create an empty Azure Functions project targetting .NET Core 3.1 and, of course, using F#.
 
 Next add the following NuGet packages:
 
     FunctionMonkey.FSharp
     FunctionMonkey.Compiler
 
-_Note that at the time of writing you will need to use prerelease packages version 4.0.40-beta.4 or later._
+_Note that at the time of writing you will need to use prerelease packages version 4.0.43-beta.4 or later._
+
+First create a file called ToDoItem.fs and create a record type for our ToDo items:
+
+{{< highlight fsharp >}}
+type ToDoItem = {
+    id: System.Guid
+    title: string
+    isComplete: bool
+}
+{{< / highlight >}}
+
+Next lets create a really simple repositoy for ToDo items based around an array. Create a file called MemoryRepository.fs and add functions that let us add, get and mark items as complete:
+
+{{< highlight fsharp >}}
+let mutable private items : ToDoItem[] = [||]
+
+let add title =
+    let newItem = {
+        title = title
+        id = System.Guid.NewGuid()
+        isComplete = false
+    }
+    items <- Array.append items [|newItem|]
+    newItem
+    
+let getAll () = items
+
+let markComplete id =
+    items <-
+        items
+        |> Array.map (fun i -> match i.id = id with
+                               | true -> { i with isComplete = true }
+                               | false -> i)
+{{< / highlight >}}
+
+So far so good. Now lets wire this up to a REST API. Function Monkey uses a DSL to associate functions with triggers. When a trigger is called Function Monkey deserializes the input data, annotates it as appropriate (for example mapping access token claims to fields for an HTTP trigger) and then calling the handler function. If you're not interested in the payload from the trigger then you can skip defining a record and just hand a parameterless function to Function Monkey. There's more to the DSL than that (piping to output triggers, authentication / authorization support, and much more) but this is all we need to get going.
+
+We'll use record types for creating an item and marking an item as complete and a parameterless function for getting all the todo items.
+
+Begin by creating a file called FunctionApp.fs and creating two record types:
+
+{{< highlight fsharp >}}
+type AddToDoItemCommand = {
+    title: string
+}
+
+type MarkAsCompleteCommand = {
+    id: Guid
+}
+{{< / highlight >}}
+
+Now we'll create two functions for handling triggers associated with these commands (we don't need one for getting all the items as we'll see):
+
+{{< highlight fsharp >}}
+let addToDoItem addToRepository command =
+    addToRepository command.title
+    
+let markAsComplete markAsCompleteInRepository command =
+    markAsCompleteInRepository command.id
+{{< / highlight >}}
+
+These two functions accept repository update functions as their first parameter and their respective command as the second parameter. Strictly speaking in this simple example we don't need to do this but its worth demonstrating how you can use currying with Function Monkey to inject dependencies.
+
+Finally we declare a function application using Function Monkey's DSL:
+
+{{< highlight fsharp >}}
+let app = functionApp {
+    httpRoute "todo" [
+        azureFunction.http (Handler(addToDoItem MemoryRepository.add), Post)
+        azureFunction.http (Handler(MemoryRepository.getAll), Get)
+        azureFunction.http (Handler(markAsComplete MemoryRepository.markComplete), Put)
+    ]
+}
+{{< / highlight >}}
+
+In this block we declare a route called todo and associate three HTTP triggers with it on different verbs. We curry our addToDoItem and markAsComplete functions with our reporistory functions and for the get verb we simply use the repository get all method directly.
+
+There's one last thing to do before running this. We're going to remove the "api" prefix that by default Azure Functions applies to the route of every HTTP function. Edit your host.json file (add one if you don't have one):
+
+{{< highlight json >}}
+{
+    "version": "2.0",
+    "extensions": {
+        "http": {
+            "routePrefix": ""
+        }
+    }
+}
+{{< / highlight >}}
 
+With that complete you should be able to run 

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,15 @@ void ExpandType(Type currentType, bool includeNamespace)`
`58`	`58`	`}`
`59`	`59`	`else`
`60`	`60`	`{`
`61`		`- retType.Append(includeNamespace ? currentType.ToString() : currentType.Name);`
	`61`	`+ // Not sure if this is correct, its to deal with F# array types as in the ToDo example`
	`62`	`+ if (currentType.IsArray && currentType.ToString().Contains('+'))`
	`63`	`+ {`
	`64`	`+ retType.Append(includeNamespace ? currentType.ToString().Replace("+", ".") : currentType.Name);`
	`65`	`+ }`
	`66`	`+ else`
	`67`	`+ {`
	`68`	`+ retType.Append(includeNamespace ? currentType.ToString() : currentType.Name);`
	`69`	`+ }`
`62`	`70`	`}`
`63`	`71`	`}`
`64`	`72`
Original file line number	Diff line number	Diff line change
`@@ -117,6 +117,8 @@ public bool Compile()`
`117`	`117`	`CompilerOptions = builder.Options`
`118`	`118`	`};`
`119`	`119`	`}`
	`120`	`+`
	`121`	`+ PostBuildPatcher.EnsureFunctionsHaveUniqueNames(functionCompilerMetadata.FunctionDefinitions);`
`120`	`122`
`121`	`123`	`IReadOnlyCollection<string> externalAssemblies =`
`122`	`124`	`GetExternalAssemblyLocations(functionCompilerMetadata.FunctionDefinitions);`
`@@ -131,7 +133,7 @@ public bool Compile()`
`131`	`133`	`externalAssemblies,`
`132`	`134`	`_outputBinaryFolder);`
`133`	`135`	`}`
`134`		`-`
	`136`	`+`
`135`	`137`	`private bool VerifyOutputBindings(IFunctionHostBuilder builder)`
`136`	`138`	`{`
`137`	`139`	`bool foundErrors = false;`
Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,11 @@ namespace FunctionMonkey.Model`
`11`	`11`	`{`
`12`	`12`	`public class HttpFunctionDefinition : AbstractFunctionDefinition`
`13`	`13`	`{`
`14`		`- public HttpFunctionDefinition(Type commandType) : base("", commandType)`
	`14`	`+ public HttpFunctionDefinition(Type commandType) : base("Http", commandType)`
`15`	`15`	`{`
`16`	`16`	`}`
`17`	`17`
`18`		`- public HttpFunctionDefinition(Type commandType, Type explicitCommandResultType) : base("", commandType, explicitCommandResultType)`
	`18`	`+ public HttpFunctionDefinition(Type commandType, Type explicitCommandResultType) : base("Http", commandType, explicitCommandResultType)`
`19`	`19`	`{`
`20`	`20`	`}`
`21`	`21`
Original file line number	Diff line number	Diff line change
`@@ -123,6 +123,8 @@ public RuntimeInstance(Assembly functionAppConfigurationAssembly,`
`123`	`123`	`FunctionDefinitions = functionCompilerMetadata.FunctionDefinitions;`
`124`	`124`	`compileTarget = functionCompilerMetadata.CompilerOptions.HttpTarget;`
`125`	`125`	`}`
	`126`	`+`
	`127`	`+ PostBuildPatcher.EnsureFunctionsHaveUniqueNames(FunctionDefinitions);`
`126`	`128`
`127`	`129`	`RegisterCoreDependencies(builder?.MediatorType ?? typeof(DefaultMediatorDecorator), FunctionDefinitions, compileTarget);`
`128`	`130`