DEV Community: Joshua Parker

What Problems Does Devflow CMF Solve for Developers?

Joshua Parker — Fri, 31 Jan 2025 20:43:40 +0000

Introduction

Before the early 2000s when CMSs started competing for market share, websites were built with pure HTML, CSS, and sometimes Javascript. After years of monolithic CMS domination, more and more people are turning to simple static websites. A headless CMS like Devflow CMF gives you that option, unlike a traditional CMS.

But it begs the question, "Why would a developer ditch an all-in-one traditional CMS and website builder for a headless one?" Well, the answer is quite simple. Investing in a headless CMS like Devflow is investing in your future as a PHP software developer, a full-stack developer, and a JAMstack developer.

Devflow CMF can be used to create any website. Websites fall under one of three types:

Informational - They are used to educate, entertain, or promote a cause.
Transactional - Allows visitors to purchase a product or service.
Interactive - Allows users to interact with a website by playing a game, interacting with forums, or leaving a comment.

The most common and easiest of websites to build are informational - which also includes personal websites. These are the types of websites a developer will build for most of their career. Informational websites make up the majority of the web, with some of them having some added interactive or transactional service powered by phpBB, Flarum, Shopify, Etsy, or some other open source or eCommerce SaaS.

Informational sites with a traditional setup may work in certain circumstances. But for a bespoke website that needs to scale and grow over time, you need a non-traditional and modern solution without limits.

Furthermore, content creators can create reusable content to be used in multiple channels and applications. Creating a single source of truth. Change it once in Devflow, and it updates everywhere that pulls content from the API. Publish once; use anywhere. Edit once; update everywhere.

Issues With No-Code Development

Before we get into the meat of this article, let's first bring up the issue of no-code development. I can't speak for all no-code platforms, but let's use WordPress - the most popular monolithic CMS - as an example.

There are several no-code page builders available for WordPress. This lowers the barrier to entry for less technical developers to build a website agency around. But there is one problem. The entire website, including the presentation layer, is saved in the database.

Who thought this was a good idea? This introduces bloat, scaling issues, and excessive database connections on every page load. Which also drives up costs. With a headless CMS, you have a separation of concerns.

No Head

As an alternative to theme-based development - which could make a site look cookie-cutter - a headless CMS allows developers to build bespoke websites for B2B or B2C clients needing their website to convey professionalism and maturity.

Event Sourcing

This feature speaks more for Devflow than headless in general. As developers, we know that our clients' needs change. Therefore, we need a CMS that can scale and grow over time. In this vein, Devflow offers developers two benefits:

Flexibility for future development - Developers can use historical data to build innovative solutions.
Improved testing and debugging - Developers can replay domain events in a controlled environment to ascertain problem areas.

Reusable Content

With an API-first architecture, developers can deliver content to websites, mobile apps, and smart devices with a seamless and enhanced user experience.

Customization and Artistic License

With a traditional CMS, the backend and frontend are connected, making it difficult to scale and customize, and introduces a security issue. When using a headless CMS, you have the artistic freedom to build and design scalable and SEO-rich websites. A headless CMS also fixes the security hole by not telling the world what powers your site.

Don't believe me? Check out What CMS? has to say about Devflow's website.

Plan for the Future

It is time for PHP developers and web development agencies to plan for the future. The monolithic CMS age will slowly decrease as businesses and startups request headless CMS solutions offering a seamless digital experience across all channels. Even Gartner Research predicts this change, "...businesses will prioritize modular applications that deliver their functionality as API/event-first business components."

To learn more about Devflow CMF, subscribe to the YouTube channel to receive updates on new tutorials and tips for using Devflow.

Devflow CMF vs WordPress: WordPress Alternative

Joshua Parker — Mon, 20 Jan 2025 15:43:00 +0000

Devflow and WordPress have quite a few things in common. Both are self-hosted solutions, coded in PHP, and customizable. Devflow also shares a lot of code with WordPress, but it is definitely not a fork. The similarities in the API, event system, and helper functions help lower the barrier to entry.

Nevertheless, there are key differences that make Devflow stand out as an incredible alternative to WordPress.

