Json Array to ND Json converter

• always increase readability by using access modifiers.
• Convert is misleading, as you're reading and writing files, so describing the function is very useful to understand what's going on inside the method.
• File.Delete(targetPath) is not necessary, as you can use FileMode.Create which will create the file if not exists, and override it if exists.
• use JsonException instead of InvalidOperationException.
• Utf8JsonWriter should be outside the loop and it's Disposable.
• You can always use File.ReadAllText or File.WriteAllText instead for small to medium size files, as shortcut, however, for large files, I advice you using the proper streaming techniques (such as reading file in chunks) instead of reading everything.
• use the proper naming for objects such as memoryStream instead of jsonObjectWithoutIndentation and jsonWriter instead of jsonObjectStreamWriter to avoid confusion.
• use Flush() and Reset() all together with the Utf8JsonWriter to reset the stream. using Flush() alone would case some exceptions, as there are some stream counters are only reset by the Reset() and not by Flush() like BytesCommitted.
• you can use FileStream with Utf8JsonWriter directly, you just need to add a new line after each write.

here is a revised version that would shows the above points :

public static class JsonArrayToNDJsonConverter
{
    private static JsonWriterOptions _jsonWriterOptionNoIndentation = new() { Indented = false };
   
    private static byte[] _newLineBytes = Encoding.UTF8.GetBytes(Environment.NewLine);

    public static void ConvertJsonArrayFileToNDArray(string sourcePath, string targetPath)
    {
        if (string.IsNullOrWhiteSpace(sourcePath))
            throw new ArgumentNullException(nameof(sourcePath));
        
        if (string.IsNullOrWhiteSpace(targetPath))
            throw new ArgumentNullException(nameof(targetPath));

        if(!File.Exists(sourcePath))
            throw new FileNotFoundException("Source file is not found");
    
        var sourceFile = File.ReadAllText(sourcePath);

        var jsonDocument = JsonDocument.Parse(sourceFile);
        
        if (jsonDocument.RootElement.ValueKind != JsonValueKind.Array)
            throw new JsonException("Json Array must be the source");

        using var targetFileStream = new FileStream(targetPath, FileMode.Create);
        using var jsonWriter = new Utf8JsonWriter(targetFileStream, _jsonWriterOptionNoIndentation);
        foreach (var jsonObject in jsonDocument.RootElement.EnumerateArray())
        {
            jsonObject.WriteTo(jsonWriter);
            jsonWriter.Flush();
            jsonWriter.Reset();
            targetFileStream.Write(_newLineBytes);
        }
    }
}

Though I think it would be better if we just divide all that into several methods and inside one helper class, to give a better reusability. Also, it would be more effective if we just target JsonArray instead of JsonDocument as you're only targting the JsonArray so using JsonNode and JsonArray would be enough. Example :

public static class JsonHelper
{
    public static JsonNode LoadFromFile(string filePath)
    {
        if (string.IsNullOrWhiteSpace(filePath))
            throw new ArgumentNullException(nameof(filePath));

        if (!File.Exists(filePath))
            throw new FileNotFoundException("Source file is not found");

        return JsonNode.Parse(File.ReadAllText(filePath));
    }

    public static void WriteToFileAsNDArray(this JsonArray jsonArray, string targetPath)
    {
        if (jsonArray == null)
            throw new ArgumentNullException(nameof(jsonArray));

        if (string.IsNullOrWhiteSpace(targetPath))
            throw new ArgumentNullException(nameof(targetPath));

        // remember this will throw an exception if the target path is invalid
        // if the file already exists, it'll be overridden
        File.WriteAllText(targetPath, jsonArray.ToJsonStringNDArray());
    }
}

public static class JsonNodeExtensions
{
    private static JsonWriterOptions _jsonWriterOptionNoIndentation = new() { Indented = false };
    
    private static byte[] _newLineBytes = Encoding.UTF8.GetBytes(Environment.NewLine);

    public static string ToJsonStringNDArray(this JsonArray jsonArray)
    {
        if (jsonArray == null)
            throw new ArgumentNullException(nameof(jsonArray));

        using var memoryStream = new MemoryStream();
        using var jsonWriter = new Utf8JsonWriter(memoryStream, _jsonWriterOptionNoIndentation);
        foreach (var jsonObject in jsonArray)
        {
            jsonObject.WriteTo(jsonWriter);
            jsonWriter.Flush();
            jsonWriter.Reset();
            memoryStream.Write(_newLineBytes);
        }

        return Encoding.UTF8.GetString(memoryStream.ToArray());
    }
}

Usage :

JsonHelper.LoadFromFile(sourcePath)
          .AsArray()
          .WriteToFileAsNDArray(targetPath);