UML DSL Reference

classDiagram(name = "Domain") {
    // Enumerations
    val status = enumOf(name = "OrderStatus") {
        literal(name = "DRAFT")
        literal(name = "CONFIRMED")
    }

    // Interfaces
    val payable = interfaceOf(name = "Payable") {
        operation(name = "amountDue") { returnType = "BigDecimal" }
    }

    // Classes
    val order = classOf(name = "Order") {
        // Attributes
        attribute(name = "id", type = "UUID") { visibility = Visibility.Private }
        attribute(name = "status", type = status)         // enum val as type
        attribute(name = "total", type = "BigDecimal")

        // Operations
        operation(name = "confirm")
        operation(name = "cancel") {
            visibility = Visibility.Public
            returnType = "Boolean"
        }

        // OCL invariants
        constraint(name = "PositiveTotal", body = "self.total >= 0")
    }

    val customer = classOf(name = "Customer")

    // Relationships
    generalization(child = order, parent = "AbstractEntity")
    realization(client = order, supplier = payable)
    association(source = order, target = customer) {
        sourceMultiplicity = "*"
        targetMultiplicity = "1"
        targetRole = "customer"
    }
}

classDiagram(name = "Order Domain") {
    val order = classOf(name = "Order") { /* ... */ }

    // Anchored to one element (the anchor's builder handle)
    comment(
        text = "Encapsulates the full order lifecycle from placement to fulfillment.",
        firstAnchor = order,
    )

    // Anchored to several elements, or by raw ID instead of a handle
    // comment(text = "...", firstAnchor = order, moreAnchors = arrayOf(subscription))
    // comment(text = "...", anchors = arrayOf("Order", "Subscription"))

    // Free-standing note (no anchors)
    // comment(text = "TODO: model refunds")
}

objectDiagram(name = "Order #42") {
    val order = objectOf(name = "order42", classifier = "Order") {
        slot(name = "status", value = "CONFIRMED")
        slot(name = "total", value = "99.50")
    }
    val item1 = objectOf(name = "item1", classifier = "OrderItem")
    val item2 = objectOf(name = "item2", classifier = "OrderItem")
    link(source = order, target = item1)
    link(source = order, target = item2)
}

componentDiagram(name = "Order service architecture") {
    val orderService = component(name = "OrderService") {
        port(name = "rest")
        operation(name = "placeOrder")
        attribute(name = "config", type = "OrderConfig")
    }

    val paymentService = component(name = "PaymentService") {
        port(name = "rest")
    }

    dependency(source = orderService, target = paymentService) {
        // technology = "REST"   (V1.2)
    }
}

stateDiagram(name = "Order lifecycle") {
    stateMachine(name = "Order") {
        initial(name = "start")
        state(name = "draft")
        state(name = "confirmed")
        state(name = "shipped") { final() }

        // Composite state with substates
        state(name = "processing") {
            initial(name = "picking")
            state(name = "picking")
            state(name = "packing")
            transition(from = "picking", to = "packing", trigger = "packed")
        }

        // Transitions: trigger, guard, effect
        transition(from = "start", to = "draft")
        transition(from = "draft", to = "confirmed", trigger = "confirm",
                   guard = "self.total > 0", effect = "log('confirmed')")
        transition(from = "confirmed", to = "shipped", trigger = "ship")
        transition(from = "confirmed", to = "processing", trigger = "process")
        transition(from = "processing", to = "shipped", trigger = "complete")
    }
}

sequenceDiagram(name = "Place order flow") {
    val customer = lifeline(name = "Customer", classifier = "Customer")
    val service = lifeline(name = "OrderService", classifier = "OrderService")
    val payment = lifeline(name = "PaymentService", classifier = "PaymentService")

    message(from = customer, to = service, label = "placeOrder()")
    message(from = service, to = payment, label = "authorise()")
    message(from = payment, to = service, label = "OK", style = MessageStyle.Reply)
    message(from = service, to = customer, label = "confirmation", style = MessageStyle.Reply)
}

useCaseDiagram(name = "Customer goals") {
    val customer = actor(name = "Customer")
    val staff = actor(name = "Staff")

    val placeOrder = useCase(name = "Place order")
    val payOrder = useCase(name = "Pay order")
    val refundOrder = useCase(name = "Refund order")

    customer.uses(placeOrder)
    customer.uses(payOrder)
    staff.uses(refundOrder)

    placeOrder.includes(payOrder)
    refundOrder.extends(payOrder)
}

packageDiagram(name = "Order Domain Modules") {
    val shared = packageOf(name = "shared") {
        classOf(name = "Money") {
            attribute(name = "amount", type = "BigDecimal")
            attribute(name = "currency", type = "String")
        }
    }

    val shop = packageOf(name = "shop") {
        classOf(name = "Customer")
        classOf(name = "Order")
    }

    val payment = packageOf(name = "payment") {
        classOf(name = "Invoice")
        classOf(name = "Receipt")
    }

    packageImport(client = shop, supplier = shared)
    packageImport(client = payment, supplier = shared)
    packageAccess(client = payment, supplier = shop)
}