Framework: Build Bespoke Websites

Devflow is a content management framework that gives developers the autonomy, flexibility, and creativity to build bespoke websites and applications. Devflow is better viewed as a content repository where one builds a firm structure around that content.

Furthermore, you are not beholden to a Post content type if you don't require a blog. The ubiquitous language for one site may not be the same as another. So instead, you create the content types you need. Even if you develop a blog site, Content Types can act as categories. Developers can customize the admin dashboard which natively is void of widgets and unnecessary content. When utilizing built-in hooks, one can build a custom dashboard based on a client's needs.

Themes and plugins can be installed to extend functionality or add a presentation layer. Otherwise, one can consume the Rest API and choose from the available frontend frameworks to build a presentation layer.

DDD, CQRS, Event Sourcing

The top feature of Devflow is that it's built on the CodefyPHP framework which is great for architecting domain-driven projects with CQRS, and Event Sourcing. To be fully transparent, a domain-driven architecture is quite complex and overwhelming for some. Nonetheless, if one takes the time to immerse oneself in domain-driven design, there is a significant return on investment with many benefits.

First, you have revisions built in. Every user, site, content type, or product change in Devflow emits an event and is stored in an event store. A user interface can be built to interact with the events to restore a content type or product to a previous version.

Second, there is room for more complexity. Have you ever built a website for a client and the project becomes more complex or mission-critical? With Devflow, you can create a product or website that aligns with a business's goal and how it operates.

Third, Devflow gives you flexibility. When you create a site or product with a modular design, it becomes easier to upgrade, modify, and modernize, extending its lifecycle. It's the gift that keeps on giving for years to come.

Page Builder

Unlike the other popular content management systems, a no-code page builder is not included. However, you can easily integrate PHPagebuilder into Devflow. PHPagebuilder is a framework-agnostic drag-and-drop page builder that also allows for customization and the creation of blocks.

Built for PHP Developers

Unlike WordPress, Devflow was built for PHP developers. No need to hack it into a CMS, instead you turn it into the CMS you want or need.

Other notable benefits of using Devflow:

Interoperability
Rapid Application Development
Increased network efficiency and scalability
NIST Level 2 Standard for improved data security
Content flexibility
Automate repetitive tasks
Extend or modify functionality

WordPress powers at least 40% of the world's websites. It is the most popular open source CMS, following Drupal and Joomla. Moreover, it has a longstanding legacy, but if you need something that offers freedom and flexibility, I encourage you to try Devflow today.

Devflow CMF equals freedom. Freedom to customize, freedom to build a custom CMS for clients, and the freedom to use any frontend framework.

An Introduction to CodefyPHP: A Domain-Driven Framework

Joshua Parker — Mon, 02 Oct 2023 18:50:17 +0000

A PHP Domain-Driven Framework for building complex applications with CQRS and Event Sourcing

What is CodefyPHP?

You might not have heard of a new framework that was released a few weeks ago called CodefyPHP. The framework was created specifically for one of my legacy projects that needs refactoring and would benefit from Domain-Driven Design. I released it to the world in the hope that others may find it beneficial as well.

As with any new library and project, naming things is always the most difficult. But when trying to think of a name, I wanted it to be meaningful and representative of its goal and mission. Therefore, I came up with CodefyPHP.

The name Codefy is a derivative of the word codify which means to arrange into a systematic code according to a plan or system. This is the purpose of CodefyPHP as it pertains to Domain-Driven Design, ubiquitous language and complex applications.

Codefy is not a full-stack framework such as the likes of Symfony, Codeigniter, Yii2, FuelPHP, or Laravel. Nevertheless, it contains components such as routing, database migrations, multiple PSR implementations, and templating. All the things you need to start building a project.

The Purpose of CodefyPHP

The philosophy of Codefy is that code should be systematized, maintainable, and follow OOP (Object-Oriented Programming). CodefyPHP tries not to be too opinionated, yet encourages best practices and coding standards by following Qubus Coding Standards. Nevertheless, you can use Codefy as you see fit. You can tap into all, some or none of the features and instead use the interfaces to build your implementations for a domain-driven project.

