Πώς να διαχειριστείτε σύνθετη επιχειρησιακή λογική

Η σύνθετη επιχειρησιακή λογική μένει διαχειρίσιμη όταν βρίσκεται σε ένα σημείο που μπορεί να ελέγξει μια μηχανή. Γράψτε τους κανόνες μία φορά ως μοντέλο: τι υπάρχει, τι μπορεί να συμβεί, ποιος επιτρέπεται να το κάνει. Κάθε διάγραμμα βγαίνει από αυτό το μοντέλο, και κάθε ερώτηση για τη λογική πηγαίνει πρώτα σε αυτό.

Το άρθρο δείχνει τη μέθοδο με ένα μικρό παράδειγμα έγκρισης τιμολογίων. Το εργαλείο είναι το Appling, μια γλώσσα μοντελοποίησης ανοιχτού κώδικα της οποίας είμαστε χορηγοί και με την οποία αναπτύσσουμε τις εφαρμογές μας. Βρίσκεται σε πρώιμο στάδιο (0.x), έχει άδεια MIT και ήδη λειτουργεί για τα βήματα που ακολουθούν.

Γιατί η επιχειρησιακή λογική ξεφεύγει από τον έλεγχο

Η επιχειρησιακή λογική σπάνια βρίσκεται σε ένα αρχείο. Το πεδίο κατάστασης είναι στο μοντέλο της βάσης, ο έλεγχος δικαιωμάτων σε έναν controller, η προθεσμία σε ένα cron job και ο κανόνας «κρύψε αυτό το κουμπί» στο frontend.

Κάθε κομμάτι στέκει μόνο του. Το σύνολο δεν το βλέπει κανείς.

Έτσι μια απλή ερώτηση, όπως «ποιος εγκρίνει ένα τιμολόγιο και από ποια κατάσταση;», σημαίνει τέσσερα αρχεία και δύο συναδέλφους. Κάθε νέα λειτουργία προσθέτει ένα πέμπτο σημείο.

flowchart LR
    subgraph Scattered["Λογική σκορπισμένη στον κώδικα"]
      direction TB
      A1["models.py<br/>πεδίο κατάστασης"]:::bad
      A2["views.py<br/>έλεγχος δικαιωμάτων"]:::bad
      A3["cron.py<br/>εργασία λήξης"]:::bad
      A4["Invoice.tsx<br/>κανόνας κουμπιού"]:::bad
    end
    subgraph One["Λογική σε ένα μοντέλο"]
      direction TB
      M["billing.appling"]:::good --> V["ελέγχεται"]:::good
      M --> D["σχεδιάζεται"]:::good
      M --> Q["ερωτάται"]:::good
    end
    Scattered --> One
    classDef good fill:#494fdf,stroke:#376cd5,color:#ffffff,stroke-width:2px
    classDef bad fill:#1e293b,stroke:#64748b,color:#f1f5f9,stroke-width:1.5px

Περιγράψτε τη λογική μία φορά, ως μοντέλο

Ένα μοντέλο επιχειρησιακής λογικής καταγράφει τους κανόνες, όχι την υλοποίηση. Τέσσερις ερωτήσεις καλύπτουν τα περισσότερα:

1. Τι υπάρχει; Οντότητες, τα πεδία τους, οι επιτρεπτές τιμές.
2. Τι μπορεί να συμβεί; Ενέργειες, αλλαγές κατάστασης, προγραμματισμένες εργασίες.
3. Ποιος επιτρέπεται; Ρόλοι και πολιτικές.
4. Πώς φτάνει κανείς εκεί; APIs και σελίδες.

Το Appling τα οργανώνει σε πέντε επίπεδα, από το Domain (τι υπάρχει) έως το Experience (πώς φτάνουν οι άνθρωποι εκεί). Οι αναφορές δείχνουν μόνο προς τα κάτω. Αυτός ο ένας κανόνας εμποδίζει ένα μοντέλο που μεγαλώνει να γίνει το ίδιο κουβάρι με τον κώδικα.

Το μοντέλο είναι απλό κείμενο. Ζει στο git, περνά από review και δίνει diffs όπως ο κώδικας.

Οπτικοποιήστε την επιχειρησιακή λογική από το μοντέλο

