JsonPathLib 1.0.0

🔍 JsonPath for System.Text.Json

Eine leichtgewichtige, leistungsstarke JsonPath-Engine für .NET basierend auf System.Text.Json.
Diese Bibliothek ermöglicht eine XPath-ähnliche Abfragesyntax für JSON-Daten ohne externe Abhängigkeiten – inkl. komplexer Filter, rekursiver Suche und direktem Zugriff auf die JSON-Wurzel.

🚀 Features

• Objekt- und Array-Navigation:
  Zugriff auf Eigenschaften (z. B. user.name) und Array-Indizes (z. B. [0], [*]).

• Filter mit Vergleichsoperatoren:
  Unterstützt Filterausdrücke wie [?(@.id == 5)], [?(@.age > 18)], [?(@.score <= 3.5)] und mehr.

• Logische Operatoren und Gruppierungen:
  Kombination von Bedingungen mit && (UND) und || (ODER) sowie Gruppierung mittels Klammern
  z. B.: [?((@.id > 10 && @.name == "Test") || @.id == 5)].

• Rekursive Suche:
  Durch das ..-Symbol können Sie rekursiv nach allen Vorkommen eines Schlüssels suchen, z. B.: $..name.

• $-Wurzelunterstützung:
  Mit dem $-Symbol beginnt die Abfrage immer an der Wurzel des JSON-Dokuments – egal ob Wurzel ein Array oder ein Objekt ist.
  Beispielsweise: $.user.name oder $..id.

• Flexibilität bei der Wurzel:
  Die JSON-Struktur muss nicht mehr zwingend in einem Array liegen – sowohl JSON-Objekte als auch Arrays werden unterstützt.

📦 Installation

Fügen Sie die Quelldateien (z. B. JsonPath.cs, ExpressionParser.cs, ExpressionNode.cs und zugehörige Hilfsklassen) Ihrem Projekt hinzu.
Stellen Sie sicher, dass Ihr Projekt System.Text.Json referenziert (standardmäßig ab .NET Core 3.0 verfügbar).

🧭 Syntaxunterstützung

💡 Beispiel

Angenommen, Sie haben folgende JSON-Daten:

Beispiel 1: JSON als Objekt

{
  "user": {
    "id": 15,
    "name": "Alice",
    "details": {
      "email": "alice@example.com",
      "name": "Alice A."
    }
  }
}

Abfragen:

• Zugriff auf den Namen des Benutzers:

  var result = jp.Select("$.user.name");
  

• Rekursive Suche nach allen "name"-Feldern:

  var result = jp.Select("$..name");
  

Beispiel 2: JSON als Array

[
  { "id": 5, "name": "A" },
  { "id": 15, "name": "Test" },
  { "id": 20, "name": "X", "flag": "yes" }
]

Abfrage:

var jp = new JsonPath(json);
var result = jp.Select("[?((@.id > 10 && @.name == \"Test\") || @.id == 5)]");

foreach (var item in result)
{
    Console.WriteLine(item);
}

Ergebnis:

• Gibt das Element mit id == 15 && name == "Test" sowie das Element mit id == 5 zurück.

🛠 Architekturüberblick

Die JsonPath-Engine gliedert sich in mehrere Komponenten:

1. Pfadparser (ParsePathSegments):
   Zerlegt den Abfragepfad in einzelne Segmente (Property, Index, Filter, rekursive Suche).
   Unterstützt explizit das $-Symbol und rekursive Segmente, die mit .. beginnen.

2. Filterparser:
   Filterausdrücke (z. B. [?(@.id > 10 && @.name == "Test")]) werden mithilfe eines rekursiven Abwärtsparsers in einen abstrakten Syntaxbaum (AST) übersetzt.
   Dabei kommen spezialisierte AST-Knoten (ConditionNode, AndNode, OrNode) zum Einsatz.

3. Auswertung:

   • Jedes Pfadsegment wird nacheinander auf die aktuelle Menge an JsonElement-Objekten angewendet.
   • Bei Filtersegmenten wird der Ausdruck gegen jedes Element evaluiert.
   • Die rekursive Suche (..) durchläuft alle untergeordneten Objekte und Arrays, um Treffer für den gesuchten Schlüssel zu finden.
   • Das Endergebnis ist eine Liste von JsonElement-Treffern, die der Abfrage entsprechen.

4. Wurzelunterstützung:
   Mit dem $-Symbol kann der Benutzer explizit angeben, dass die Abfrage an der JSON-Wurzel startet – egal ob diese ein Objekt oder ein Array ist.

🔧 Erweiterungsmöglichkeiten

• Weitere Filterfunktionen:
  Unterstützung für Funktionen wie contains(), startsWith() usw.

• Erweiterte Datentyp-Unterstützung:
  Behandlung von null, Booleans und weiteren Datentypen.

• Integration in ein Interface:
  Umsetzung als IJsonQuery-Interface für flexiblere Erweiterungen oder Plug-in-Architekturen.

• CI/CD & UnitTests:
  Aufbau einer vollständigen Testabdeckung und automatisierten Tests (z. B. mit xUnit oder NUnit).