Value conversion finalized.

src/Squidex.Domain.Apps.Core.Operations/ConvertContent/ContentConverter.cs

@@ -7,53 +7,51 @@
 
 using System;
 using System.Collections.Generic;
-using Newtonsoft.Json.Linq;
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Domain.Apps.Core.Schemas;
 using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Core.ConvertContent
 {
-    public delegate ContentFieldData FieldConverter(ContentFieldData data, IRootField field);
-
-    public delegate JToken ValueConverter(JToken value, IRootField field);
-
     public static class ContentConverter
     {
-        public static NamedContentData ToNameModel(this IdContentData content, Schema schema, params FieldConverter[] converters)
+        private static readonly Func<IRootField, string> KeyNameResolver = f => f.Name;
+        private static readonly Func<IRootField, long> KeyIdResolver = f => f.Id;
+
+        public static NamedContentData ConvertId2Name(this IdContentData content, Schema schema, params FieldConverter[] converters)
         {
             Guard.NotNull(schema, nameof(schema));
 
             var result = new NamedContentData(content.Count);
 
-            return ConvertInternal(content, result, schema.FieldsById, x => x.Name, converters);
+            return ConvertInternal(content, result, schema.FieldsById, KeyNameResolver, converters);
         }
 
-        public static IdContentData ToIdModel(this NamedContentData content, Schema schema, params FieldConverter[] converters)
+        public static IdContentData ConvertId2Id(this IdContentData content, Schema schema, params FieldConverter[] converters)
         {
             Guard.NotNull(schema, nameof(schema));
 
             var result = new IdContentData(content.Count);
 
-            return ConvertInternal(content, result, schema.FieldsByName, x => x.Id, converters);
+            return ConvertInternal(content, result, schema.FieldsById, KeyIdResolver, converters);
         }
 
-        public static IdContentData Convert(this IdContentData content, Schema schema, params FieldConverter[] converters)
+        public static NamedContentData ConvertName2Name(this NamedContentData content, Schema schema, params FieldConverter[] converters)
         {
             Guard.NotNull(schema, nameof(schema));
 
-            var result = new IdContentData(content.Count);
+            var result = new NamedContentData(content.Count);
 
-            return ConvertInternal(content, result, schema.FieldsById, x => x.Id, converters);
+            return ConvertInternal(content, result, schema.FieldsByName, KeyNameResolver, converters);
         }
 
-        public static NamedContentData Convert(this NamedContentData content, Schema schema, params FieldConverter[] converters)
+        public static IdContentData ConvertName2Id(this NamedContentData content, Schema schema, params FieldConverter[] converters)
         {
             Guard.NotNull(schema, nameof(schema));
 
-            var result = new NamedContentData(content.Count);
+            var result = new IdContentData(content.Count);
 
-            return ConvertInternal(content, result, schema.FieldsByName, x => x.Name, converters);
+            return ConvertInternal(content, result, schema.FieldsByName, KeyIdResolver, converters);
         }
 
         private static TDict2 ConvertInternal<TKey1, TKey2, TDict1, TDict2>(
@@ -71,24 +69,24 @@ namespace Squidex.Domain.Apps.Core.ConvertContent
                     continue;
                 }
 
-                var fieldValue = fieldKvp.Value;
+                var newvalue = fieldKvp.Value;
 
                 if (converters != null)
                 {
                     foreach (var converter in converters)
                     {
-                        fieldValue = converter(fieldValue, field);
+                        newvalue = converter(newvalue, field);
 
-                        if (fieldValue == null)
+                        if (newvalue == null)
                         {
                             break;
                         }
                     }
                 }
 
-                if (fieldValue != null)
+                if (newvalue != null)
                 {
-                    target.Add(targetKey(field), fieldValue);
+                    target.Add(targetKey(field), newvalue);
                 }
             }
 

src/Squidex.Domain.Apps.Core.Operations/ConvertContent/FieldConverters.cs

@@ -20,8 +20,17 @@ using Squidex.Infrastructure.Json;
 
 namespace Squidex.Domain.Apps.Core.ConvertContent
 {
+    public delegate ContentFieldData FieldConverter(ContentFieldData data, IRootField field);
+
     public static class FieldConverters
     {
+        private static readonly Func<IField, string> KeyNameResolver = f => f.Name;
+        private static readonly Func<IField, string> KeyIdResolver = f => f.Id.ToString();
+        private static readonly Func<IArrayField, string, IField> FieldByIdResolver =
+            (f, k) => long.TryParse(k, out var id) ? f.FieldsById.GetOrDefault(id) : null;
+        private static readonly Func<IArrayField, string, IField> FieldByNameResolver =
+            (f, k) => f.FieldsByName.GetOrDefault(k);
+
         public static FieldConverter ExcludeHidden()
         {
             return (data, field) =>
@@ -195,7 +204,30 @@ namespace Squidex.Domain.Apps.Core.ConvertContent
             };
         }
 
-        private static FieldConverter ForNested(params ValueConverter[] converters)
+        public static FieldConverter ForNestedName2Name(params ValueConverter[] converters)
+        {
+            return ForNested(FieldByNameResolver, KeyNameResolver, converters);
+        }
+
+        public static FieldConverter ForNestedName2Id(params ValueConverter[] converters)
+        {
+            return ForNested(FieldByNameResolver, KeyIdResolver, converters);
+        }
+
+        public static FieldConverter ForNestedId2Name(params ValueConverter[] converters)
+        {
+            return ForNested(FieldByIdResolver, KeyNameResolver, converters);
+        }
+
+        public static FieldConverter ForNestedId2Id(params ValueConverter[] converters)
+        {
+            return ForNested(FieldByIdResolver, KeyIdResolver, converters);
+        }
+
+        private static FieldConverter ForNested(
+            Func<IArrayField, string, IField> fieldResolver,
+            Func<IField, string> keyResolver,
+            params ValueConverter[] converters)
         {
             return (data, field) =>
             {
@@ -213,33 +245,38 @@ namespace Squidex.Domain.Apps.Core.ConvertContent
 
                                     foreach (var kvp in item)
                                     {
-                                        if (!arrayField.FieldsByName.TryGetValue(kvp.Key, out var nestedField))
+                                        var nestedField = fieldResolver(arrayField, kvp.Key);
+
+                                        if (nestedField == null)
                                         {
                                             continue;
                                         }
 
                                         var newValue = kvp.Value;
 
+                                        var isUnset = false;
+
                                         if (converters != null)
                                         {
                                             foreach (var converter in converters)
                                             {
-                                                newValue = converter(newValue, field);
+                                                newValue = converter(newValue, nestedField);
 
                                                 if (ReferenceEquals(newValue, Value.Unset))
                                                 {
+                                                    isUnset = true;
                                                     break;
                                                 }
                                             }
                                         }
 
-                                        if (!ReferenceEquals(newValue, Value.Unset))
+                                        if (!isUnset)
                                         {
-                                            result.Add(field.Id.ToString(), newValue);
+                                            result.Add(keyResolver(nestedField), newValue);
                                         }
                                     }
 
-                                    jArray[i] = item;
+                                    jArray[i] = result;
                                 }
                             }
                         }
@@ -262,6 +299,8 @@ namespace Squidex.Domain.Apps.Core.ConvertContent
                     {
                         var newValue = partition.Value;
 
+                        var isUnset = false;
+
                         if (converters != null)
                         {
                             foreach (var converter in converters)
@@ -270,19 +309,20 @@ namespace Squidex.Domain.Apps.Core.ConvertContent
 
                                 if (ReferenceEquals(newValue, Value.Unset))
                                 {
+                                    isUnset = true;
                                     break;
                                 }
                             }
                         }
 
-                        if (result != null || !ReferenceEquals(newValue, partition.Value))
+                        if (result != null || isUnset || !ReferenceEquals(newValue, partition.Value))
                         {
                             if (result == null)
                             {
                                 result = new ContentFieldData();
                             }
 
-                            if (!ReferenceEquals(newValue, Value.Unset))
+                            if (!isUnset)
                             {
                                 result.Add(partition.Key, newValue);
                             }

src/Squidex.Domain.Apps.Core.Operations/ConvertContent/Value.cs

@@ -9,12 +9,8 @@ using Newtonsoft.Json.Linq;
 
 namespace Squidex.Domain.Apps.Core.ConvertContent
 {
-    public sealed class Value
+    public static class Value
     {
         public static readonly JToken Unset = JValue.CreateUndefined();
-
-        private Value()
-        {
-        }
     }
 }

src/Squidex.Domain.Apps.Core.Operations/ConvertContent/ValueConverters.cs

@@ -14,6 +14,8 @@ using Squidex.Infrastructure.Json;
 
 namespace Squidex.Domain.Apps.Core.ConvertContent
 {
+    public delegate JToken ValueConverter(JToken value, IField field);
+
     public static class ValueConverters
     {
         public static ValueConverter DecodeJson()
@@ -50,7 +52,7 @@ namespace Squidex.Domain.Apps.Core.ConvertContent
         {
             return (value, field) =>
             {
-                return field.IsHidden ? null : value;
+                return field.IsHidden ? Value.Unset : value;
             };
         }
 
@@ -58,16 +60,18 @@ namespace Squidex.Domain.Apps.Core.ConvertContent
         {
             return (value, field) =>
             {
-                try
+                if (value.IsNull())
                 {
-                    if (!value.IsNull())
+                    return value;
+                }
+
+                try
                 {
                     JsonValueConverter.ConvertValue(field, value);
                 }
-                }
                 catch
                 {
-                    return null;
+                    return Value.Unset;
                 }
 
                 return value;

src/Squidex.Domain.Apps.Core.Operations/ExtractReferenceIds/FieldReferencesConverter.cs → src/Squidex.Domain.Apps.Core.Operations/ExtractReferenceIds/ValueReferencesConverter.cs

@@ -12,7 +12,7 @@ using Squidex.Infrastructure.Json;
 
 namespace Squidex.Domain.Apps.Core.ExtractReferenceIds
 {
-    public static class FieldReferencesConverter
+    public static class ValueReferencesConverter
     {
         public static ValueConverter CleanReferences(IEnumerable<Guid> deletedReferencedIds)
         {

src/Squidex.Domain.Apps.Entities.MongoDb/Contents/Extensions.cs

@@ -28,12 +28,22 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
 
         public static NamedContentData FromMongoModel(this IdContentData result, Schema schema, List<Guid> deletedIds)
         {
-            return result.ToNameModel(schema, FieldConverters.DecodeJson(), FieldReferencesConverter.CleanReferences(deletedIds));
+            return result.ConvertId2Name(schema,
+                FieldConverters.ForValues(
+                    ValueConverters.DecodeJson(),
+                    ValueReferencesConverter.CleanReferences(deletedIds)),
+                FieldConverters.ForNestedId2Name(
+                    ValueConverters.DecodeJson(),
+                    ValueReferencesConverter.CleanReferences(deletedIds)));
         }
 
         public static IdContentData ToMongoModel(this NamedContentData result, Schema schema)
         {
-            return result.ToIdModel(schema, FieldConverters.EncodeJson());
+            return result.ConvertName2Id(schema,
+                FieldConverters.ForValues(
+                    ValueConverters.EncodeJson()),
+                FieldConverters.ForNestedId2Name(
+                    ValueConverters.EncodeJson()));
         }
 
         public static string ToFullText<T>(this ContentData<T> data)

src/Squidex.Domain.Apps.Entities/Contents/ContentQueryService.cs

@@ -154,12 +154,12 @@ namespace Squidex.Domain.Apps.Entities.Contents
                             result.Data = scriptEngine.Transform(new ScriptContext { User = context.User, Data = content.Data, ContentId = content.Id }, scriptText);
                         }
 
-                        result.Data = result.Data.Convert(schema.SchemaDef, converters);
+                        result.Data = result.Data.ConvertName2Name(schema.SchemaDef, converters);
                     }
 
                     if (result.DataDraft != null)
                     {
-                        result.DataDraft = result.DataDraft.Convert(schema.SchemaDef, converters);
+                        result.DataDraft = result.DataDraft.ConvertName2Name(schema.SchemaDef, converters);
                     }
 
                     yield return result;
@@ -172,11 +172,13 @@ namespace Squidex.Domain.Apps.Entities.Contents
             if (!context.IsFrontendClient)
             {
                 yield return FieldConverters.ExcludeHidden();
+                yield return FieldConverters.ForNestedName2Name(ValueConverters.ExcludeHidden());
             }
 
             if (checkType)
             {
                 yield return FieldConverters.ExcludeChangedTypes();
+                yield return FieldConverters.ForNestedName2Name(ValueConverters.ExcludeChangedTypes());
             }
 
             yield return FieldConverters.ResolveInvariant(context.App.LanguagesConfig);

src/Squidex.Domain.Apps.Entities/Contents/GraphQL/GraphQLModel.cs

@@ -28,7 +28,6 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 {
     public sealed class GraphQLModel : IGraphModel
     {
-        private readonly QueryGraphTypeVisitor schemaTypes;
         private readonly Dictionary<ISchemaEntity, ContentGraphType> contentTypes = new Dictionary<ISchemaEntity, ContentGraphType>();
         private readonly Dictionary<ISchemaEntity, ContentDataGraphType> contentDataTypes = new Dictionary<ISchemaEntity, ContentDataGraphType>();
         private readonly Dictionary<Guid, ISchemaEntity> schemasById;

tests/Squidex.Domain.Apps.Core.Tests/Operations/ConvertContent/ContentConversionTests.cs

@@ -30,7 +30,7 @@ namespace Squidex.Domain.Apps.Core.Operations.ConvertContent
         }
 
         [Fact]
-        public void Should_convert_to_id_model()
+        public void Should_convert_name_to_id()
         {
             var input =
                 new NamedContentData()
@@ -44,7 +44,7 @@ namespace Squidex.Domain.Apps.Core.Operations.ConvertContent
                         new ContentFieldData()
                             .AddValue("iv", 2));
 
-            var actual = input.ToIdModel(schema, (data, field) => field.Name == "field2" ? null : data);
+            var actual = input.ConvertName2Id(schema, (data, field) => field.Name == "field2" ? null : data);
 
             var expected =
                 new IdContentData()
@@ -56,25 +56,25 @@ namespace Squidex.Domain.Apps.Core.Operations.ConvertContent
         }
 
         [Fact]
-        public void Should_convert_id_model()
+        public void Should_convert_name_to_name()
         {
             var input =
-               new IdContentData()
-                    .AddField(1,
+                new NamedContentData()
+                    .AddField("field1",
                         new ContentFieldData()
                             .AddValue("en", "EN"))
-                    .AddField(2,
+                    .AddField("field2",
                         new ContentFieldData()
                             .AddValue("iv", 1))
-                    .AddField(99,
+                    .AddField("invalid",
                         new ContentFieldData()
                             .AddValue("iv", 2));
 
-            var actual = input.Convert(schema, (data, field) => field.Name == "field2" ? null : data);
+            var actual = input.ConvertName2Name(schema, (data, field) => field.Name == "field2" ? null : data);
 
             var expected =
-                new IdContentData()
-                    .AddField(1,
+                new NamedContentData()
+                    .AddField("field1",
                         new ContentFieldData()
                             .AddValue("en", "EN"));
 
@@ -82,7 +82,7 @@ namespace Squidex.Domain.Apps.Core.Operations.ConvertContent
         }
 
         [Fact]
-        public void Should_convert_to_name_model()
+        public void Should_convert_id_to_id()
         {
             var input =
                 new IdContentData()
@@ -96,11 +96,11 @@ namespace Squidex.Domain.Apps.Core.Operations.ConvertContent
                         new ContentFieldData()
                             .AddValue("iv", 2));
 
-            var actual = input.ToNameModel(schema, (data, field) => field.Name == "field2" ? null : data);
+            var actual = input.ConvertId2Id(schema, (data, field) => field.Name == "field2" ? null : data);
 
             var expected =
-                new NamedContentData()
-                    .AddField("field1",
+                new IdContentData()
+                    .AddField(1,
                         new ContentFieldData()
                             .AddValue("en", "EN"));
 
@@ -108,21 +108,21 @@ namespace Squidex.Domain.Apps.Core.Operations.ConvertContent
         }
 
         [Fact]
-        public void Should_convert_name_model()
+        public void Should_convert_id_to_name()
         {
             var input =
-               new NamedContentData()
-                    .AddField("field1",
+                new IdContentData()
+                    .AddField(1,
                         new ContentFieldData()
                             .AddValue("en", "EN"))
-                    .AddField("field2",
+                    .AddField(2,
                         new ContentFieldData()
                             .AddValue("iv", 1))
-                    .AddField("invalid",
+                    .AddField(99,
                         new ContentFieldData()
                             .AddValue("iv", 2));
 
-            var actual = input.Convert(schema, (data, field) => field.Name == "field2" ? null : data);
+            var actual = input.ConvertId2Name(schema, (data, field) => field.Name == "field2" ? null : data);
 
             var expected =
                 new NamedContentData()

tests/Squidex.Domain.Apps.Core.Tests/Operations/ConvertContent/FieldConvertersTests.cs

@@ -19,69 +19,150 @@ namespace Squidex.Domain.Apps.Core.Operations.ConvertContent
     public class FieldConvertersTests
     {
         private readonly LanguagesConfig languagesConfig = LanguagesConfig.Build(Language.EN, Language.DE);
+        private readonly RootField<NumberFieldProperties> numberField = Fields.Number(1, "1", Partitioning.Invariant);
         private readonly RootField<StringFieldProperties> stringLanguageField = Fields.String(1, "1", Partitioning.Language);
         private readonly RootField<StringFieldProperties> stringInvariantField = Fields.String(1, "1", Partitioning.Invariant);
         private readonly RootField<JsonFieldProperties> jsonField = Fields.Json(1, "1", Partitioning.Invariant);
-        private readonly RootField<NumberFieldProperties> numberField = Fields.Number(1, "1", Partitioning.Invariant);
+        private readonly RootField<ArrayFieldProperties> arrayField = Fields.Array(1, "1", Partitioning.Invariant,
+            Fields.Number(1, "field1"),
+            Fields.Number(2, "field2").Hide());
 
         [Fact]
-        public void Should_encode_json_value()
+        public void Should_return_same_object_for_value_conversion_if_nothing_converted()
         {
-            var source = JToken.FromObject(new { Value = 1 });
+            var input =
+                new ContentFieldData()
+                    .AddValue("iv", new JObject());
 
-            var result = ValueConverters.EncodeJson()(source, jsonField);
+            var actual = FieldConverters.ForValues()(input, stringInvariantField);
 
-            Assert.True(result.Type == JTokenType.String);
+            Assert.Same(input, actual);
         }
 
         [Fact]
-        public void Should_return_same_value_if_encoding_null_value()
+        public void Should_filter_for_value_conversion()
         {
-            var source = JValue.CreateNull();
+            var input =
+                new ContentFieldData()
+                    .AddValue("iv", new JObject());
 
-            var result = ValueConverters.EncodeJson()(source, jsonField);
+            var actual = FieldConverters.ForValues((f, i) => Value.Unset)(input, stringInvariantField);
 
-            Assert.Same(source, result);
+            var expected = new ContentFieldData();
+
+            Assert.Equal(expected, actual);
         }
 
         [Fact]
-        public void Should_return_same_value_if_encoding_non_json_field()
+        public void Should_convert_for_value_conversion()
         {
-            var source = (JToken)"NO-JSON";
+            var input =
+                new ContentFieldData()
+                    .AddValue("iv", new JObject());
 
-            var result = ValueConverters.EncodeJson()(source, stringLanguageField);
+            var actual = FieldConverters.ForValues(ValueConverters.EncodeJson())(input, jsonField);
 
-            Assert.Same(source, result);
+            var expected =
+                new ContentFieldData()
+                    .AddValue("iv", "e30=");
+
+            Assert.Equal(expected, actual);
         }
 
         [Fact]
-        public void Should_decode_json_values()
+        public void Should_convert_name_to_id()
         {
-            var source = "e30=";
+            var input =
+                new ContentFieldData()
+                    .AddValue("iv",
+                        new JArray(
+                            new JObject(
+                                new JProperty("field1", 100),
+                                new JProperty("field2", 200),
+                                new JProperty("invalid", 300))));
 
-            var result = ValueConverters.DecodeJson()(source, jsonField);
+            var actual = FieldConverters.ForNestedName2Id(ValueConverters.ExcludeHidden())(input, arrayField);
 
-            Assert.True(result is JObject);
+            var expected =
+               new ContentFieldData()
+                    .AddValue("iv",
+                        new JArray(
+                            new JObject(
+                                new JProperty("1", 100))));
+
+            Assert.Equal(expected, actual);
         }
 
         [Fact]
-        public void Should_return_same_value_if_decoding_null_value()
+        public void Should_convert_name_to_name()
         {
-            var source = JValue.CreateNull();
+            var input =
+                new ContentFieldData()
+                    .AddValue("iv",
+                        new JArray(
+                            new JObject(
+                                new JProperty("field1", 100),
+                                new JProperty("field2", 200),
+                                new JProperty("invalid", 300))));
 
-            var result = ValueConverters.DecodeJson()(source, jsonField);
+            var actual = FieldConverters.ForNestedName2Name(ValueConverters.ExcludeHidden())(input, arrayField);
 
-            Assert.Same(source, result);
+            var expected =
+                new ContentFieldData()
+                    .AddValue("iv",
+                        new JArray(
+                            new JObject(
+                                new JProperty("field1", 100))));
+
+            Assert.Equal(expected, actual);
         }
 
         [Fact]
-        public void Should_return_same_value_if_decoding_non_json_field()
+        public void Should_convert_id_to_id()
         {
-            var source = JValue.CreateNull();
+            var input =
+               new ContentFieldData()
+                    .AddValue("iv",
+                        new JArray(
+                            new JObject(
+                                new JProperty("1", 100),
+                                new JProperty("2", 200),
+                                new JProperty("99", 300))));
 
-            var result = ValueConverters.EncodeJson()(source, stringLanguageField);
+            var actual = FieldConverters.ForNestedId2Id(ValueConverters.ExcludeHidden())(input, arrayField);
 
-            Assert.Same(source, result);
+            var expected =
+               new ContentFieldData()
+                    .AddValue("iv",
+                        new JArray(
+                            new JObject(
+                                new JProperty("1", 100))));
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Should_convert_id_to_name()
+        {
+            var input =
+               new ContentFieldData()
+                    .AddValue("iv",
+                        new JArray(
+                            new JObject(
+                                new JProperty("1", 100),
+                                new JProperty("2", 200),
+                                new JProperty("99", 300))));
+
+            var actual = FieldConverters.ForNestedId2Name(ValueConverters.ExcludeHidden())(input, arrayField);
+
+            var expected =
+               new ContentFieldData()
+                    .AddValue("iv",
+                        new JArray(
+                            new JObject(
+                                new JProperty("field1", 100))));
+
+            Assert.Equal(expected, actual);
         }
 
         [Fact]

tests/Squidex.Domain.Apps.Core.Tests/Operations/ConvertContent/ValueConvertersTests.cs

@@ -0,0 +1,104 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using Newtonsoft.Json.Linq;
+using Squidex.Domain.Apps.Core.Apps;
+using Squidex.Domain.Apps.Core.ConvertContent;
+using Squidex.Domain.Apps.Core.Schemas;
+using Squidex.Infrastructure;
+using Xunit;
+
+namespace Squidex.Domain.Apps.Core.Operations.ConvertContent
+{
+    public class ValueConvertersTests
+    {
+        private readonly LanguagesConfig languagesConfig = LanguagesConfig.Build(Language.EN, Language.DE);
+        private readonly RootField<StringFieldProperties> stringField = Fields.String(1, "1", Partitioning.Invariant);
+        private readonly RootField<JsonFieldProperties> jsonField = Fields.Json(1, "1", Partitioning.Invariant);
+        private readonly RootField<NumberFieldProperties> numberField = Fields.Number(1, "1", Partitioning.Invariant);
+
+        [Fact]
+        public void Should_encode_json_value()
+        {
+            var source = new JObject();
+
+            var result = ValueConverters.EncodeJson()(source, jsonField);
+
+            Assert.Equal("e30=", result);
+        }
+
+        [Fact]
+        public void Should_return_same_value_if_encoding_null_value()
+        {
+            var source = JValue.CreateNull();
+
+            var result = ValueConverters.EncodeJson()(source, jsonField);
+
+            Assert.Same(source, result);
+        }
+
+        [Fact]
+        public void Should_return_same_value_if_encoding_non_json_field()
+        {
+            var source = (JToken)"NO-JSON";
+
+            var result = ValueConverters.EncodeJson()(source, stringField);
+
+            Assert.Same(source, result);
+        }
+
+        [Fact]
+        public void Should_decode_json_values()
+        {
+            var source = "e30=";
+
+            var result = ValueConverters.DecodeJson()(source, jsonField);
+
+            Assert.Equal(new JObject(), result);
+        }
+
+        [Fact]
+        public void Should_return_same_value_if_decoding_null_value()
+        {
+            var source = JValue.CreateNull();
+
+            var result = ValueConverters.DecodeJson()(source, jsonField);
+
+            Assert.Same(source, result);
+        }
+
+        [Fact]
+        public void Should_return_same_value_if_decoding_non_json_field()
+        {
+            var source = JValue.CreateNull();
+
+            var result = ValueConverters.EncodeJson()(source, stringField);
+
+            Assert.Same(source, result);
+        }
+
+        [Fact]
+        public void Should_return_unset_if_field_hidden()
+        {
+            var source = 123;
+
+            var result = ValueConverters.ExcludeHidden()(source, stringField.Hide());
+
+            Assert.Same(Value.Unset, result);
+        }
+
+        [Fact]
+        public void Should_return_unset_if_field_has_wrong_type()
+        {
+            var source = "invalid";
+
+            var result = ValueConverters.ExcludeChangedTypes()(source, numberField);
+
+            Assert.Same(Value.Unset, result);
+        }
+    }
+}

tests/Squidex.Domain.Apps.Core.Tests/Operations/ExtractReferenceIds/ReferenceExtractionTests.cs

@@ -69,9 +69,9 @@ namespace Squidex.Domain.Apps.Core.Operations.ExtractReferenceIds
                         new ContentFieldData()
                             .AddValue("iv", new JArray(id1.ToString(), id2.ToString())));
 
-            var converter = FieldConverters.ForValues(FieldReferencesConverter.CleanReferences(new[] { id2 }));
+            var converter = FieldConverters.ForValues(ValueReferencesConverter.CleanReferences(new[] { id2 }));
 
-            var actual = input.Convert(schema, converter);
+            var actual = input.ConvertId2Id(schema, converter);
 
             var cleanedValue = (JArray)actual[5]["iv"];
 

tests/Squidex.Domain.Apps.Core.Tests/TestData.cs

@@ -89,7 +89,7 @@ namespace Squidex.Domain.Apps.Core
                 .AddTags(112, "root-tags", Partitioning.Language,
                     new TagsFieldProperties())
                 .Update(new SchemaProperties { Hints = "The User" })
-                .UpdateField(107, f => f.Hide())
+                .UpdateField(104, f => f.Hide())
                 .UpdateField(108, f => f.Lock())
                 .UpdateField(109, f => f.Disable());