Highlighted Features

CodefyPHP has several noted features outside of the domain-driven scope. Let's take a look at some of them.

Codex CLI

When you use the skeleton package, you have access to Codex which allows you to generate migrations, controllers, middleware, service providers, start the dev server and more.

Here are some example commands:

❯ php codex serve //This command starts the dev server

❯ php codex stub:make Users_controller //Creates UsersController

❯ php codex password:hash 'jsx82kjsks9273js'
Your hashed password is: $2y$10$4A3iA5z.qyi6DZ5bibKXUujbqYdjH.QjpbO/lUDR9dalaN1IbEZtm 

❯ php codex ddd:ulid //Generates a random Ulid string

Database Migrations

Placing your database under version control is easy with CodefyPHP's database migrations:

❯ php codex migrate:generate CreateUsersTable
+f ./database/migrations/20230908035134_CreateUsersTable.php

❯ php codex migrate:status
+--------+------------------+-----------------------+                                                                                                                 
| Status | Migration ID     | Migration Name        |
+--------+------------------+-----------------------+
| down   |  20230908035134  | CreateUsersTable   |
+--------+------------------+-----------------------+

❯ php codex migrate
 == 20230908035134 CreateUsersTable migrating
 == 20230908035134 CreateUsersTable migrated 0.0090s

❯ php codex migrate:status
+--------+------------------+-----------------------+                                                                                                                  
| Status | Migration ID     | Migration Name        |
+--------+------------------+-----------------------+
| up     |  20230908035134  | CreateUsersTable   |
+--------+------------------+-----------------------+

//Example from migration file
    public function up(): void
    {
        if (!$this->schema()->hasTable(table: 'users')) {
            $this->schema()
                ->create(table: 'users', callback: function (CreateTable $table) {
                    $table->string(name: 'user_id', length: 36)
                        ->primary()
                        ->unique(name: 'userId');
                    $table->string(name: 'first_name', length: 191);
                    $table->string(name: 'last_name', length: 191);
                    $table->string(name: 'email', length: 191)
                        ->unique(name: 'email')
                        ->notNull();
                });
        }
    }

Dual Templating Engines

CodefyPHP comes with dual templating engines. The templating engine is called Scaffold, and there is a native engine and compiler engine. The native engine can be used if you are a PHP purist and only want to write PHP code. Here is an example:

<?php

$this->parent('main::layout');
$this->block('content', function ($params) {

?>
<article>
    <header>
        <h1><?=$this->esc($this->ucfirst($params['title']));?></h1>
    </header>
    <main>
        <?php foreach($params['paragraphs'] as $paragraph): ?>
            <p>
                <?=$this->esc($paragraph);?>
            </p>
        <?php endforeach; ?>
    </main>
</article>
<?php }); ?>



<html>
    <head>
        <title><?=$this->esc($title);?></title>
    </head>
    <body>
        <?=$this->block('content');?>
    </body>
</html>

The compiler engine is similar to that of Twig and Blade. Nevertheless, the framework includes adapters for a few other templating engines as well.

Test-Driven Development (TDD)

When you create a new project with the app starter (skeleton), it will include PestPHP which is great for test-driven development. One of the main advantages of TDD is the high test coverage by writing the tests for each feature before the implementation. While coding your implementation, you run your tests until all of them pass. It is a slow but rewarding process.

Along with the ones previously mentioned, a few other highlighted features are the dual query builders, sanitizing helpers, injector for bootstrapping, routing engine, and adapters for cookies, sessions and cache storage.

In Conclusion

But what if you are not interested in the framework, but the domain-driven stuff is all you need? Well, the framework is built on what's called the domain-driven core. The Domain-Driven Core includes the abstractions and interfaces you can use to build your domain-driven project without the dependencies found in the framework, and it includes a lot of tests you can check out. You can even integrate it into your Laravel, Symfony, or Codeigniter project.

If you are a PHP developer who loves Domain-Driven Design and Test-Driven Development as much as I do, then head on over to the project's GitHub page. After such a short time, it already has 7 stars.