Ένα διάγραμμα στον πίνακα είναι παλιό την επόμενη μέρα της συνάντησης. Ένα διάγραμμα που βγαίνει από το μοντέλο δεν μπορεί να αποκλίνει, γιατί υπολογίζεται κάθε φορά από το ίδιο κείμενο.

Αυτός είναι ο κύκλος ζωής του τιμολογίου που μοντελοποιούμε παρακάτω. Κάθε βέλος είναι μια ενέργεια, και το μοντέλο ορίζει ποιος μπορεί να την εκτελέσει:

flowchart LR
    draft -->|Submit<br/>Accountant| submitted
    submitted -->|Approve<br/>Manager| approved
    submitted -->|Reject<br/>Manager| rejected
    approved -->|MarkPaid<br/>Accountant| paid
    classDef state fill:#494fdf,stroke:#376cd5,color:#ffffff,stroke-width:2px
    class draft,submitted,approved,rejected,paid state

Στο Appling δεν το σχεδιάζετε με το χέρι. Το IDE και το παράθυρο του MCP το αποδίδουν από το μοντέλο.

Ο καμβάς μεγαλώνει από τα modules προς τα πάνω και ανοίγει μόνο ό,τι πατάτε: εδώ την οντότητα Order του δείγματος sales και μετά τις ενέργειες που δουλεύουν πάνω της. Κάθε κλικ επιλέγει ταυτόχρονα και το κείμενο στα αριστερά.

Κρατήστε την επιχειρησιακή λογική ορατή

Η παρατηρησιμότητα κατά την εκτέλεση (logs, μετρικές, traces) σας λέει τι συνέβη. Η ορατή λογική σας λέει τι επιτρέπεται να συμβεί, πριν τρέξει κανείς τον κώδικα.

Με ένα μοντέλο μπορείτε να ρωτήσετε ανά πάσα στιγμή:

• Μπορεί ένα τιμολόγιο να φτάσει στο paid, και με ποια βήματα;
• Ποιοι ρόλοι μπορούν να εκτελέσουν το Approve;
• Ποιους κανόνες θέτει σε κίνδυνο μια ενέργεια;
• Πού στον κώδικα υλοποιείται αυτός ο κανόνας;

Στις τρεις πρώτες απαντά ο προσομοιωτής του Appling και στην τέταρτη οι αναφορές κώδικα: αρχείο και εύρος γραμμών ανά στοιχείο, που ακολουθούν τον κώδικα όταν μετακινούνται οι γραμμές. Οι απαντήσεις προέρχονται από το μοντέλο, άρα ισχύουν για κάθε υλοποίησή του.

Στο IDE οι απαντήσεις αυτές βρίσκονται στον inspector. Για μια μηχανή καταστάσεων δείχνει κάθε προσβάσιμη κατάσταση με τα βήματα που οδηγούν εκεί:

Για μια ενέργεια δείχνει τι απαιτεί, τι αλλάζει, ποια μετάβαση προκαλεί και πού χρησιμοποιείται:

Γράψτε το πρώτο σας μοντέλο Appling

Χρειάζεστε Node.js 24 ή νεότερο. Η εγκατάσταση παίρνει περίπου δέκα λεπτά. Ο οδηγός εγκατάστασης αναφέρει τις επιπλέον απαιτήσεις για τη δημιουργία κώδικα.

1. Εγκαταστήστε το CLI και δημιουργήστε τον φάκελο του μοντέλου.

npm install --save-dev @appling/cli
mkdir models

2. Γράψτε το πρώτο αρχείο μοντέλου. Δημιουργήστε το models/billing.appling:

module billing {
  role Accountant
  role Manager
  actor human Clerk roles Accountant
  actor human Director roles Manager

  enum InvoiceStatus {
    draft
    submitted
    approved
    rejected
    paid
  }

  entity Invoice {
    number: String unique
    amount: Money
    status: InvoiceStatus state default draft

    invariant "amount is positive" { amount > 0 }
  }

  action Submit on Invoice {
    requires { amount > 0 } else ZeroAmount
    errors ZeroAmount
    policy { actor.is(Accountant) }
  }

  action Approve on Invoice {
    policy { actor.is(Manager) }
  }

