How is your experience with the OutSystems Community?
applicationlandscape2markdown
Reactive icon

ApplicationLandscape2Markdown

Stable version 1.0.1 (Compatible with OutSystems 11)
Uploaded
 on 17 Nov (18 hours ago)
 by 
0.0
 (0 ratings)
applicationlandscape2markdown

ApplicationLandscape2Markdown

Documentation
1.0.1

Requirements and installation

The component runs on OutSystems 11 (Reactive Web) and needs the dependencies below, all published in the environment before you install it.

Dependency

Why it is needed

(System)

Application, App_Definition_Module, Module, Espace, Entity, Espace_Entity, Web_Reference and Web_Service

ExtendedMetamodel (Forge)

REST_Web_Reference (consumed REST) and REST_Expose (exposed REST)

Sanitization

BuildSafe_InClauseIntegerList, to build the application filter safely

OutSystemsUI

Layout, DropdownSearch, CardSectioned and BlankSlate

Users

Template login and logout actions

  1. Install ExtendedMetamodel from the Forge, if it is not in the environment yet.
  2. Install ApplicationLandscape2Markdown from the Forge.
  3. Open the module in Service Studio and confirm that User Provider is set to ServiceCenter, so only IT users can sign in.
  4. Publish the module.
  5. Open https://<your-environment>/ApplicationLandscape2Markdown/ and sign in with an IT user.

How to use

Pick the scope, choose the sections and generate: the document appears below the filters in seconds.

  1. In Applications, select one or more applications, or tick Export all applications to include every non-system application.
  2. In Sections to include, untick what you do not need: Dependencies and findings, Entities, Integrations (REST and SOAP), Descriptions, Mermaid diagrams.
  3. Click Generate Markdown. With nothing selected and the all-applications option off, a warning asks you to select something.
  4. Use the icons next to the Markdown title to copy the document to the clipboard or download it as a .md file.
  5. Paste or attach the file in your AI assistant together with your question, for example an impact analysis of a change to a Core module.

For large landscapes, start with a few applications: the export runs as one SQL query with a 60-second timeout.

Document sections

The export always holds the header, overview, catalogues and context; the rest follows the options you tick.

Section

What it holds

Shown when

Header

Generation date (server time), scope and number of applications

Always

Overview

Counts of applications, modules, dependencies, findings, entities and integrations

Always (rows per ticked option)

Application Catalogue

Each application with its ID, description and modules with their layer

Always

Suggested Architecture Classification

Modules grouped by End User, Core, Foundation, Platform and Unclassified

Always

Architecture Findings

Upward references, side references between End User modules, direct cycles

Dependencies and findings

Module Dependency Diagram

Mermaid flowchart grouped by layer; each arrow shows the number of referenced entities

Dependencies and findings + Mermaid diagrams

Integration Diagram

Mermaid flowchart of the REST and SOAP services each module consumes or exposes

Integrations + Mermaid diagrams

Module Catalogue

Per module: application, module kind, layer, Depends On, Used By, Owned Entities, Integrations

Always (subsections per option)

Cross-Application Dependencies

Every dependency between modules of different applications

Dependencies and findings

Integration Landscape

All integrations grouped by direction and technology, with URLs

Integrations

Architecture Context and Known Limitations

How to read the document and what it does not cover

Always

Descriptions of applications and entities are added only when Descriptions is ticked.

Architecture layers and findings

Layers are inferred from the module name, checked in the order below; the first rule that matches wins.

Order

Rule

Layer

1

Platform system module (for example ServiceCenter)

Platform (not validated)

2

Name ends in _FS, _IS, _TH, _Theme, _Pat, _Lib, _Core, _Drv or _Ext

Foundation

3

Name ends in _CS, _BL, _CW, _Sync or _API

Core

4

Name equals the application name, with or without spaces

End User

5

Anything else

Unclassified (not validated)

