Deutsch

English

Deutsch

English

Erscheinungsbild

Get Started ​

Jardis ist eine visuelle Plattform: Du modellierst deine Domäne im Designer (jardis ui) (Bounded Contexts, Aggregates, Rules und Prozesse) und ein Klick auf Build erzeugt den vollständigen DDD-Platform-Code. Kein Boilerplate, kein Template-Copy-Paste. In fünf Schritten von der Domäne zur laufenden Anwendung.

Step 1 — Designer starten ​

bash
jardis ui

Der Designer öffnet im Browser (127.0.0.1). Du siehst das Workspace-Board: Subdomains → Bounded Contexts → Aggregates → Rules → Prozesse. Ein Workspace ist ein Verzeichnis und enthält eine oder mehrere Domänen.

Das Workspace-Board: Subdomains, Bounded Contexts, Aggregates, Rules und Prozesse

Step 2 — Schema ​

Jardis arbeitet auf einem Tabellen-Schema. Zwei Wege dorthin:

  • Import — ein bestehendes Datenbank-Schema in den Designer importieren. Jardis liest Tabellen, Spalten, Primär-/Fremdschlüssel und Indexe.
  • Authoring — das Schema kooperativ mit KI-gestützten Skills aus einer Klartext-Idee erstellen, validiert gegen das Jardis-Format.

Step 3 — Design ​

Im Aggregate-Designer legst du fest, welche Tabellen zu einem Aggregate gehören, welche Entität die Root ist und wie sie zusammenhängen, als ER-Diagramm mit PK/FK/UK-Markierungen.

Aggregate-Designer: ER-Modell mit Root-Entität und Beziehungen

Im Process-Designer modellierst du fachliche Abläufe als Knoten-Graph mit onSuccess/onFail-Routing, Cross-BC-Reads, Rule-Ketten und Event-Verkündung. Strategisch verwaltest du das Ganze über Steckbrief, Glossar, Governance/Rules und die Context-Map (Strategic / Tactical / Reconcile, inkl. Drift-Check deklarierter vs. realer Kopplung).

Step 4 — Build ​

Ein Klick auf Build im Designer erzeugt den vollständigen Code-Baum pro Aggregate: Entities, Commands, Queries, Events, Repository-Pipeline, API-Contracts und den generierten {Domain}Context. Den erzeugten Code siehst du direkt im Code-Tab.

Der Code-Tab zeigt den generierten Aggregate-Baum

Headless via MCP

Denselben Ablauf (Workspace → Schema → Design → Build) steuerst du ohne Browser über den MCP-Server: jardis mcp. Tools sind Aktionen, Resources sind Read-only. Ideal für AI-Agents.

Step 5 — Im Projekt nutzen ​

Der erzeugte Code läuft auf der Core-Laufzeit: Kernel liefert den Koffer, App die HTTP-Delivery.

bash
composer require jardiscore/kernel jardiscore/app
php
use JardisCore\Kernel\Bootstrap\BuildDomainKernelFromEnv;

// 1. Koffer aus der .env-Kaskade bauen
$kernel = (new BuildDomainKernelFromEnv())(__DIR__ . '/..');

// 2. Generierte Domain-Fassade instanziieren (Builder-Output)
$sales = new \Ecommerce\Sales($kernel);

// 3. Lesen über die BC-Read-Fassade …
$order = $sales->order()->getOrderById($orderId);

// … Schreiben über einen Prozess
$result = $sales->process(PlaceOrder::class, [
    'customerId' => $customerId,
    'items'      => $items,
]);

Jede Operation liefert eine DomainResponse: App übersetzt sie in den {status, data, errors, meta}-Envelope. Details zur Verdrahtung in eine Transportschicht: die Platform-Skills (platform-usage).

Step 6 — Fachlogik ​

Die DDD-Plattform steht. Ab hier arbeitest du die fachlichen Anforderungen in die generierten Command/Handler/Action-Stubs ein: Value Objects, Business Rules, Domain Services, Workflows. KI-gestützt, auf einer Architektur, die von Anfang an richtig gebaut ist.