26620856256

Committed 29 May 2026 05:53AM UTC coverage: 54.913% (-0.9%) from 55.778%

Build # 26620856256

Build Type

push

github

Committed by

pwelter34

Commit Message

Validate JsonColumn and use fully-qualified types

Coverage Stats

1412 of 3414 branches covered (41.36%)

Branch coverage included in aggregate %.

13 of 102 new or added lines in 4 files covered. (12.75%)

12 existing lines in 3 files now uncovered.

4478 of 7312 relevant lines covered (61.24%)

306.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.78

/src/FluentCommand.Generators/DataReaderFactoryWriter.cs

using System.Text;

using FluentCommand.Generators.Models;

namespace FluentCommand.Generators;

public static class DataReaderFactoryWriter
{
    public static string Generate(EntityClass entityClass)
    {
        if (entityClass == null)
            throw new ArgumentNullException(nameof(entityClass));

        var codeBuilder = new IndentedStringBuilder();
        codeBuilder
            .AppendLine("// <auto-generated />")
            .AppendLine("#nullable enable")
            .AppendLine()
            .AppendLine("using global::FluentCommand.Extensions;")
            .AppendLine();

        codeBuilder
            .Append("namespace ")
            .AppendLine(entityClass.EntityNamespace)
            .AppendLine("{")
            .IncrementIndent();

        codeBuilder
            .AppendLine("/// <summary>")
            .AppendLine("/// Extension methods for FluentCommand")
            .AppendLine("/// </summary>")
            .Append("public static partial class ")
            .Append(entityClass.EntityName)
            .AppendLine("DataReaderExtensions")
            .AppendLine("{")
            .IncrementIndent();

        WriteQueryEntity(codeBuilder, entityClass);

        WriteQuerySingleEntity(codeBuilder, entityClass);

        WriteQueryEntityTask(codeBuilder, entityClass);

        WriteQuerySingleEntityTask(codeBuilder, entityClass);

        WriteEntityFactory(codeBuilder, entityClass);

        codeBuilder
            .DecrementIndent()
            .AppendLine("}") // class
            .DecrementIndent()
            .AppendLine("}"); // namespace

        return codeBuilder.ToString();
    }