  action Reject on Invoice {
    input {
      reason: String
    }
    policy { actor.is(Manager) }
  }

  action MarkPaid on Invoice {
    policy { actor.is(Accountant) }
  }

  machine InvoiceFlow on Invoice.status {
    transition draft -> submitted via Submit
    transition submitted -> approved via Approve
    transition submitted -> rejected via Reject
    transition approved -> paid via MarkPaid
  }
}

Το πεδίο status έχει σήμανση state, οπότε μόνο η μηχανή καταστάσεων InvoiceFlow μπορεί να το αλλάξει. Κάθε policy ορίζει ποιος εκτελεί την ενέργεια.

3. Ελέγξτε το.

npx appling check models

1 file(s), 0 error(s)

4. Χαλάστε το επίτηδες. Αλλάξτε την τελευταία μετάβαση σε approved -> settled και ελέγξτε ξανά:

models/billing.appling:48:5 error "settled" is not a value of InvoiceStatus.
1 file(s), 1 error(s)

Ο κωδικός εξόδου είναι 1, άρα η ίδια εντολή προστατεύει και το CI σας. Επαναφέρετε την αλλαγή.

5. Κάντε ερωτήσεις στο μοντέλο.

npx appling simulate reach billing.InvoiceFlow paid models
npx appling simulate actors billing.Approve models

paid is reachable from draft:
  Submit -> submitted
  Approve -> approved
  MarkPaid -> paid

billing.Clerk: no
billing.Director: yes

6. Ανοίξτε το IDE.

npx @appling/ide models

Ανοίξτε το http://127.0.0.1:4410. Το κείμενο βρίσκεται δίπλα σε έναν χάρτη του μοντέλου, με αναζήτηση σε κάθε στοιχείο και έναν inspector που δείχνει ποιος εκτελεί κάθε ενέργεια. Ο οδηγός του IDE εξηγεί κάθε πάνελ.

Για μια πρώτη ματιά χωρίς εγκατάσταση, χρησιμοποιήστε το demo παρακάτω. Είναι το ίδιο IDE με το δείγμα μοντέλου πωλήσεων και CRM, και τρέχει εξ ολοκλήρου στον browser. Πατήστε έναν κύκλο στον καμβά για να ανοίξει, ή διαλέξτε ένα στοιχείο από την αναζήτηση.

Σε μικρή οθόνη, ανοίξτε το demo σε πλήρη οθόνη.

Συνδέστε τον MCP server του Appling με το Claude Code

Ο MCP server δίνει στο Claude Code ελεγμένη πρόσβαση στο μοντέλο. Το Claude το διαβάζει, ρωτά τον προσομοιωτή και το αλλάζει μόνο με λειτουργίες που κρατούν το μοντέλο έγκυρο.

1. Εγκαταστήστε το πακέτο AI.

npm install --save-dev @appling/ai

2. Καταχωρίστε τον server για τον φάκελο του μοντέλου.

claude mcp add appling -- npx appling-mcp models

3. Ρωτήστε για τη λογική με δικά σας λόγια. Ξεκινήστε το Claude Code στο project και δοκιμάστε:

Ποιοι ρόλοι μπορούν να εγκρίνουν ένα τιμολόγιο, και από ποια κατάσταση;

Το Claude απαντά μέσω graph_query και simulate, όχι μαντεύοντας από τα αρχεία πηγαίου κώδικα. Ο server του δηλώνει ότι το μοντέλο είναι η πηγή αλήθειας για τους επιχειρησιακούς κανόνες. Η ίδια αρχή βρίσκεται πίσω από το άρθρο μας για δικό σας MCP server για το Claude Code: ένα τυποποιημένο εργαλείο είναι καλύτερο από τις εικασίες του μοντέλου.

4. Αλλάξτε τη λογική. Ζητήστε μια αλλαγή, για παράδειγμα «ένας manager να μπορεί να επιστρέψει ένα απορριφθέν τιμολόγιο σε πρόχειρο». Το Claude χρησιμοποιεί το εργαλείο edit. Μια αλλαγή που θα πρόσθετε σφάλμα απορρίπτεται με αιτιολογία, και το αρχείο μένει όπως ήταν.