deploymentDiagram(name = "Production Cloud Stack") {
    val cluster = executionEnvironment(name = "EKS Cluster") {
        node(name = "Pod: order-service") {
            artifact(name = "orderservice.jar")
            artifact(name = "config.yaml")
        }
    }

    val db = device(name = "PostgreSQL 16") {
        artifact(name = "orders.db")
    }

    val webApp = artifact(name = "webapp.war")
    val edge = node(name = "Edge Gateway")
    deploy(artifact = webApp, node = edge)

    communicationPath(end1 = cluster, end2 = db)
    communicationPath(end1 = edge, end2 = cluster)
}

activityDiagram(name = "Checkout") {
    val start   = initialNode()
    val verify  = action(name = "Verify cart")
    val ok      = decision(name = "valid?")
    val charge  = action(name = "Charge card")
    val confirm = action(name = "Send confirmation")
    val cancel  = action(name = "Notify error")
    val done    = finalNode()

    edge(from = start,   to = verify)
    edge(from = verify,  to = ok)
    edge(from = ok,      to = charge,  guard = "ok")
    edge(from = ok,      to = cancel,  guard = "invalid")
    edge(from = charge,  to = confirm)
    edge(from = confirm, to = done)
    edge(from = cancel,  to = done)
}

communicationDiagram(name = "Place Order — Communication") {
    val ui  = role(classifierName = "Frontend",  roleName = "ui")
    val api = role(classifierName = "Backend",   roleName = "api")
    val db  = role(classifierName = "OrderDB",   roleName = "db")

    message(from = ui,  to = api, label = "submitOrder()")
    message(from = api, to = db,  label = "INSERT order")
    message(from = db,  to = api, label = "ok")
    message(from = api, to = ui,  label = "201 Created")
}

profileDiagram(name = "Java EE Profile") {
    val classMC = metaclass(name = "Class")

    val entity = stereotype(name = "Entity", metaclasses = listOf("Class")) {
        tag(name = "tableName", type = "String")
        tag(name = "schema",    type = "String")
    }

    val valueObject = stereotype(name = "ValueObject", metaclasses = listOf("Class")) {
        tag(name = "immutable", type = "Boolean")
    }

    extension(stereotype = entity,       metaclass = classMC)
    extension(stereotype = valueObject,  metaclass = classMC)
}

timingDiagram(name = "TCP 3-Way Handshake") {
    lifeline(name = "client", states = listOf("CLOSED", "SYN_SENT", "ESTABLISHED")) {
        tick(t = 0, state = "CLOSED")
        tick(t = 1, state = "SYN_SENT")
        tick(t = 3, state = "ESTABLISHED")
    }

    lifeline(name = "server", states = listOf("LISTEN", "SYN_RCVD", "ESTABLISHED")) {
        tick(t = 0, state = "LISTEN")
        tick(t = 2, state = "SYN_RCVD")
        tick(t = 3, state = "ESTABLISHED")
    }
}

interactionOverviewDiagram(name = "Order Process Overview") {
    val start    = initial()
    val login    = interactionRef(name = "Login")
    val search   = interactionRef(name = "Search Catalog")
    val checkout = interactionRef(name = "Checkout")
    val notify   = interactionRef(name = "Ship Notification")
    val end      = final()

    edge(from = start,    to = login)
    edge(from = login,    to = search)
    edge(from = search,   to = checkout)
    edge(from = checkout, to = notify)
    edge(from = notify,   to = end)
}

compositeStructureDiagram(name = "OrderService Internals") {
    val orderApi = interfaceOf(name = "IOrderApi") {
        operation(name = "placeOrder") { returns(typeName = "OrderId") }
    }
    val dbApi = interfaceOf(name = "IPersistence") {
        operation(name = "save")
    }

    lateinit var validator: UmlComponent
    lateinit var persistence: UmlComponent

    val service = component(name = "OrderService") {
        port(name = "api"); provides(iface = orderApi)
        port(name = "db");  requires(iface = dbApi)

        validator = component(name = "Validator") {
            port(name = "in"); port(name = "out")
        }
        persistence = component(name = "Persistence") {
            port(name = "in"); port(name = "db")
            requires(iface = dbApi)
        }
    }

    // connect() lives at the diagram (UmlModelScope) level, not inside the
    // component block — capture the nested components via lateinit above.
    // Delegation: boundary port → inner part port
    connect(end1 = service,     port1 = "api", end2 = validator,   port2 = "in")
    // Assembly: part port → part port
    connect(end1 = validator,   port1 = "out", end2 = persistence, port2 = "in")
    // Delegation out: inner port → boundary port
    connect(end1 = persistence, port1 = "db",  end2 = service,     port2 = "db")
}

umlModel(name = "Order subsystem") {
    classDiagram(name = "Domain") {
        // ...
    }
    componentDiagram(name = "Architecture") {
        // ...
    }
    stateDiagram(name = "Lifecycle") {
        stateMachine(name = "Order") { /* ... */ }
    }
}