Graphileon Knowledge

(:IA_Function)-[:TRIGGER {type: event_name}]->(:IA_Function)

Graph Elements (Vertex Labels)

Graphileon’s application model is built around the following node (vertex) labels stored in the graph database:

Allowed Patterns

These are the graph patterns that define how Graphileon’s application logic is structured:

• Function triggers Function — all IA_Function vertices have a required type property that determines their behaviour and the outgoing events that can be triggered.
  (source:IA_Function {type})-[:TRIGGER]->(target:IA_Function {type})
• Function requires Permission — REQUIRE edges have a required for property. Use of permissions is optional.
  (:IA_Function {type})-[:REQUIRE {for: read|query|filter}]->(:IA_Permission)
• Dashboard shortcut to Function — the shortcut materialises as a button; activating it initiates the function.
  (:IA_Dashboard)-[:SHORTCUT {name}]->(:IA_Function {type})
• User personal shortcut — appears as a button in the user segment on all accessible dashboards.
  (:IA_User)-[:SHORTCUT {name}]->(:IA_Function {type})
• Team shortcut — appears as a button in the team segment on all accessible dashboards.
  (:IA_Team)-[:SHORTCUT {name}]->(:IA_Function {type})
• Dashboard auto-start — loading the dashboard automatically starts the linked function.
  (:IA_Dashboard)-[:START]->(:IA_Function {type})
• Dashboard bookmark — makes functions accessible at a named URL pattern.
  (:IA_Dashboard {iaName})-[:BOOKMARK {name}]->(:IA_Function {type})
• User can see Dashboard
  (:IA_User)-[:DASHBOARD]->(:IA_Dashboard)
• Team can see Dashboard — a user who is a member of a team can see a dashboard.
  (:IA_Team)-[:DASHBOARD]->(:IA_Dashboard)
• User is member of Team
  (:IA_User)-[:MEMBER]->(:IA_Team)
• Nested Team structure — team A is a member of team B; patterns can be chained.
  (:IA_Team {name: 'A'})-[:MEMBER]->(:IA_Team {name: 'B'})
• User granted Permission
  (:IA_User)-[:ALLOW]->(:IA_Permission)
• Team granted Permission
  (:IA_Team)-[:ALLOW]->(:IA_Permission)

Core Mechanisms

Understanding these mechanisms is essential to building effective Graphileon applications:

1. Graphileon loads application logic from a label-property graph and executes functions and triggers. The central pattern (:IA_Function)-[:TRIGGER {type:event_name}]->(:IA_Function), combined with ~60 function types, enables great flexibility.
2. :TRIGGER edges match specific events using the type property. A trigger with no type property fires on any event. Multiple events can be matched using an includes expression: { true: includes(['functionExecuted','functionUpdated'],(%).type) }.
3. Functions are stored in (:IA_Function) nodes. Triggers are stored on edges and fired when events occur. Triggers support matching (when to fire) and mapping (what data to pass).
4. The value of the type property on a [:TRIGGER] relationship must correspond to one of the event names of the source function.
5. Query statements must be configured inside a Query function. If a TreeView or GridView needs data, use a Query function with a TRIGGER {type: 'success'} to the consumer.
6. Application flows can be recursive — a function may trigger itself: (a:IA_Function)-[:TRIGGER {type:event_name}]->(a).
7. When a UI widget function is triggered, it automatically executes and appears in the designated area (default: content).
8. [:TRIGGER|SHORTCUT|START] edge property keys belong to one of these categories: match, map_to_target, match_to_path, manage_appearance, manage_instance, permission, or id.
9. A public: false|true property on a [:TRIGGER] determines whether it fires without a logged-in user. Default is false.
10. To pass parameters to a Query function, use a $params object on the trigger: {'$params.myParameter': '123'}.
11. Backend functions are killed after execution unless stayAlive is set to dashboard or session. Commonly used with IO, Timer, CustomStyle, and Iterate.
12. A new function instance is created on every incoming event unless the function’s _instance property is set to a specific name.
13. UI widget triggers with {type: 'context'} create right-click context menus. Triggers with {type: 'batch'} create buttons at the top of the container.
14. Triggers can access the global object via (@) — e.g. (@).user.name for the current user or (@).instances.myInstance.data for named instances.
15. Triggers access event data via the event object (%) — e.g. (%).data for the event payload or (%)._function.cypher to read the source function’s property.
16. Property keys starting with $_path. or #_path. map values to the application path object, accessible downstream via (%)._path.
17. Instance management uses $_instance, $kill, and $_instanceUpdateOnly. $_instance: '_new'|[name]|'_previous'|'_all' directs flow to specific instances.
18. Trigger property keys that do not start with # or $ are matching properties — conditions that must be true for the trigger to fire.
19. Multiple matching conditions can be combined using true as the key: { true: (@).user.name == 'Tom' && (%).data.length >= 5 }.
20. Function properties whose keys start with # or $ can be updated at runtime. Properties without these prefixes are read-only.
21. UI functions are rendered inside containers. Container properties (id, title, state, area, height, width) are set via the $container property key.
22. If a function renders in a container with an existing id, the previous function is killed and replaced — preventing screen clutter.
23. Four default display areas exist: content (centre), sidebar-right, sidebar-left, and modal.
24. Property values that reference expressions or combine multiple event/global objects must be wrapped in evaluate(): { $message: "evaluate('Hello ' + (@).user.name)" }.
25. All parameters support Mustache templating by default: {{ placeholder }} is replaced at execution time. Templating can be disabled per parameter with the :templating: none meta property.
26. Routing between application branches is achieved by creating multiple outgoing triggers with matching properties to determine which branch fires.
27. Property keys must be unique on a function, ignoring the #/$ prefix — you cannot have both $foo and #foo on the same function.

Function Types

Graphileon provides approximately 60 function types spanning backend logic, data management, UI views, maps, charts, graph visualisation, and administration.

Backend & Logic

Server-side / Flow control

Data Management

Graph database operations

UI Views — Data Display

Tables, trees & grids

UI Views — Forms & Input

User input & editing

UI Views — Charts & Timeline

Data visualisation

UI Views — Maps & Geo

Spatial & geographic

UI Views — Graph & Network Visualisation

Graph rendering

UI Views — Layout & Content Rendering

Layout & HTML

Navigation & Diagrams

Navigation & diagrams

Output & File Generation

File output

Administration

User & team management

Universal Events

In addition to the events listed for each individual function type, all function types fire the following events:

Example Configurations

The following examples illustrate common patterns using Graphileon’s graph-based application syntax.

(db:IA_Dashboard)-[:SHORTCUT {name: 'start query'}]->
(q:IA_Function {type: 'Query', cypher: 'MATCH () .. RETURN ..', store: 'data'})-
[s:TRIGGER {type: 'success', #data: '(%).data'}]->
(cjs:IA_Function {type: 'ChartJsView'})

(db:IA_Dashboard)-[:START]->
(q:IA_Function {type: 'Query', cypher: 'MATCH () .. RETURN ..', store: 'data'})-
[r:TRIGGER {type: 'success', #data: '(%).data'}]->
(tv:IA_Function {type: 'TableView|GridView|AgGridView'})

(q:IA_Function {type: 'Query', cypher: 'MATCH () .. RETURN ..', store: 'data'})-
[r:TRIGGER {type: 'success', #data: '(%).data'}]->
(it:IA_Function {type: 'Iterate'})-
[r2:TRIGGER {type: 'iteration', #data: '(%).data'}]->
(em:IA_Function {type: 'Email'})-
[r3:TRIGGER {type: 'sent', $iterationNext: true, $_instance: '_previous'}]->
(it)