Enabling Content Management Systems as an Information Source in Model-Driven Projects

Joan Giner-Miguelez, Abel Gómez, Jordi Cabot

Abstract

Modern software development increasingly relies on "headless" Content Management Systems (CMSs) as data backends. However, integrating these systems into Model-Driven Engineering (MDE) workflows remains a manual and error-prone process. This paper presents a model-based framework that automates the integration of CMSs by reverse-engineering their data schemas and generating custom middleware. By treating the CMS as a structured, platform-agnostic data source, the framework bridges the gap between content management and formal software engineering.

Introduction

Content Management Systems (CMSs) like WordPress and Drupal power over 60% of the web. The rise of "headless" architectures—where content is served via REST APIs rather than pre-rendered pages—has made them attractive backends for mobile and modern web applications. Despite their popularity, integrating a CMS into a professional software pipeline is often a "brute-force" manual effort. Developers must manually map JSON responses to local data structures and write repetitive "glue code," a process that is fragile and time-consuming.

This research aims to bring the rigor of Model-Driven Engineering (MDE) to CMS integration. The proposed framework automates the discovery of CMS schemas and the generation of middleware, allowing developers to interact with CMS data through high-level, structured models rather than raw API calls.

The Proposed Framework

The authors introduce a three-step framework implemented as an Eclipse plug-in to automate the transition from a live CMS to a usable software library.

Overview of the model-based framework for CMS integration.

1. Core CMS Model

The foundation of the framework is a "Core CMS Model" derived from an analysis of market leaders (WordPress, Drupal, Joomla). This base UML model captures universal concepts common across platforms, such as ContentType, Taxonomy (tags and categories), Media, and User Management (roles and permissions).

2. Reverse Engineering and Model Integration

The framework initiates a discovery process using the URL and credentials of a deployed CMS. By leveraging standard discovery mechanisms like OpenAPI/Swagger or JSON:API, it "crawls" the target system to identify custom entities. These site-specific types (e.g., a "VideoArticle" or "Podcast") are then mapped as extensions of the Core CMS Model, creating an integrated application model.

3. Code Generation

Finally, the framework generates a Java-based middleware library. This library includes dynamic classes representing the discovered content types, a "Site Manager" for connection handling, and a technology-specific "CMS Driver" (e.g., DrupalDriver) that translates model-level queries into REST API calls.

Case Study: Journal CMS

To validate the framework, the authors applied it to a "Journal CMS" scenario. This case study involved a complex schema with relationships between video articles, written news, and podcasts to demonstrate the framework's ability to handle custom schemas.

Integrated model for the Journal CMS case study, showing extensions of the generic schema.

As shown in the integrated model, specific types like NewsArticle and VideoArticle extend the generic ContentType, while BannerAds extends Block. This demonstrates the framework's ability to handle custom, hierarchical schemas and maintain relationships (e.g., RelatedAds, SearchTags) across different content types.

Key Insights

  • API as the Source of Truth: Since CMS APIs update automatically when administrators modify fields, they serve as the most reliable source for reverse-engineering the data model.
  • Platform Agnosticism: The "Driver" pattern abstracts away platform-specific details. A developer can interact with a VideoArticle object without needing to know if the underlying storage is WordPress or Drupal.
  • Abstraction of Hypermedia: The generated middleware simplifies complex REST "hypermedia" navigation. Instead of manual recursive API calls, developers can use intuitive methods like article.getAuthor().

Conclusion and Future Work

The framework successfully automates the generation of "glue code," significantly reducing manual effort and providing standard UML diagrams for broader project integration. While currently supporting WordPress and Drupal, the architecture is designed to be extensible to other platforms like Contentful or Strapi. Future work aims to incorporate "presentation suggestions" from the CMS to help automate the UI generation and explore integrations with data science tools for machine learning applications.

Summary updated

Abstract

Content Management Systems (CMSs) are the most popular tool when it comes to create and publish content across the web. Recently, CMSs have evolved, becoming headless. Content served by a headless CMS aims to be consumed by other applications and services through REST APIs rather than by human users through a web browser. This evolution has enabled CMSs to become a notorious source of content to be used in a variety of contexts beyond pure web navigation. As such, CMS have become an important component of many information systems. Unfortunately, we still lack the tools to properly discover and manage the information stored in a CMS, often highly customized to the needs of a specific domain. Currently, this is mostly a time-consuming and error-prone manual process.
BibTeX
@inproceedings{ginermiguelez2022enabling,
  author = {Joan Giner-Miguelez and Abel Gómez and Jordi Cabot},
  title = {{Enabling Content Management Systems as an Information Source in Model-Driven Projects}},
  booktitle = {RCIS},
  year = {2022},
  doi = {10.1007/978-3-031-05760-1\_30},
}
Figure