    private static void WriteQuerySingleEntityTask(IndentedStringBuilder codeBuilder, EntityClass entity)
    {
        // public static Task<Entity> QuerySingleEntityAsync(this IDataQueryAsync dataQuery) => QuerySingleAsync(dataQuery, EntityFactory);
        codeBuilder
            .AppendLine("/// <summary>")
            .Append("/// Executes the query and returns the first row in the result as a <see cref=\"T:")
            .Append(entity.FullyQualified)
            .AppendLine("\"/> object.")
            .AppendLine("/// </summary>")
            .AppendLine("/// <param name=\"dataQuery\">The <see cref=\"T:FluentCommand.IDataQueryAsync\"/> for this extension method.</param>")
            .AppendLine("/// <param name=\"cancellationToken\">The cancellation instruction.</param>")
            .AppendLine("/// <returns>")
            .Append("/// A instance of <see cref=\"T:")
            .Append(entity.FullyQualified)
            .AppendLine("\"/>  if row exists; otherwise null.")
            .AppendLine("/// </returns>")
            .Append("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"")
            .Append(ThisAssembly.Product)
            .Append("\", \"")
            .Append(ThisAssembly.InformationalVersion)
            .AppendLine("\")]")
            .Append("public static global::System.Threading.Tasks.Task<")
            .Append(entity.FullyQualified)
            .Append("?> QuerySingle")
            .AppendLine("Async<TEntity>(")
            .IncrementIndent()
            .AppendLine("this global::FluentCommand.IDataQueryAsync dataQuery,")
            .AppendLine("global::System.Threading.CancellationToken cancellationToken = default)")
            .Append("where TEntity : ")
            .AppendLine(entity.FullyQualified)
            .DecrementIndent()
            .AppendLine("{")
            .IncrementIndent()
            .Append("return dataQuery.QuerySingleAsync<")
            .Append(entity.FullyQualified)
            .AppendLine(">(")
            .IncrementIndent()
            .Append("factory: ")
            .Append(entity.EntityName)
            .Append("DataReaderExtensions.")
            .Append(entity.EntityName)
            .AppendLine("Factory,")
            .AppendLine("commandBehavior: global::System.Data.CommandBehavior.SequentialAccess |")
            .AppendLine("                 global::System.Data.CommandBehavior.SingleResult |")
            .AppendLine("                 global::System.Data.CommandBehavior.SingleRow,")
            .AppendLine("cancellationToken: cancellationToken);")
            .DecrementIndent()
            .DecrementIndent()
            .AppendLine("}")
            .AppendLine();
    }

    private static void WriteQueryEntityTask(IndentedStringBuilder codeBuilder, EntityClass entity)
    {
        // public static Task<IEnumerable<Entity>> QueryEntityAsync(this IDataQueryAsync dataQuery) => QueryAsync(dataQuery, EntityFactory);
        codeBuilder
            .AppendLine("/// <summary>")
            .Append("/// Executes the command against the connection and converts the results to <see cref=\"T:")
            .Append(entity.FullyQualified)
            .AppendLine("\"/> objects.")
            .AppendLine("/// </summary>")
            .AppendLine("/// <param name=\"dataQuery\">The <see cref=\"T:FluentCommand.IDataQueryAsync\"/> for this extension method.</param>")
            .AppendLine("/// <param name=\"cancellationToken\">The cancellation instruction.</param>")
            .AppendLine("/// <returns>")
            .Append("/// An <see cref=\"T:System.Collections.Generic.IEnumerable`1\" /> of <see cref=\"T:")
            .Append(entity.FullyQualified)
            .AppendLine("\"/> objects.")
            .AppendLine("/// </returns>")
            .Append("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"")
            .Append(ThisAssembly.Product)
            .Append("\", \"")
            .Append(ThisAssembly.InformationalVersion)
            .AppendLine("\")]")
            .Append("public static global::System.Threading.Tasks.Task<global::System.Collections.Generic.IEnumerable<")
            .Append(entity.FullyQualified)
            .AppendLine(">> QueryAsync<TEntity>(")
            .IncrementIndent()
            .AppendLine("this global::FluentCommand.IDataQueryAsync dataQuery,")
            .AppendLine("global::System.Threading.CancellationToken cancellationToken = default)")
            .Append("where TEntity : ")
            .AppendLine(entity.FullyQualified)
            .DecrementIndent()
            .AppendLine("{")
            .IncrementIndent()
            .Append("return dataQuery.QueryAsync<")
            .Append(entity.FullyQualified)
            .AppendLine(">(")
            .IncrementIndent()
            .Append("factory: ")
            .Append(entity.EntityName)
            .Append("DataReaderExtensions.")
            .Append(entity.EntityName)
            .AppendLine("Factory,")
            .AppendLine("commandBehavior: global::System.Data.CommandBehavior.SequentialAccess |")
            .AppendLine("                 global::System.Data.CommandBehavior.SingleResult,")
            .AppendLine("cancellationToken: cancellationToken);")
            .DecrementIndent()
            .DecrementIndent()
            .AppendLine("}")
            .AppendLine();
    }

    private static void WriteQuerySingleEntity(IndentedStringBuilder codeBuilder, EntityClass entity)
    {
        // public static Entity QuerySingleEntity(this IDataQuery dataQuery) => QuerySingle(dataQuery, EntityFactory);
        codeBuilder
            .AppendLine("/// <summary>")
            .Append("/// Executes the query and returns the first row in the result as a <see cref=\"T:")
            .Append(entity.FullyQualified)
            .AppendLine("\"/> object.")
            .AppendLine("/// </summary>")
            .AppendLine("/// <param name=\"dataQuery\">The <see cref=\"T:FluentCommand.IDataQuery\"/> for this extension method.</param>")
            .AppendLine("/// <returns>")
            .Append("/// A instance of <see cref=\"T:")
            .Append(entity.FullyQualified)
            .AppendLine("\"/>  if row exists; otherwise null.")
            .AppendLine("/// </returns>")
            .Append("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"")
            .Append(ThisAssembly.Product)
            .Append("\", \"")
            .Append(ThisAssembly.InformationalVersion)
            .AppendLine("\")]")
            .Append("public static ")
            .Append(entity.FullyQualified)
            .AppendLine("? QuerySingle<TEntity>(")
            .IncrementIndent()
            .AppendLine("this global::FluentCommand.IDataQuery dataQuery)")
            .Append("where TEntity : ")
            .AppendLine(entity.FullyQualified)
            .DecrementIndent()
            .AppendLine("{")
            .IncrementIndent()
            .Append("return dataQuery.QuerySingle<")
            .Append(entity.FullyQualified)
            .AppendLine(">(")
            .IncrementIndent()
            .Append("factory: ")
            .Append(entity.EntityName)
            .Append("DataReaderExtensions.")
            .Append(entity.EntityName)
            .AppendLine("Factory,")
            .AppendLine("commandBehavior: global::System.Data.CommandBehavior.SequentialAccess |")
            .AppendLine("                 global::System.Data.CommandBehavior.SingleResult |")
            .AppendLine("                 global::System.Data.CommandBehavior.SingleRow);")
            .DecrementIndent()
            .DecrementIndent()
            .AppendLine("}")
            .AppendLine();
    }

    private static void WriteQueryEntity(IndentedStringBuilder codeBuilder, EntityClass entity)
    {
        // public static IEnumerable<Entity> QueryEntity(this IDataQuery dataQuery) => Query(dataQuery, EntityFactory);
        codeBuilder
            .AppendLine("/// <summary>")
            .Append("/// Executes the command against the connection and converts the results to <see cref=\"T:")
            .Append(entity.FullyQualified)
            .AppendLine("\"/> objects.")
            .AppendLine("/// </summary>")
            .AppendLine("/// <param name=\"dataQuery\">The <see cref=\"T:FluentCommand.IDataQuery\"/> for this extension method.</param>")
            .AppendLine("/// <returns>")
            .Append("/// An <see cref=\"T:System.Collections.Generic.IEnumerable`1\" /> of <see cref=\"T:")
            .Append(entity.FullyQualified)
            .AppendLine("\"/> objects.")
            .AppendLine("/// </returns>")
            .Append("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"")
            .Append(ThisAssembly.Product)
            .Append("\", \"")
            .Append(ThisAssembly.InformationalVersion)
            .AppendLine("\")]")
            .Append("public static global::System.Collections.Generic.IEnumerable<")
            .Append(entity.FullyQualified)
            .AppendLine("> Query<TEntity>(")
            .IncrementIndent()
            .AppendLine("this global::FluentCommand.IDataQuery dataQuery)")
            .Append("where TEntity : ")
            .AppendLine(entity.FullyQualified)
            .DecrementIndent()
            .AppendLine("{")
            .IncrementIndent()
            .Append("return dataQuery.Query<")
            .Append(entity.FullyQualified)
            .AppendLine(">(")
            .IncrementIndent()
            .Append("factory: ")
            .Append(entity.EntityName)
            .Append("DataReaderExtensions.")
            .Append(entity.EntityName)
            .AppendLine("Factory,")
            .AppendLine("commandBehavior: global::System.Data.CommandBehavior.SequentialAccess |")
            .AppendLine("                 global::System.Data.CommandBehavior.SingleResult);")
            .DecrementIndent()
            .DecrementIndent()
            .AppendLine("}")
            .AppendLine();
    }

    private static void WriteEntityFactory(IndentedStringBuilder codeBuilder, EntityClass entity)
    {
        codeBuilder
            .AppendLine("/// <summary>")
            .Append("/// A factory for creating <see cref=\"T:")
            .Append(entity.FullyQualified)
            .AppendLine("\"/> objects from the current row in the specified <paramref name=\"dataRecord\"/>.")
            .AppendLine("/// </summary>")
            .AppendLine("/// <param name=\"dataRecord\">The open <see cref=\"T:System.Data.IDataReader\"/> to get the object from.</param>")
            .AppendLine("/// <returns>")
            .Append("/// A instance of <see cref=\"")
            .Append(entity.FullyQualified)
            .AppendLine("\"/>  having property names set that match the field names in the <paramref name=\"dataRecord\"/>.")
            .AppendLine("/// </returns>")
            .Append("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"")
            .Append(ThisAssembly.Product)
            .Append("\", \"")
            .Append(ThisAssembly.InformationalVersion)
            .AppendLine("\")]")
            .Append("public static ")
            .Append(entity.FullyQualified)
            .Append(" ")
            .Append(entity.EntityName)
            .AppendLine("Factory(this global::System.Data.IDataReader dataRecord)")
            .AppendLine("{")
            .IncrementIndent()
            .AppendLine("if (dataRecord == null)")
            .IncrementIndent()
            .AppendLine("throw new global::System.ArgumentNullException(nameof(dataRecord));")
            .DecrementIndent()
            .AppendLine();

        foreach (var entityProperty in entity.Properties)
        {
            if (entityProperty.IsNotMapped)
                continue;

            var aliasType = GetAliasMap(entityProperty.PropertyType);
            var fieldName = CamelCase(entityProperty.PropertyName);

            // local variable
            codeBuilder
                .Append(aliasType)
                .Append(" v_")
                .Append(fieldName)
                .Append(" = default")
                .AppendIf("!", _ => !entityProperty.IsNullable)
                .AppendLine(";");
        }

        codeBuilder
            .AppendLine()
            .AppendLine("for (var __index = 0; __index < dataRecord.FieldCount; __index++)")
            .AppendLine("{")
            .IncrementIndent()
            .AppendLine("if (dataRecord.IsDBNull(__index))")
            .IncrementIndent()
            .AppendLine(" continue;")
            .DecrementIndent()
            .AppendLine();

        codeBuilder
            .AppendLine("var __name = dataRecord.GetName(__index);")
            .AppendLine("switch (__name)")
            .AppendLine("{")
            .IncrementIndent();

        foreach (var entityProperty in entity.Properties)
        {
            if (entityProperty.IsNotMapped)
                continue;

            var fieldName = CamelCase(entityProperty.PropertyName);

            codeBuilder
                .Append("case \"")
                .Append(entityProperty.ColumnName)
                .AppendLine("\":");

            if (entityProperty.IsJsonColumn)
            {
                var jsonReaderName = entityProperty.IsNullable
                    ? "GetFromJson"
                    : "GetRequiredFromJson";

                codeBuilder
                    .IncrementIndent()
                    .Append("v_")
                    .Append(fieldName)
                    .Append(" = dataRecord.")
                    .Append(jsonReaderName)
                    .Append("<")
                    .Append(entityProperty.PropertyType)
                    .Append(">(__index")
                    .Append(GetJsonReaderArgument(entityProperty))
                    .AppendLine(");")
                    .AppendLine("break;")
                    .DecrementIndent();
            }
            else if (entityProperty.IsEnum)
            {
                WriteEnumColumnReader(codeBuilder, entityProperty, fieldName);
            }
            else if (string.IsNullOrEmpty(entityProperty.ConverterName))
            {
                var readerName = GetReaderName(entityProperty);

                codeBuilder
                    .IncrementIndent()
                    .Append("v_")
                    .Append(fieldName)
                    .Append(" = dataRecord.")
                    .Append(readerName)
                    .AppendLine("(__index);")
                    .AppendLine("break;")
                    .DecrementIndent();
            }
            else
            {
                // create converter via singleton helper
                codeBuilder
                    .IncrementIndent()
                    .Append("var c_")
                    .Append(fieldName)
                    .Append(" = global::FluentCommand.Internal.Singleton<")
                    .Append(entityProperty.ConverterName!)
                    .AppendLine(">.Current")
                    .IncrementIndent()
                    .Append("as global::FluentCommand.IDataFieldConverter<")
                    .Append(entityProperty.PropertyType)
                    .AppendLine(">;")
                    .DecrementIndent()
                    .AppendLine();

                // read via converter instance
                codeBuilder
                    .Append("v_")
                    .Append(fieldName)
                    .Append(" = c_")
                    .Append(fieldName)
                    .AppendLine(".ReadValue(dataRecord, __index);")
                    .AppendLine("break;")
                    .DecrementIndent();
            }
        }

        codeBuilder
            .DecrementIndent()
            .AppendLine("}") // switch
            .DecrementIndent()
            .AppendLine("}") // for
            .AppendLine();

        if (entity.InitializationMode == InitializationMode.Constructor)
            WriteReturnConstructor(codeBuilder, entity);
        else
            WriteReturnObjectInitializer(codeBuilder, entity);

        codeBuilder
            .DecrementIndent()
            .AppendLine("}") // method
            .AppendLine();
    }

    private static void WriteEnumColumnReader(IndentedStringBuilder codeBuilder, EntityProperty entityProperty, string fieldName)
    {
        codeBuilder
            .IncrementIndent()
            .Append("v_")
            .Append(fieldName)
            .Append(" = ")
            .Append(GetEnumReadExpression(entityProperty))
            .AppendLine(";")
            .AppendLine("break;")
            .DecrementIndent();
    }

    private static string GetEnumReadExpression(EntityProperty entityProperty)
    {
        var underlyingType = GetAliasMap(entityProperty.EnumUnderlyingType ?? "int");

        if (entityProperty.IsNullableEnum)
            return $"({entityProperty.PropertyType})dataRecord.GetValue<{underlyingType}?>(__index)";

        return $"({entityProperty.PropertyType})dataRecord.{GetReaderName(underlyingType)}(__index)";
    }

    private static void WriteReturnConstructor(IndentedStringBuilder codeBuilder, EntityClass entity)
    {
        codeBuilder
            .Append("return new ")
            .Append(entity.FullyQualified)
            .AppendLine("(")
            .IncrementIndent();

        var mappedProperties = entity.Properties.Where(p => !p.IsNotMapped).ToList();
        var index = 0;
        var count = mappedProperties.Count;

        foreach (var entityProperty in mappedProperties)
        {
            var fieldName = CamelCase(entityProperty.PropertyName);
            codeBuilder
                .Append(entityProperty.ParameterName!)
                .Append(": ")
                .Append(" v_")
                .Append(fieldName);

            if (++index == count)
                codeBuilder.AppendLine();
            else
                codeBuilder.AppendLine(",");
        }

        codeBuilder
            .DecrementIndent()
            .AppendLine(");"); // new
    }

    private static void WriteReturnObjectInitializer(IndentedStringBuilder codeBuilder, EntityClass entity)
    {
        codeBuilder
            .Append("return new ")
            .AppendLine(entity.FullyQualified)
            .AppendLine("{")
            .IncrementIndent();

        var mappedProperties = entity.Properties.Where(p => !p.IsNotMapped).ToList();
        var index = 0;
        var count = mappedProperties.Count;

        foreach (var entityProperty in mappedProperties)
        {
            var fieldName = CamelCase(entityProperty.PropertyName);
            codeBuilder
                .Append(entityProperty.PropertyName)
                .Append(" = ")
                .Append(" v_")
                .Append(fieldName);

            if (++index == count)
                codeBuilder.AppendLine();
            else
                codeBuilder.AppendLine(",");
        }

        codeBuilder
            .DecrementIndent()
            .AppendLine("};"); // new
    }

    private static string GetAliasMap(string type)
    {
        return type switch
        {
            "global::System.Boolean" => "bool",
            "global::System.Byte" => "byte",
            "global::System.Byte[]" => "byte[]",
            "global::System.Char" => "char",
            "global::System.Decimal" => "decimal",
            "global::System.Double" => "double",
            "global::System.Single" => "float",
            "global::System.Int16" => "short",
            "global::System.Int32" => "int",
            "global::System.Int64" => "long",
            "global::System.String" => "string",
            "System.Boolean" => "bool",
            "System.Byte" => "byte",
            "System.Byte[]" => "byte[]",
            "System.Char" => "char",
            "System.Decimal" => "decimal",
            "System.Double" => "double",
            "System.Single" => "float",
            "System.Int16" => "short",
            "System.Int32" => "int",
            "System.Int64" => "long",
            "System.String" => "string",
            _ => type,
        };
    }

    private static string GetReaderName(EntityProperty entityProperty)
    {
        var propertyType = entityProperty.IsNullable
            ? entityProperty.PropertyType.Substring(0, entityProperty.PropertyType.Length - 1)
            : entityProperty.PropertyType;

        return GetReaderName(propertyType);
    }

    private static string GetReaderName(string propertyType)
    {
        return propertyType switch
        {
            "global::System.Boolean" => "GetBoolean",
            "global::System.Byte" => "GetByte",
            "global::System.Byte[]" => "GetBytes",
            "global::System.Char" => "GetChar",
            "global::System.DateTime" => "GetDateTime",
            "global::System.DateTimeOffset" => "GetDateTimeOffset",
            "global::System.Decimal" => "GetDecimal",
            "global::System.Double" => "GetDouble",
            "global::System.Guid" => "GetGuid",
            "global::System.Single" => "GetFloat",
            "global::System.Int16" => "GetInt16",
            "global::System.Int32" => "GetInt32",
            "global::System.Int64" => "GetInt64",
            "global::System.String" => "GetString",
            "System.Boolean" => "GetBoolean",
            "System.Byte" => "GetByte",
            "System.Byte[]" => "GetBytes",
            "System.Char" => "GetChar",
            "System.DateTime" => "GetDateTime",
            "System.DateTimeOffset" => "GetDateTimeOffset",
            "System.Decimal" => "GetDecimal",
            "System.Double" => "GetDouble",
            "System.Guid" => "GetGuid",
            "System.Single" => "GetFloat",
            "System.Int16" => "GetInt16",
            "System.Int32" => "GetInt32",
            "System.Int64" => "GetInt64",
            "System.String" => "GetString",
            "bool" => "GetBoolean",
            "byte" => "GetByte",
            "byte[]" => "GetBytes",
            "char" => "GetChar",
            "decimal" => "GetDecimal",
            "double" => "GetDouble",
            "float" => "GetFloat",
            "short" => "GetInt16",
            "int" => "GetInt32",
            "long" => "GetInt64",
            "string" => "GetString",
            // special handling for ConcurrencyToken to use GetBytes
            "global::FluentCommand.ConcurrencyToken" => "GetBytes",
            "FluentCommand.ConcurrencyToken" => "GetBytes",
            // fallback to GetValue<T> for unsupported types
            _ => $"GetValue<{propertyType}>"
        };
    }

    private static string GetJsonReaderArgument(EntityProperty entityProperty)
    {
        if (!string.IsNullOrEmpty(entityProperty.JsonOptionsProviderName))
            return $", {entityProperty.JsonOptionsProviderName}.Options";

        if (!string.IsNullOrEmpty(entityProperty.JsonContextName)
            && !string.IsNullOrEmpty(entityProperty.JsonTypeInfoPropertyName))
        {
            return $", {entityProperty.JsonContextName}.Default.{entityProperty.JsonTypeInfoPropertyName}";
        }

        return string.Empty;
    }

    private static string CamelCase(string name)
    {
        if (string.IsNullOrEmpty(name) || !char.IsUpper(name[0]))
            return name;

        char[] chars = name.ToCharArray();
        FixCasing(chars);

        return new string(chars);
    }

    private static void FixCasing(Span<char> chars)
    {
        for (int i = 0; i < chars.Length; i++)
        {
            if (i == 1 && !char.IsUpper(chars[i]))
                break;

            bool hasNext = (i + 1 < chars.Length);

            // Stop when next char is already lowercase.
            if (i > 0 && hasNext && !char.IsUpper(chars[i + 1]))
            {
                // If the next char is a space, lowercase current char before exiting.
                if (chars[i + 1] == ' ')
                    chars[i] = char.ToLowerInvariant(chars[i]);

                break;
            }

            chars[i] = char.ToLowerInvariant(chars[i]);
        }
    }
}

loresoft / FluentCommand / 26620856256

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous