Create WireMock.Net.MimePart project (#1300)

* Create WireMock.Net.MimePart project

* .

* REFACTOR

* ILRepack

* --

* ...

* x

* x

* .

* fix

* public class MimePartMatcher

* shared

* min

* .

* <!--<DelaySign>true</DelaySign>-->

* Update README.md

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

src/WireMock.Net.Minimal/Transformers/Handlebars/FileHelpers.cs

@@ -0,0 +1,34 @@
+// Copyright © WireMock.Net
+
+using HandlebarsDotNet;
+using HandlebarsDotNet.Helpers.Attributes;
+using HandlebarsDotNet.Helpers.Enums;
+using HandlebarsDotNet.Helpers.Helpers;
+using HandlebarsDotNet.Helpers.Options;
+using Stef.Validation;
+using WireMock.Handlers;
+using WireMock.Settings;
+
+namespace WireMock.Transformers.Handlebars;
+
+internal class FileHelpers : BaseHelpers, IHelpers
+{
+    internal const string Name = "File";
+
+    private readonly IFileSystemHandler _fileSystemHandler;
+
+    public FileHelpers(IHandlebars context, WireMockServerSettings settings) : base(context, new HandlebarsHelpersOptions())
+    {
+        _fileSystemHandler = Guard.NotNull(settings.FileSystemHandler);
+    }
+
+    [HandlebarsWriter(WriterType.String, usage: HelperUsage.Both, passContext: true, name: Name)]
+    public string Read(Context context, string path)
+    {
+        var templateFunc = Context.Compile(path);
+        var transformedPath = templateFunc(context.Value);
+        return _fileSystemHandler.ReadResponseBodyAsString(transformedPath);
+    }
+
+    public Category Category => Category.Custom;
+}

src/WireMock.Net.Minimal/Transformers/Handlebars/HandlebarsContext.cs

@@ -0,0 +1,39 @@
+// Copyright © WireMock.Net
+
+using HandlebarsDotNet;
+using HandlebarsDotNet.Helpers.Extensions;
+using Stef.Validation;
+using WireMock.Handlers;
+
+namespace WireMock.Transformers.Handlebars;
+
+internal class HandlebarsContext : IHandlebarsContext
+{
+    public IHandlebars Handlebars { get; }
+
+    public IFileSystemHandler FileSystemHandler { get; }
+
+    public HandlebarsContext(IHandlebars handlebars, IFileSystemHandler fileSystemHandler)
+    {
+        Handlebars = Guard.NotNull(handlebars);
+        FileSystemHandler = Guard.NotNull(fileSystemHandler);
+    }
+
+    public string ParseAndRender(string text, object model)
+    {
+        var template = Handlebars.Compile(text);
+        return template(model);
+    }
+
+    public object? ParseAndEvaluate(string text, object model)
+    {
+        if (text.StartsWith("{{") && text.EndsWith("}}") &&
+            Handlebars.TryEvaluate(text, model, out var result) &&
+            result is not UndefinedBindingResult)
+        {
+            return result;
+        }
+
+        return ParseAndRender(text, model);
+    }
+}

src/WireMock.Net.Minimal/Transformers/Handlebars/HandlebarsContextFactory.cs

@@ -0,0 +1,32 @@
+// Copyright © WireMock.Net
+
+using HandlebarsDotNet;
+using Stef.Validation;
+using WireMock.Settings;
+
+namespace WireMock.Transformers.Handlebars;
+
+internal class HandlebarsContextFactory : ITransformerContextFactory
+{
+    private readonly WireMockServerSettings _settings;
+
+    public HandlebarsContextFactory(WireMockServerSettings settings)
+    {
+        _settings = Guard.NotNull(settings);
+    }
+
+    public ITransformerContext Create()
+    {
+        var config = new HandlebarsConfiguration
+        {
+            FormatProvider = _settings.Culture
+        };
+        var handlebars = HandlebarsDotNet.Handlebars.Create(config);
+
+        WireMockHandlebarsHelpers.Register(handlebars, _settings);
+
+        _settings.HandlebarsRegistrationCallback?.Invoke(handlebars, _settings.FileSystemHandler);
+
+        return new HandlebarsContext(handlebars, _settings.FileSystemHandler);
+    }
+}

src/WireMock.Net.Minimal/Transformers/Handlebars/IHandlebarsContext.cs

@@ -0,0 +1,10 @@
+// Copyright © WireMock.Net
+
+using HandlebarsDotNet;
+
+namespace WireMock.Transformers.Handlebars;
+
+internal interface IHandlebarsContext : ITransformerContext
+{
+    IHandlebars Handlebars { get; }
+}

src/WireMock.Net.Minimal/Transformers/Handlebars/WireMockHandlebarsHelpers.cs

@@ -0,0 +1,58 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using HandlebarsDotNet;
+using HandlebarsDotNet.Helpers;
+using HandlebarsDotNet.Helpers.Helpers;
+using WireMock.Settings;
+using WireMock.Types;
+
+namespace WireMock.Transformers.Handlebars;
+
+internal static class WireMockHandlebarsHelpers
+{
+    internal static void Register(IHandlebars handlebarsContext, WireMockServerSettings settings)
+    {
+        // Register https://github.com/Handlebars.Net/Handlebars.Net.Helpers
+        HandlebarsHelpers.Register(handlebarsContext, o =>
+        {
+            var paths = new List<string>
+            {
+                Directory.GetCurrentDirectory(),
+                GetBaseDirectory(),
+            };
+
+#if !NETSTANDARD1_3_OR_GREATER
+            void Add(string? path, ICollection<string> customHelperPaths)
+            {
+                if (!string.IsNullOrEmpty(path))
+                {
+                    customHelperPaths.Add(path!);
+                }
+            }
+            Add(Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly()?.Location), paths);
+            Add(Path.GetDirectoryName(System.Reflection.Assembly.GetCallingAssembly().Location), paths);
+            Add(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), paths);
+            Add(Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule?.FileName), paths);
+#endif
+            o.CustomHelperPaths = paths;
+
+            o.CustomHelpers = new Dictionary<string, IHelpers>();
+            if (settings.HandlebarsSettings?.AllowedCustomHandlebarsHelpers.HasFlag(CustomHandlebarsHelpers.File) == true)
+            {
+                o.CustomHelpers.Add(FileHelpers.Name, new FileHelpers(handlebarsContext, settings));
+            }
+        });
+    }
+
+    private static string GetBaseDirectory()
+    {
+#if NETSTANDARD1_3_OR_GREATER || NET6_0_OR_GREATER
+        return AppContext.BaseDirectory.TrimEnd(Path.DirectorySeparatorChar);
+#else
+        return AppDomain.CurrentDomain.BaseDirectory.TrimEnd(Path.DirectorySeparatorChar);
+#endif
+    }
+}

