Support named enums

[HarvieKrumpet]

Just as newtonsoft and system.text have converters to handle

   [JsonStringEnumConverter]
   [StringEnumConverter]
   public enum MyEnum {text, refusal, toolresponse, image, url, filename, b64, block, application, html }

Magic should also support this functionality, as add/removing, or even re-arranging an enum in code will silently break the database versions. by converting to string names. we not only get a solid error if there is a mismatch during deserialization. re-arranging/adding/deleting enums will not break the database.

It just seems to me you can "peek" into the reflection and look for these system.text or newtownsoft attributes without needing to add more MagicAttributes to trigger a converter.

[Ard2025]

Will be picked up after #105 where we are going to discuss how to handle annotations going forward

[HarvieKrumpet]

I was worried also if what I do in normal serialization would be different than what I want to happen in the database. I have found the major use case is communicating these structures in/out of SignalR for Server/Client Comms is where everything happens. Keep in mind that SignalR is totally reliant on system.text annotations. So it turns out I ended up 1 to 1 on jsonignore with magicnotmapped. The jsonconstructor always points to a parameterless constructor, or it points to a constructor that doubles as parameterless. Because of SignalR, blazor developers typically stick with system.text and not newtonsoft. I didn't run into any use case that was an exception to this rule. My overriding reason I am pushing for this is I am predicting your going to support serialization converters eventually. which you would have to "duplicate" all the system.text annotators functionality anyway.

Another massive feature would be to enable the "ignore default or null" feature. since you separate keys from the body of the table, the body of the record can be shrunk to just what is different from a default construction. The issue is that system.text.json "does not" actually read the autoset {get;set} properties. so it does not know the default values thus cannot tweeze out default values. it needs help to know this via [DefaultValue(value)]

To fix this, we can incorporate the standard componentModel attribute....
[DefaultValue(SeedGeneration.seedrandom)] // can be read by the serializer
public SeedGeneration SeedType {get;set;} = SeedGeneration.seedrandom; // this default will not be read by the system.text.json
[DefaultValue(5.0f)] // can be read by the serializer
public float mirostat_tau { get; set; } = 5.0f;// this default will not be read by the system.text.json

With this, a optimizing serializer can reliably know what the default value is supposed to be, knowing the default constructor will fill this in. and write a reduced table body.

if you have thousands of records (like me) that are mostly at default values, this can be a huge win in speed and diskspace.
what might take up a gig, now takes up a few 100k

as an aside, newtownsoft "does" read the autoset variables but at a huge overhead cost and complexity.

in essense, the system.text.json "ignore default values" doesn't work out of the box because of the autoset issue. But with a custom converter. this works perfectly. I will include my converter here in case you find value in it. this would have to be a built-in converter into magicdb to make this happen.

        public class DefaultValueIgnoringConverter<T> : JsonConverter<T> {
            private readonly T _defaultValue;

            public DefaultValueIgnoringConverter(T defaultValue) {
                _defaultValue = defaultValue;
            }

            public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
                JsonSerializer.Deserialize<T>(ref reader, options)!;

            public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options) {
                if (Equals(value, _defaultValue)) {
                    // Skip writing this property by doing nothing
                    return;
                }
                JsonSerializer.Serialize(writer, value, options);
            }
        }

        public class DefaultValueResolver : DefaultJsonTypeInfoResolver {
            public override JsonTypeInfo GetTypeInfo(Type type, JsonSerializerOptions options) {
                var typeInfo = base.GetTypeInfo(type, options);

                if (typeInfo.Kind == JsonTypeInfoKind.Object) {
                    foreach (var prop in typeInfo.Properties) {
                        // Get the property info from the declaring type
                        var propertyInfo = type.GetProperty(prop.Name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
                        if (propertyInfo != null) {
                            var defaultValueAttr = propertyInfo.GetCustomAttribute<DefaultValueAttribute>();
                            if (defaultValueAttr != null) {
                                // Create and assign a converter that knows the default value
                                var converterType = typeof(DefaultValueIgnoringConverter<>).MakeGenericType(propertyInfo.PropertyType);
                                var converter = (JsonConverter)Activator.CreateInstance(converterType, defaultValueAttr.Value)!;
                                prop.CustomConverter = converter;
                            }
                        }
                    }
                }

                return typeInfo;
            }
        }

I have been using this in SignalR comms to save to a server connected to a file system. but now with magicdb, there is no reason to touch the server for fileio.

[Ard2025]

I think the annotation below would be sufficient for your usecase while waiting for some better solution @HarvieKrumpet

[JsonConverter(typeof(JsonStringEnumConverter<Permissions>))]
public enum Permissions
{
    None = 0,
    CanRead = 1,
    CanWrite = 1 << 1,
    CanDelete = 1 << 2,
    CanCreate = 1 << 3
}