The findings follow the Architecture Canvas, using these layers and the entity-based dependencies:

  • Upward reference: a module references a module in a higher layer (Foundation to Core or End User, Core to End User).
  • Side reference between End User modules: one End User module references another.
  • Cyclic reference: two modules reference each other directly.

Adapt the suffixes in the first UPDATE of the qBuildMarkdown SQL query in GetMarkdown if your naming conventions differ.

Data sources and security

The export is read-only and reaches only authenticated IT users; it never reads credentials.

  • One read-only query: GetMarkdown runs a single SQL query (qBuildMarkdown) over (System) and ExtendedMetamodel entities, with temporary tables and a 60-second timeout. It writes nothing to the database.
  • Safe filter: the selected application IDs go through BuildSafe_InClauseIntegerList (Sanitization) before the Expand Inline parameter.
  • Access control: the module uses the ServiceCenter user provider. The screen requires an authenticated user, and GetMarkdown checks CheckRegisteredRole() on the server and raises AccessDeniedException otherwise.
  • No credentials: the query reads only names, URLs and security settings. The username, password and client-secret attributes of REST_Web_Reference are never read.
  • Sensitive output: the document holds module names, entity names and endpoint URLs of your environment. Treat it as internal and check your policy before sharing it with external AI services.
  • Smaller dependency footprint: in Manage Dependencies, keep only REST_Web_Reference and REST_Expose from ExtendedMetamodel. Entities such as SessionToken, ServiceCenter_Token or SapConfig are not needed.


Known limitations

Dependencies come only from entity references; everything else a module consumes is not visible to the export.

  • References to actions, blocks, structures, themes and images are not included, because neither (System) nor ExtendedMetamodel exposes them. A module that only calls actions of another module shows no dependency on it.
  • Extensions are not listed: their names are not available through (System) or ExtendedMetamodel.
  • Strong and weak references are not distinguished.
  • Architecture layers are inferred from module names and must be validated manually.
  • Cycle detection reports only direct cycles between two modules.
  • REST and SOAP methods are not listed individually.
  • The platform does not allow OSSYS_ tables in SQL nodes, so richer metadata would need an extension built in Integration Studio.

1.0.0

Release Notes 

Version 1.0.0 

  • Initial release. 
  • Features included: 
  • Multi-application export 
  • Markdown generation 
  • Architecture classification 
  • Entity ownership discovery 
  • Entity dependency analysis 
  • Cross-application dependency discovery 
  • REST integration inventory 
  • SOAP integration inventory 
  • Mermaid dependency diagrams 
  • Mermaid integration diagrams 
  • AI-ready application landscape documentation


Benefits 

  • Architecture visibility 
  • Faster documentation generation 
  • Landscape discovery 
  • Dependency mapping 
  • Integration inventory 
  • AI-ready output Mermaid diagram generation 
  • Multi-application analysis 
  • Metamodel-driven documentation


Generated Information 

The current version includes: 

  • Applications 
    • Application metadata 
    • Application composition 
    • Module inventory 
  • Modules 
    • Module metadata 
    • Suggested architecture layer 
  • Entities 
    • Entity ownership 
    • Entity descriptions 
    • Entity classifications 
  • Dependencies 
    • Module-to-module dependencies 
    • Cross-application dependencies 
    • Referenced entities Integrations 
    • Consumed REST integrations 
    • Consumed SOAP integrations 
    • Endpoint inventory 
  • Diagrams 
    • Entity dependency diagrams 
    • Integration diagrams


Limitations

Current dependency discovery is based on entity references. 

The current version does not include dependencies that exist exclusively through: 

  • Public Actions 
  • Structures 
  • UI Blocks 
  • Themes 
  • Extensions 
  • Runtime-only interactions


The current integration inventory includes: 

  • Consumed REST services 
  • Consumed SOAP services 


The current version does not include: 

  • Exposed REST APIs 
  • Exposed SOAP services 
  • Individual REST operations 
  • Individual SOAP methods 


Architecture classifications are inferred from naming conventions and should be validated by solution architects when required.