src/WireMock.Net.Minimal/Transformers/ITransformer.cs

@@ -0,0 +1,18 @@
+// Copyright © WireMock.Net
+
+using System.Collections.Generic;
+using WireMock.Types;
+using WireMock.Util;
+
+namespace WireMock.Transformers;
+
+interface ITransformer
+{
+    ResponseMessage Transform(IMapping mapping, IRequestMessage requestMessage, IResponseMessage original, bool useTransformerForBodyAsFile, ReplaceNodeOptions options);
+
+    IBodyData? TransformBody(IMapping mapping, IRequestMessage originalRequestMessage, IResponseMessage originalResponseMessage, IBodyData? bodyData, ReplaceNodeOptions options);
+
+    IDictionary<string, WireMockList<string>> TransformHeaders(IMapping mapping, IRequestMessage originalRequestMessage, IResponseMessage originalResponseMessage, IDictionary<string, WireMockList<string>>? headers);
+
+    string TransformString(IMapping mapping, IRequestMessage originalRequestMessage, IResponseMessage originalResponseMessage, string? value);
+}

src/WireMock.Net.Minimal/Transformers/ITransformerContext.cs

@@ -0,0 +1,14 @@
+// Copyright © WireMock.Net
+
+using WireMock.Handlers;
+
+namespace WireMock.Transformers;
+
+internal interface ITransformerContext
+{
+    IFileSystemHandler FileSystemHandler { get; }
+
+    string ParseAndRender(string text, object model);
+
+    object? ParseAndEvaluate(string text, object model);
+}

src/WireMock.Net.Minimal/Transformers/ITransformerContextFactory.cs

