Add docs feature pages (#29)

- Update features/index.md
- Add features/parse.md
- Add features/validate.md
- Add features/visit.md
- Add features/print.md
- Add features/execute.md
- Add features/linq.md
- Update mkdocs.yml for new pages

Author: iMvBremen

docs/defining-a-schema/features/execute.md

@@ -0,0 +1,172 @@
+# Execute
+
+The execute feature wires together parsing, validation, and execution so you can run FunQL requests end-to-end with a
+single call. It builds on the execution pipeline, ensuring that all steps are performed in the correct order and in the 
+right way, reducing complexity for developers.
+
+This page explains how to enable the execute feature, how to run requests, and how to customize the pipeline.
+
+## Adding the feature
+
+Use `AddExecuteFeature()` to register the services required to execute FunQL requests:
+
+```csharp 
+public sealed class ApiSchema : Schema 
+{ 
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema)
+    { 
+        schema.AddExecuteFeature();
+    }
+}
+```
+
+This sets up the execute feature with default configurations and the core execution handlers, like handlers for parsing 
+and validating. See [Advanced configuration](#advanced-configuration) on how to customize the feature.
+
+## Executing requests
+
+To avoid duplication, the examples for executing FunQL requests (both REST-style parameters and full FunQL queries) are 
+documented in the _Executing queries_ guide:
+
+- [Learn how to execute requests →](../../executing-queries/index.md)
+
+## Advanced configuration
+
+The `AddExecuteFeature()` method has two optional arguments:
+
+- `action`: An action to customize the feature.
+- `withCoreExecutionHandlers`: Whether to add all core execution handlers. Default `true`.
+
+For example, add your own execution handler:
+
+```csharp 
+public sealed class ApiSchema : Schema 
+{ 
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema) 
+    { 
+        schema.AddExecuteFeature(config => { 
+            // Customize the feature here            
+            config.WithExecutionHandler("MyCustomHandler", new MyCustomHandler(), 0);
+        });
+    }
+}
+```
+
+### Core execution handlers
+
+With `withCoreExecutionHandlers` set to `true` (default), the execute feature adds the following core execution 
+handlers:
+
+- **`ParseRequestExecutionHandler`**: Parses a full FunQL request string (e.g., `listSets(skip(1))`) into a `Request` 
+  AST for further processing. This is designed for full FunQL queries, treating FunQL as a query language (_QL_).
+- **`ParseRequestForParametersExecutionHandler`**: Builds a `Request` from given parameters (e.g., `filter`, `sort`), 
+  parsing each parameter separately. This is designed for _REST_ APIs where the FunQL parameters are extracted from the 
+  URL, like  `../sets?filter=gte(price, 500)&sort=desc(price)`.
+- **`ValidateRequestExecutionHandler`**: Validates the parsed `Request` against the schema.
+
+!!! tip
+
+    Add the [LINQ feature](linq.md) **after** the execute feature to automatically register the LINQ execution handlers. 
+    These handlers translate the `Request` into LINQ and apply filter/sort/limit/skip to the target `IQueryable`.
+
+### Custom execution handlers
+
+You can also add your own execution handlers to the pipeline. For example, a handler that measures the time it takes to 
+execute the request:
+
+```csharp 
+public sealed class TimingExecutionHandler : IExecutionHandler 
+{     
+    public async Task Execute(IExecutorState state, ExecutorDelegate next, CancellationToken cancellationToken)
+    {
+        var stopwatch = Stopwatch.StartNew();
+        try
+        {
+            await next(state, cancellationToken);
+        }
+        finally
+        {
+            stopwatch.Stop();
+            Console.WriteLine($"Request executed in {stopwatch.ElapsedMilliseconds} ms");
+        }
+    }
+}
+```
+
+Then register the handler when adding the execute feature:
+
+```csharp 
+public sealed class ApiSchema : Schema 
+{ 
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema) 
+    { 
+        schema.AddExecuteFeature(config => { 
+            // Register the handler here      
+            config.WithExecutionHandler(
+                // Name of the handler, used to identify it in the pipeline
+                name: "TimingExecutionHandler", 
+                new TimingExecutionHandler(), 
+                // Lower order means earlier in the pipeline, so pick a very 
+                // low value to measure the whole pipeline 
+                order: int.MinValue
+            );
+        });
+    }
+}
+```
+
+Now whenever a request is executed, the `TimingExecutionHandler` will log how long it takes to execute the request.
+
+**Dynamic context:**
+
+For handlers that require dynamic context or need to share data with other handlers, use `IExecutorState` to enter an 
+`IExecuteContext`. This stores data that handlers later in the pipeline can then use.
+
+As an example, we update the `TimingExecutionHandler` to enter a `TimingContext` with a shared `Stopwatch` for a 
+different handler to use:
+
+```csharp 
+public sealed record TimingContext(Stopwatch Stopwatch) : IExecuteContext;
+
+public sealed class TimingExecutionHandler : IExecutionHandler 
+{     
+    public async Task Execute(IExecutorState state, ExecutorDelegate next, CancellationToken cancellationToken)
+    {
+        var stopwatch = Stopwatch.StartNew();
+        // Enter the context before calling the next handler
+        state.EnterContext(new TimingContext(stopwatch));
+        
+        await next(state, cancellationToken);
+        
+        // Exit the context to clean up the data
+        state.ExitContext();
+    }
+}
+```
+
+Now create a handler that uses the `TimingContext` to log the elapsed time:
+
+```csharp 
+public sealed class LogTimingExecutionHandler : IExecutionHandler 
+{     
+    public Task Execute(IExecutorState state, ExecutorDelegate next, CancellationToken cancellationToken)
+    {
+        // Find the context and log the elapsed time
+        var context = state.FindContext<TimingContext>();
+        if (context != null) {
+            Console.WriteLine($"Time elapsed is {context.stopwatch.ElapsedMilliseconds} ms");
+        } // else: Context was not entered
+        
+        return next(state, cancellationToken);
+    }
+}
+```
+
+The `LogTimingExecutionHandler` logs the elapsed time only when a `TimingContext` has been entered.
+
+## What's next
+
+With the execution feature added, it's time to use it:
+
+- [Learn more about executing queries →](../../executing-queries/index.md)
+- [Learn more about the LINQ feature →](linq.md)

docs/defining-a-schema/features/index.md

@@ -1,7 +1,139 @@
 # Features
 
-!!! info "Work in Progress"
+FunQL provides a modular architecture where each capability (like parse, validate, execute) is its own configurable
+feature. By only including the features you need, you ensure that your schema remains lightweight and optimized for your
+use case.
 
-    We are actively working on the documentation for FunQL .NET.  
-    Please check back later or visit [our repository](https://github.com/funql/funql-dotnet) to track progress or
-    contribute.
+This section introduces FunQL's features, explains their role, and shows you how to add them to your schema.
+
+## Adding core features
+
+To quickly enable all core features (Parse, Validate, Execute, Print, and Visit), use:
+
+```csharp
+public sealed class ApiSchema : Schema
+{
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema)
+    {
+        schema.AddCoreFeatures();
+    }
+}
+```
+
+For a lightweight schema, selectively add only the features you need.
+
+---
+
+## Parse
+
+The parse feature enables FunQL to transform raw queries into structured query nodes by generating an Abstract Syntax 
+Tree (AST). This is the first step in handling FunQL queries before validation or execution.
+
+**Adding the feature:**
+
+```csharp
+public sealed class ApiSchema : Schema
+{
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema)
+    {
+        schema.AddParseFeature();
+    }
+}
+```
+
+[Learn more about the parse feature →](parse.md)
+
+## Validate
+
+The validate feature allows for validating that FunQL queries comply with the rules defined in the schema. This prevents 
+invalid queries from being processed by catching errors early.
+
+**Adding the feature:**
+
+```csharp
+public sealed class ApiSchema : Schema
+{
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema)
+    {
+        schema.AddValidateFeature();
+    }
+}
+```
+  
+[Learn more about the validate feature →](validate.md)
+
+## Execute
+
+The execute feature simplifies the entire query-processing pipeline by combining parsing, validation, and execution into
+a single method, leveraging FunQL's [execution pipeline](../../executing-queries/pipeline.md).
+
+**Adding the feature:**
+
+```csharp
+public sealed class ApiSchema : Schema
+{
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema)
+    {
+        schema.AddExecuteFeature();
+    }
+}
+```
+
+[Learn more about the execute feature →](execute.md)
+
+## LINQ
+
+The LINQ feature translates FunQL queries into LINQ expressions, enabling seamless integration with LINQ-based
+frameworks such as Entity Framework Core.
+
+**Adding the feature:**
+
+```csharp
+public sealed class ApiSchema : Schema
+{
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema)
+    {
+        schema.AddLinqFeature();
+    }
+}
+```
+
+[Learn more about the LINQ feature →](linq.md)
+
+## Visit
+
+The visit feature provides functionality to traverse and inspect the FunQL AST. It is commonly used for the [validate
+feature](#validate), but it can be extended for custom operations like query rewriting or auditing.
+
+**Adding the feature:**
+
+```csharp
+public sealed class ApiSchema : Schema
+{
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema)
+    {
+        schema.AddVisitFeature();
+    }
+}
+```
+
+[Learn more about the visit feature →](visit.md)
+
+## Print
+
+The print feature converts the FunQL AST into a readable FunQL query string. This is useful for logging or debugging
+complex queries.
+
+**Adding the feature:**
+
+```csharp
+public sealed class ApiSchema : Schema
+{
+    protected override void OnInitializeSchema(ISchemaConfigBuilder schema)
+    {
+        schema.AddPrintFeature();
+    }
+}
+```
+
+[Learn more about the print feature →](print.md)