sequenceDiagram
    participant Εσείς
    participant CC as Claude Code
    participant MCP as appling-mcp
    participant M as models/*.appling
    Εσείς->>CC: "Ποιος εγκρίνει ένα τιμολόγιο;"
    CC->>MCP: simulate actors billing.Approve
    MCP->>M: ανάγνωση και έλεγχος
    MCP-->>CC: Clerk: no, Director: yes
    CC-->>Εσείς: Μόνο ο ρόλος Manager, από submitted

Χρησιμοποιήστε το παράθυρο οπτικοποίησης του MCP

Μέσω stdio, ο MCP server του Appling μπορεί να ανοίξει ένα μικρό παράθυρο οπτικοποίησης δίπλα στο τερματικό σας και να σχεδιάσει εκεί το μοντέλο. Συνεχίζετε να μιλάτε με το Claude Code· το παράθυρο δείχνει αυτό για το οποίο μιλάτε.

1. Ζητήστε μια προβολή.

Δείξε μου τον κύκλο ζωής του τιμολογίου.

Το Claude καλεί το visualize. Ένα παράθυρο χωρίς πλαίσιο ανοίγει πάνω δεξιά στην οθόνη, πάνω από τα άλλα παράθυρα, χωρίς να παίρνει την εστίαση από το τερματικό. Η προβολή machine δείχνει μία κάρτα ανά κατάσταση με ό,τι μπορεί να γίνει εκεί. Άλλες προβολές δείχνουν οντότητες, μεμονωμένες ενέργειες, use cases και events.

2. Δείξτε κάτι. Κάντε κλικ σε μια κάρτα ή γραμμή και γράψτε στο τερματικό «εξήγησέ μου αυτό». Το Claude διαβάζει την επιλογή σας με το visual_selection.

3. Ελέγξτε τις αλλαγές στο παράθυρο. Όσο το παράθυρο είναι ανοιχτό, το Claude προτείνει αλλαγές στο μοντέλο με το propose_edits. Το παράθυρο δείχνει τη σύνοψη και τις γραμμές που αλλάζουν. Το Accept τις γράφει στα αρχεία· το Reject αφήνει τα αρχεία ανέγγιχτα και επιστρέφει το σχόλιό σας στο Claude.

4. Προαιρετικά: γράψτε ερωτήσεις στο παράθυρο. Οι ερωτήσεις που γράφετε εκεί φτάνουν στη συνεδρία μέσω των channels του Claude Code, που βρίσκονται σε research preview. Ξεκινήστε το Claude Code δηλώνοντας τον server:

claude --dangerously-load-development-channels server:appling

Το παράθυρο χρειάζεται @appling/ai 0.1.2 ή νεότερο. Τρέχει σε Electron και κατεβάζει το εκτελέσιμο την πρώτη φορά. Σε Linux με Wayland τρέχει μέσω XWayland, που το παρέχουν το GNOME και το KDE.

Ξεκινήστε από το μοντέλο, όχι από τον κώδικα

Το βασικό συμπέρασμα: η σύνθετη επιχειρησιακή λογική γίνεται διαχειρίσιμη μόλις αποκτήσει ένα σημείο που μια μηχανή ελέγχει, σχεδιάζει και απαντά σε ερωτήσεις γι’ αυτό. Ο κώδικας, τα διαγράμματα και οι αλλαγές της AI ακολουθούν τότε το μοντέλο, αντί να κρατά ο καθένας τη δική του εκδοχή των κανόνων.

Ξεκινήστε από μία ροή που σας δυσκολεύει σήμερα, όπως οι εγκρίσεις ή οι καταστάσεις παραγγελιών, και μοντελοποιήστε μόνο αυτή. Η τεκμηρίωση του Appling καλύπτει όλη τη γλώσσα, ένα δεκάλεπτο tutorial για το πρώτο μοντέλο, την εξαγωγή μοντέλου από υπάρχοντα κώδικα με το Claude Code και τη δημιουργία κώδικα για Django, Ash, Go και Rust. Ο πηγαίος κώδικας είναι στο GitHub.

Αν θέλετε βοήθεια να μοντελοποιήσετε μια μπερδεμένη διαδικασία στο δικό σας σύστημα, μιλήστε μαζί μας.