@@ -0,0 +1,9 @@
+// Copyright © WireMock.Net
+
+namespace WireMock.Transformers
+{
+    interface ITransformerContextFactory
+    {
+        ITransformerContext Create();
+    }
+}

src/WireMock.Net.Minimal/Transformers/Scriban/ScribanContext.cs

@@ -0,0 +1,34 @@
+// Copyright © WireMock.Net
+
+using Scriban;
+using Stef.Validation;
+using WireMock.Handlers;
+using WireMock.Types;
+
+namespace WireMock.Transformers.Scriban;
+
+internal class ScribanContext : ITransformerContext
+{
+    private readonly TransformerType _transformerType;
+
+    public IFileSystemHandler FileSystemHandler { get; }
+
+    public ScribanContext(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
+    {
+        FileSystemHandler = Guard.NotNull(fileSystemHandler);
+        _transformerType = transformerType;
+    }
+
+    public string ParseAndRender(string text, object model)
+    {
+        var template = _transformerType == TransformerType.ScribanDotLiquid ? Template.ParseLiquid(text) : Template.Parse(text);
+
+        return template.Render(model, member => member.Name);
+    }
+
+    public object? ParseAndEvaluate(string text, object model)
+    {
+        // In case of Scriban, call ParseAndRender.
+        return ParseAndRender(text, model);
+    }
+}

src/WireMock.Net.Minimal/Transformers/Scriban/ScribanContextFactory.cs

@@ -0,0 +1,24 @@
+// Copyright © WireMock.Net
+
+using WireMock.Handlers;
+using WireMock.Types;
+using Stef.Validation;
+
+namespace WireMock.Transformers.Scriban;
+
+internal class ScribanContextFactory : ITransformerContextFactory
+{
+    private readonly IFileSystemHandler _fileSystemHandler;
+    private readonly TransformerType _transformerType;
+
+    public ScribanContextFactory(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
+    {
+        _fileSystemHandler = Guard.NotNull(fileSystemHandler);
+        _transformerType = Guard.Condition(transformerType, t => t is TransformerType.Scriban or TransformerType.ScribanDotLiquid);
+    }
+
+    public ITransformerContext Create()
+    {
+        return new ScribanContext(_fileSystemHandler, _transformerType);
+    }
+}

src/WireMock.Net.Minimal/Transformers/Scriban/WireMockListAccessor.cs

@@ -0,0 +1,71 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+using Scriban;
+using Scriban.Parsing;
+using Scriban.Runtime;
+
+namespace WireMock.Transformers.Scriban
+{
+    internal class WireMockListAccessor : IListAccessor, IObjectAccessor
+    {
+        #region IListAccessor
+        public int GetLength(TemplateContext context, SourceSpan span, object target)
+        {
+            throw new NotImplementedException();
+        }
+
+        public object GetValue(TemplateContext context, SourceSpan span, object target, int index)
+        {
+            return target.ToString();
+        }
+
+        public void SetValue(TemplateContext context, SourceSpan span, object target, int index, object value)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+
+        #region IObjectAccessor
+        public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool HasIndexer => throw new NotImplementedException();
+
+        public Type IndexType => throw new NotImplementedException();
+        #endregion
+    }
+}

src/WireMock.Net.Minimal/Transformers/Scriban/WireMockTemplateContext.cs

@@ -0,0 +1,17 @@
+// Copyright © WireMock.Net
+
+using Scriban;
+using Scriban.Runtime;
+using WireMock.Types;
+
+namespace WireMock.Transformers.Scriban;
+
+internal class WireMockTemplateContext : TemplateContext
+{
+    protected override IObjectAccessor GetMemberAccessorImpl(object target)
+    {
+        return target?.GetType().GetGenericTypeDefinition() == typeof(WireMockList<>) ?
+            new WireMockListAccessor() :
+            base.GetMemberAccessorImpl(target);
+    }
+}

src/WireMock.Net.Minimal/Transformers/TransformModel.cs

@@ -0,0 +1,17 @@
+// Copyright © WireMock.Net
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace WireMock.Transformers;
+
+[SuppressMessage("ReSharper", "InconsistentNaming")]
+internal struct TransformModel
+{
+    public IMapping mapping { get; set; }
+
+    public IRequestMessage request { get; set; }
+
+    public IResponseMessage? response { get; set; }
+
+    public object data { get; set; }
+}

src/WireMock.Net.Minimal/Transformers/Transformer.cs

@@ -0,0 +1,370 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HandlebarsDotNet.Helpers.Models;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Stef.Validation;
+using WireMock.Settings;
+using WireMock.Types;
+using WireMock.Util;
+
+namespace WireMock.Transformers;
+
+internal class Transformer : ITransformer
+{
+    private readonly JsonSerializer _jsonSerializer;
+    private readonly ITransformerContextFactory _factory;
+
+    public Transformer(WireMockServerSettings settings, ITransformerContextFactory factory)
+    {
+        _factory = Guard.NotNull(factory);
+
+        _jsonSerializer = new JsonSerializer
+        {
+            Culture = Guard.NotNull(settings).Culture
+        };
+    }
+
+    public IBodyData? TransformBody(
+        IMapping mapping,
+        IRequestMessage originalRequestMessage,
+        IResponseMessage originalResponseMessage,
+        IBodyData? bodyData,
+        ReplaceNodeOptions options)
+    {
+        var (transformerContext, model) = Create(mapping, originalRequestMessage, originalResponseMessage);
+
+        IBodyData? newBodyData = null;
+        if (bodyData?.DetectedBodyType != null)
+        {
+            newBodyData = TransformBodyData(transformerContext, options, model, bodyData, false);
+        }
+
+        return newBodyData;
+    }
+
+    public IDictionary<string, WireMockList<string>> TransformHeaders(
+        IMapping mapping,
+        IRequestMessage originalRequestMessage,
+        IResponseMessage originalResponseMessage,
+        IDictionary<string, WireMockList<string>>? headers
+    )
+    {
+        var (transformerContext, model) = Create(mapping, originalRequestMessage, originalResponseMessage);
+
+        return TransformHeaders(transformerContext, model, headers);
+    }
+
+    public string TransformString(
+        IMapping mapping,
+        IRequestMessage originalRequestMessage,
+        IResponseMessage originalResponseMessage,
+        string? value
+    )
+    {
+        if (value is null)
+        {
+            return string.Empty;
+        }
+
+        var (transformerContext, model) = Create(mapping, originalRequestMessage, originalResponseMessage);
+        return transformerContext.ParseAndRender(value, model);
+    }
+
+    public ResponseMessage Transform(IMapping mapping, IRequestMessage requestMessage, IResponseMessage original, bool useTransformerForBodyAsFile, ReplaceNodeOptions options)
+    {
+        var responseMessage = new ResponseMessage();
+
+        var (transformerContext, model) = Create(mapping, requestMessage, null);
+
+        if (original.BodyData?.DetectedBodyType != null)
+        {
+            responseMessage.BodyData = TransformBodyData(transformerContext, options, model, original.BodyData, useTransformerForBodyAsFile);
+
+            if (original.BodyData.DetectedBodyType is BodyType.String or BodyType.FormUrlEncoded)
+            {
+                responseMessage.BodyOriginal = original.BodyData.BodyAsString;
+            }
+        }
+
+        responseMessage.FaultType = original.FaultType;
+        responseMessage.FaultPercentage = original.FaultPercentage;
+
+        responseMessage.Headers = TransformHeaders(transformerContext, model, original.Headers);
+        responseMessage.TrailingHeaders = TransformHeaders(transformerContext, model, original.TrailingHeaders);
+
+        responseMessage.StatusCode = original.StatusCode switch
+        {
+            int statusCodeAsInteger => statusCodeAsInteger,
+            string statusCodeAsString => transformerContext.ParseAndRender(statusCodeAsString, model),
+            _ => responseMessage.StatusCode
+        };
+
+        return responseMessage;
+    }
+
+    private (ITransformerContext TransformerContext, TransformModel Model) Create(IMapping mapping, IRequestMessage request, IResponseMessage? response)
+    {
+        return (_factory.Create(), new TransformModel
+        {
+            mapping = mapping,
+            request = request,
+            response = response,
+            data = mapping.Data ?? new { }
+        });
+    }
+
+    private IBodyData? TransformBodyData(ITransformerContext transformerContext, ReplaceNodeOptions options, TransformModel model, IBodyData original, bool useTransformerForBodyAsFile)
+    {
+        switch (original.DetectedBodyType)
+        {
+            case BodyType.Json:
+            case BodyType.ProtoBuf:
+                return TransformBodyAsJson(transformerContext, options, model, original);
+
+            case BodyType.File:
+                return TransformBodyAsFile(transformerContext, model, original, useTransformerForBodyAsFile);
+
+            case BodyType.String or BodyType.FormUrlEncoded:
+                return TransformBodyAsString(transformerContext, model, original);
+
+            default:
+                return null;
+        }
+    }
+
+    private static IDictionary<string, WireMockList<string>> TransformHeaders(ITransformerContext transformerContext, TransformModel model, IDictionary<string, WireMockList<string>>? original)
+    {
+        if (original == null)
+        {
+            return new Dictionary<string, WireMockList<string>>();
+        }
+
+        var newHeaders = new Dictionary<string, WireMockList<string>>();
+        foreach (var header in original)
+        {
+            var headerKey = transformerContext.ParseAndRender(header.Key, model);
+            var templateHeaderValues = header.Value.Select(text => transformerContext.ParseAndRender(text, model)).ToArray();
+
+            newHeaders.Add(headerKey, new WireMockList<string>(templateHeaderValues));
+        }
+
+        return newHeaders;
+    }
+
+    private IBodyData TransformBodyAsJson(ITransformerContext transformerContext, ReplaceNodeOptions options, object model, IBodyData original)
+    {
+        JToken? jToken = null;
+        switch (original.BodyAsJson)
+        {
+            case JObject bodyAsJObject:
+                jToken = bodyAsJObject.DeepClone();
+                WalkNode(transformerContext, options, jToken, model);
+                break;
+
+            case JArray bodyAsJArray:
+                jToken = bodyAsJArray.DeepClone();
+                WalkNode(transformerContext, options, jToken, model);
+                break;
+
+            case Array bodyAsArray:
+                jToken = JArray.FromObject(bodyAsArray, _jsonSerializer);
+                WalkNode(transformerContext, options, jToken, model);
+                break;
+
+            case string bodyAsString:
+                jToken = ReplaceSingleNode(transformerContext, options, bodyAsString, model);
+                break;
+
+            case not null:
+                jToken = JObject.FromObject(original.BodyAsJson, _jsonSerializer);
+                WalkNode(transformerContext, options, jToken, model);
+                break;
+        }
+
+        return new BodyData
+        {
+            Encoding = original.Encoding,
+            DetectedBodyType = original.DetectedBodyType,
+            DetectedBodyTypeFromContentType = original.DetectedBodyTypeFromContentType,
+            ProtoDefinition = original.ProtoDefinition,
+            ProtoBufMessageType = original.ProtoBufMessageType,
+            BodyAsJson = jToken
+        };
+    }
+
+    private JToken ReplaceSingleNode(ITransformerContext transformerContext, ReplaceNodeOptions options, string stringValue, object model)
+    {
+        var transformedString = transformerContext.ParseAndRender(stringValue, model);
+
+        if (!string.Equals(stringValue, transformedString))
+        {
+            const string property = "_";
+            JObject dummy = JObject.Parse($"{{ \"{property}\": null }}");
+            if (dummy[property] == null)
+            {
+                // TODO: check if just returning null is fine
+                return string.Empty;
+            }
+
+            JToken node = dummy[property]!;
+
+            ReplaceNodeValue(options, node, transformedString);
+
+            return dummy[property]!;
+        }
+
+        return stringValue;
+    }
+
+    private void WalkNode(ITransformerContext transformerContext, ReplaceNodeOptions options, JToken node, object model)
+    {
+        switch (node.Type)
+        {
+            case JTokenType.Object:
+                // In case of Object, loop all children. Do a ToArray() to avoid `Collection was modified` exceptions.
+                foreach (var child in node.Children<JProperty>().ToArray())
+                {
+                    WalkNode(transformerContext, options, child.Value, model);
+                }
+                break;
+
+            case JTokenType.Array:
+                // In case of Array, loop all items. Do a ToArray() to avoid `Collection was modified` exceptions.
+                foreach (var child in node.Children().ToArray())
+                {
+                    WalkNode(transformerContext, options, child, model);
+                }
+                break;
+
+            case JTokenType.String:
+                // In case of string, try to transform the value.
+                var stringValue = node.Value<string>();
+                if (string.IsNullOrEmpty(stringValue))
+                {
+                    return;
+                }
+
+                var transformed = transformerContext.ParseAndEvaluate(stringValue!, model);
+                if (!Equals(stringValue, transformed))
+                {
+                    ReplaceNodeValue(options, node, transformed);
+                }
+                break;
+        }
+    }
+
+    // ReSharper disable once UnusedParameter.Local
+    private void ReplaceNodeValue(ReplaceNodeOptions options, JToken node, object? transformedValue)
+    {
+        switch (transformedValue)
+        {
+            case JValue jValue:
+                node.Replace(jValue);
+                return;
+
+            case string transformedString:
+                var (isConvertedFromString, convertedValueFromString) = TryConvert(options, transformedString);
+                if (isConvertedFromString)
+                {
+                    node.Replace(JToken.FromObject(convertedValueFromString, _jsonSerializer));
+                }
+                else
+                {
+                    node.Replace(ParseAsJObject(transformedString));
+                }
+                break;
+
+            case WireMockList<string> strings:
+                switch (strings.Count)
+                {
+                    case 1:
+                        node.Replace(ParseAsJObject(strings[0]));
+                        return;
+
+                    case > 1:
+                        node.Replace(JToken.FromObject(strings.ToArray(), _jsonSerializer));
+                        return;
+                }
+                break;
+
+            case { }:
+                var (isConverted, convertedValue) = TryConvert(options, transformedValue);
+                if (isConverted)
+                {
+                    node.Replace(JToken.FromObject(convertedValue, _jsonSerializer));
+                }
+                return;
+
+            default: // It's null, skip it. Maybe remove it ?
+                return;
+        }
+    }
+
+    private static JToken ParseAsJObject(string stringValue)
+    {
+        return JsonUtils.TryParseAsJObject(stringValue, out var parsedAsjObject) ? parsedAsjObject : stringValue;
+    }
+
+    private static (bool IsConverted, object ConvertedValue) TryConvert(ReplaceNodeOptions options, object value)
+    {
+        var valueAsString = value as string;
+
+        if (options == ReplaceNodeOptions.Evaluate)
+        {
+            if (valueAsString != null && WrappedString.TryDecode(valueAsString, out var decoded))
+            {
+                return (true, decoded);
+            }
+
+            return (false, value);
+        }
+
+        if (valueAsString != null)
+        {
+            return WrappedString.TryDecode(valueAsString, out var decoded) ?
+                (true, decoded) :
+                StringUtils.TryConvertToKnownType(valueAsString);
+        }
+
+        return (false, value);
+    }
+
+    private static IBodyData TransformBodyAsString(ITransformerContext transformerContext, object model, IBodyData original)
+    {
+        return new BodyData
+        {
+            Encoding = original.Encoding,
+            DetectedBodyType = original.DetectedBodyType,
+            DetectedBodyTypeFromContentType = original.DetectedBodyTypeFromContentType,
+            BodyAsString = transformerContext.ParseAndRender(original.BodyAsString!, model)
+        };
+    }
+
+    private static IBodyData TransformBodyAsFile(ITransformerContext transformerContext, object model, IBodyData original, bool useTransformerForBodyAsFile)
+    {
+        var transformedBodyAsFilename = transformerContext.ParseAndRender(original.BodyAsFile!, model);
+
+        if (!useTransformerForBodyAsFile)
+        {
+            return new BodyData
+            {
+                DetectedBodyType = original.DetectedBodyType,
+                DetectedBodyTypeFromContentType = original.DetectedBodyTypeFromContentType,
+                BodyAsFile = transformedBodyAsFilename
+            };
+        }
+
+        var text = transformerContext.FileSystemHandler.ReadResponseBodyAsString(transformedBodyAsFilename);
+        return new BodyData
+        {
+            DetectedBodyType = BodyType.String,
+            DetectedBodyTypeFromContentType = original.DetectedBodyTypeFromContentType,
+            BodyAsString = transformerContext.ParseAndRender(text, model),
+            BodyAsFile = transformedBodyAsFilename
+        };
+    }
+}