PreviousNext: Overriding base field labels and descriptions of Drupal Entities without custom code

Planet Drupal - 11 hours 53 min ago

Have you ever had a project where you've used a core or contributed module but been asked to make slight changes to base fields? e.g. Changing the field title, default value, required state or description?

Read on to find out how to use a little-known feature of core to make these changes with only configuration.

by lee.rowlands / 27 May 2022

You may not be aware, but Drupal core has a mechanism for changing base field definitions without code, but other than for nodes, there's no real UI to make use of this API.

If you've ever changed the label of the Title field for a node-type and then exported your configuration, you've probably seen a core.base_field_override file pop up in the exported files.

These config entities can be used to modify base fields on a per-bundle basis.

Drupal core uses them to change the label of the Title field for a given node-type or the default state of the 'Promoted to front page' field.

But the same mechanism can be used for any entity-type.

So how do you go about using this feature.

Well, you've got two options - one is to use the Base Field Override UI module. This lets you change the title and description via a UI. 

But there are more properties a field override can contain, such as default values, required state and even field settings. For those cases, you need to revert to editing YML. But first you need a mechanism to generate the YML.

At present, the simplest way to do that is using Drush to evaluate the following.

drush php-eval "\Drupal::service('entity_field.manager')->getBaseFieldDefinitions({entity_type})[{field_name}]->getConfig({bundle})->save();" 

Just substitute the entity type ID, field name and bundle.

E.g. to export the YML of the 'info' (label) field on the block content entity from 'Block description' for a block-type called 'gallery' you would run

drush php-eval "\Drupal::service('entity_field.manager')->getBaseFieldDefinitions('block_content')['info']->getConfig('gallery')->save();" 

Once that is done, you can run drush config:export -y to export your configuration and you should see a new in your config export folder.

You can now edit this file and make the changes you need, and then re-import it using drush config:import -y.

If the entity-type you need to override doesn't support bundles, just use the entity type ID in place of the bundle, e.g. for the User entity, use user for both the entity type ID and bundle.

The advantage of this approach is you don't need to keep an extra module around (Base Field Override UI) just for one-off changes.

Thanks to Adam Bramley for reminding me of this feature. I have a slack comment from him pinned in my saved items and refer to it all the time!

Tagged Entities, configuration management

ImageX: Bon Appétit: Top Modules for Creating User-Friendly Menus in Drupal

Planet Drupal - Thu, 2022/05/26 - 6:20pm
In eateries and websites alike, menus offer guests a selection of options to enjoy.  It may be obvious, but menus are indispensable website navigation elements. If properly built and well-positioned, they greatly increase the chance that customers feel more engaged, find what they are looking for, and ultimately,  end up with a conversion.  It’s great to know Drupal offers plenty of tools both to make website menus user-friendly and help menu creators — admins, editors, developers — build them as easily and quickly as possible. 

Security advisories: Drupal core - Moderately critical - Third-party libraries - SA-CORE-2022-010

Planet Drupal - Wed, 2022/05/25 - 9:39pm
Project: Drupal coreDate: 2022-May-25Security risk: Moderately critical 13∕25 AC:Complex/A:None/CI:Some/II:Some/E:Theoretical/TD:UncommonVulnerability: Third-party librariesCVE IDs: CVE-2022-29248Description: 

Drupal uses the third-party Guzzle library for handling HTTP requests and responses to external services. Guzzle has released a security update which does not affect Drupal core, but may affect some contributed projects or custom code on Drupal sites.

We are issuing this security advisory outside our regular Drupal security release window schedule since Guzzle has already published information about the vulnerability, and vulnerabilities might exist in contributed modules or custom modules that use Guzzle for outgoing requests. Guzzle has rated this vulnerability as high-risk.

This advisory is not covered by Drupal Steward.


Install the latest version:

All versions of Drupal 9 prior to 9.2.x are end-of-life and do not receive security coverage. Note that Drupal 8 has reached its end of life.

Drupal 7 is not affected.

Reported By: Fixed By: 

Théodore 'nod_' Biadala: JavaScript management in Non-JavaScript CMS

Planet Drupal - Tue, 2022/05/24 - 9:45pm

I wrote this post from scratch about 7 times over the last few months, and I’m not getting anywhere so I’ll write up something, it’s not perfect, I took a few shortcuts but having a discussion going is more important than a perfect post.


JavaScript development went from widget-based add-ons for functional HTML pages to being responsible for HTML page assembly and even basic browser interactions (such as navigation, form submission, etc.)

In the first case, the JS files are standalone-ish, they usually depend on a bigger library (like jQuery) and sticking them on the page with a script tag is enough for things to work. Makes it easy to assemble pages at runtime based on the original JS source. Additional processing can be done on the JS file to minify or gzip it but it doesn’t go much further than this. This is what Drupal and most other CMSs that have been around for a while do very well.

This worked well until the push for better UX shifted more and more responsibilities to the frontend. More responsibilities translate to more code sent, minification wasn’t enough and JS libraries got bigger and became frameworks with smarter tools, we began to see an optimization or build step to transform development code into running code. This is around the time where CMSs started to get left behind I’d say.

Fast forward to now where the whole site/application is in JavaScript and the framework needs to build the application before it can even be loaded. It’s not really possible to add or remove functionality at runtime, if there is a change in the application, the whole application needs to be built again. On top of this frameworks are now competing in server side rendering capabilities.


How to accommodate JS as it is written today with the CMSs way of consuming it?


Essentially, transform a monolithic JS application in a set of files that are optional and can be loaded at runtime without the need of a build step. One partially successful example of this is how CKEditor 5 has been integrated into Drupal by using the relatively new Webpack DllPlugin, instead of building a single JS file with all the WYSIWYG tools, each tool is packaged in it’s own file that can be loaded at runtime without fuss. This solution still needs a build step but at least the result of the build step can be used dynamically.


In the case of Wordpress they solved the problem simply by going all JS with Gutenberg: a whole new repo, only JS/React code, very little PHP in sight, and a great opportunity to generate engagement by creating a new way of doing things. It seems to be working well for them.


Symfony went with a Yaml API around nodejs tooling with Webpack Encore. Still need nodejs installed and all it comes with.

Another way?

Personally I would like to explore an alternative path before considering to move all-in on the JS way of doing things, and require nodejs for hosting a Drupal website, a path that can help mitigate some of the pain of JS tooling. There is no reason for JS tooling to be written only in JS, there is already a bunch of tools written in rust, as long as you can read the file, you can make the same transformations in any language.

I’d like to see a set of PHP-based tools that helps manage JS, in a way that the build step is actually handled by the CMS so that people writing Drupal code do not need to care about nodejs, tooling, package updates, etc. For example I would love to write JavaScript modules and have the dependencies automatically picked up and declared in Drupal and at the same time, have Drupal aggregate all those modules in a single file. Something that is surprisingly impossible to do natively for now hopefully. Until then I’m itching to use peast to transform JS from PHP and start making tools that remove problems for PHP developers.

What do you think?

As as said in the beginning this post is a bit messy, I’m not comparing the same things or define what it is that the build step should be doing or not doing, but I’m happy to just talk about the topic and see what others think.


Evolving Web: Why Web Governance Is Essential to Your Digital Content Strategy

Planet Drupal - Tue, 2022/05/24 - 7:42pm

Governance is more than a conversation about who gets a user account on your website. A web governance plan should help you use your website or digital platform as an effective communication machine. It should tell you why each part of your website exists and the steps your organization should take to deliver on that purpose. If your website plays a strategic role in how you communicate and engage with your audiences, you need web governance.

Launching with a Strong Content Strategy is Not Enough

An important step in the discovery work of any website redesign project is digging into the business goals, the user needs, and how people are using a website. This is valuable work that involves getting stakeholders together, performing user research, and analyzing current user behavior and website performance. But too often, this work is only used to feed into the redesign itself. It gets translated into a strategy, a design, and potential some content improvements, and finally a new website is launched.

But too often, when the website is launched, the vision and strategy for the website is forgotten. And the content and messaging can become dated or stray from the actual purpose of the website. In short, it’s not enough to launch with a good strategy, you need a way to act on it. Without a specific and realistic governance plan, a fantastic website can quickly devolve into something that doesn’t serve its purpose.

Governance is often the bridge between business goals and user needs. Sometimes there’s a mismatch between how your website is organized and how decisions get made. This could mean that people from different departments share responsibility for updating a single website, section, content type, or page. And because each organization is different, web governance is not one-size-fits-all.

That being said, here are some things you can do to make sure your governance plan helps you deliver on your content strategy goals.

8 Aspects of an Effective Web Governance Plan Be Strategic

Your governance plan should tell you the purpose and goals of each element of your web platform. That goes for each website, each section or content type, and each feature. The purpose should also come across in the metrics that you’re tracking and who is responsible for analyzing, updating, and approving changes. This should also help your organization figure out where new features, messaging, or information should fit into the user experience, or whether it belongs on your website at all.

Be Specific

If you’re using a content management system, you’ve probably already done the work of defining the individual content types and content components to organize your content. Using these in your web governance plan, assigning responsibility for who updates and maintains each content segment, can help people feel empowered to make improvements. This gives visibility to the overall system status, helps set expectations, and reduces anxiety on a usually already busy team.

Be Proactive

Sometimes, in the discovery phase of a project, when we’re discussing the pain points of an existing website or app, it’s clear that the people in charge of running a website aren’t necessarily familiar with all the content they have or where to find it. If a website is truly external-facing, some sections might languish for months or years because we assume they’re working fine or that someone else has it covered. Governance should address this by establishing cycles for analyzing these corners of your website with some regularity.

Create Alternative Contribution Channels

While roles and permissions are fantastic tools for allowing people to create content directly within your content management platform, external tools could prompt other groups to contribute content when they have something to promote upstream. A tool like Trello or a simple Google Form allows many people to contribute content, which can then be used in any digital channel (social media, newsletters, the website) while leaving the curation and use of that content to a more centralized group.

Weave in Compliance

Often, content compliance (adhering to accessibility guidelines or your content style guide) is something that’s done reactively when someone notices a particular page or section of a website strays from the norm. Or there’s an education program in place, so that content editors can get accessibility training. And while these two things play a role in compliance, it’s even more effective to identify tools that content editors can use to check compliance as they go, like the editoria11y module for Drupallisted as one of our team’s favourite

Drupal modules

Identifying offline content collaboration tools (e.g. using a particular Google Docs template for creating drafts or using tools like PuppyPaste to clean up content before pasting it into your WYSIWYG editor) can also result in better standardization of content before it even lands on your website.

Divide and Conquer

It’s good to be creative about who takes responsibility for what. In an organization with a hundred websites or more, it’s hard for one central group to take stock of which websites exist, let alone be responsible for the success of each one. In this case, it might be useful to assign a champion for a grouping of websites, someone who can take responsibility for who gets to create a new site, be the point-person for compliance questions, and run segments of the content review process.

Be Realistic

The whole point of governance is to keep your work purposeful. But if the burden of updating and analyzing your content is too high, you won’t do it. Looking at the time people actually have to analyze data, update content, or create fresh content is important. This is why it’s important to create your web governance plan early, before launching a website or rolling out new features.

To reduce the burden, you can reduce the amount of dynamic content and content curation required to keep the website fresh. You can also prioritize which content deserves the most attention, and address this more frequently. It’s helpful to schedule reminders and meetings to do the monthly, quarterly and yearly tasks identified, which will make it clear what is expected of each person involved in governance.

If disparate groups have a track record of not contributing or monitoring their content, make sure your governance plan addresses it. You can add new ways for them to contribute that don’t require so much effort. Or alternatively, change their role so that they are informed of content updates, but don’t have to take responsibility for making them.

Think Beyond a Single Website

Your governance plan can go beyond serving as a playbook for improving the content of a single website. It can also serve to question why certain features, websites, and content types are required in the first place. If you’re working in an environment where websites are spun up on a regular basis for one-off events, topics, or campaigns, it would be extremely valuable to create a centralized place where the purpose of each existing website is described. You could also include a set of criteria for creating a new website.

💻 Want to create an effective content strategy for your Drupal project? Check out our UX and Content Strategy for Drupal training course

+ more awesome articles by Evolving Web

Specbee: What to expect in Drupal 10

Planet Drupal - Tue, 2022/05/24 - 9:34am
What to expect in Drupal 10 Alok Aman 24 May, 2022

If you were at DrupalCon Portland 2022 or watched the recording of DriesNote, you’re probably aware that the release date of Drupal 10 has been moved back by a few months. Drupal 10 is now expected to release in December 2022 (which was a plan-B scheduled release date anyway). We’ll touch on the reason the dates were pushed from June 2022 to December 2022 first. But read on for all the things to look forward to in Drupal 10.

If you’re still on Drupal 7 (or 6), the time is right to migrate to Drupal 9 now. Upgrades to Drupal 10 and all the following versions are going to be easy forever!

Why not June 2022 for Drupal 10

A flexible content editor is a fundamental part of any content management system. CKEditor has been a part of Drupal’s family of modules since Drupal 6 and has become a favorite editing tool amongst users. CKEditor 4.5 is the default WYSIWYG rich text editor for Drupal 8/9. 

The big news here is that Drupal 10 will have the all-new features of CKEditor 5. It’s going to be more powerful, easily customizable, perfect UX and will come with a modular architecture. With CKEditor 5 in Drupal 10, we foresee a bigger adoption of Drupal as a blogging platform.

However, CKEditor 5 is a complete rewrite of CKEditor with no backwards compatibility or upgrade path. Almost like a Drupal 7 to Drupal 8 rebuild. The Drupal community has been working closely with the CKEditor team at CKSource on this and has spent thousands of hours creating an upgrade path from CKEditor 4 to CKEditor 5 for Drupal 10. But there still is a lot of work to be done to push it to the finish line and to make sure it is easy for site builders to upgrade from CKEditor 4 to 5. 

With that and CKEditor 5 being an integral part of Drupal 10, the scheduled release date had to be pushed to December 2022.

What’s New with Drupal 10

Drupal 10 is going to be the more updated and polished version of Drupal 9. It comes with some updated additions of new features and removal of some deprecations.

Updated Third-Party Software

Drupal now works on different third-party components. It’s essential to work with the updated versions of these modern libraries and features. These components perform better and are more user-friendly. Drupal 10 websites will be able to leverage the innovations of these components.

Symfony 6.2

Drupal relies heavily on the Symfony framework. It is the foremost driver of Drupal since version 8. Drupal 9 uses Symfony version 4, which is reaching end of life and support by November 2022. So apparently, the Drupal 9 to Drupal 10 upgrade will be skipping a version of Symfony (Symfony 4 to 6). Symfony 6.2 will be released just in time for Drupal 10’s release and will have many modern features that developers are going to love.

CKEditor 5

As already discussed earlier in this post, Drupal 10 will ship with the awesome CKEditor 5, replacing CKEditor 4 for good. CKEditor 5 is supported in Drupal 9.3 as an experimental module but is not stable. CKEditors is not only great for site builders because of its user-friendliness and great UX, it is also a great framework for developers to customize and build upon. It will look a lot like MS Word or Google documents and will have a ton of integrations to make it richer and more efficient.

  PHP 8.1

The Drupal project team has decided to increase the requirement of PHP to PHP 8.1 in Drupal 10. Symfony 6.2 will require PHP 8.1 version and hence the dependency. Since version Drupal 9.1, PHP 8.0 has been supported. PHP 7.4 will reach end of life by November 2022, so if you are using PHP 7.4, it is time to upgrade!


There may be a final replacement of the jQuery UI with modern JavaScript components. Drupal 10 will now no longer support Internet Explorer 11.

Auto-Updating Features

How awesome would it be if your website could update itself?!

With Drupal 10, developers and site builders can automatically enable secure and easy updates. The automatic updates feature will be introduced to Drupal 10 core and is present for completely composer based sites. The Automatic Updates Initiative has done some significant work in areas such as UX enhancements, package deal signing for progressed security and trying out with various host providers.

Decoupled Menus

Drupal is now moving closer to being a headless CMS. The Decoupled Menus Initiative is a huge step in this direction. It can assist to build a number of ways for JavaScript front-ends to apply Drupal website menus. It is a contributed module presently but will be included in core later. Content creators and marketing teams also can replace the menu via the Drupal UI without a developer’s involvement. The changes will be reflected in the JavaScript front-end automatically.

Olivero New Default Front-End Theme

A new and modern Olivero theme is taking accessibility to a whole new level. Olivero will replace Bartik as the default front-end theme for websites in Drupal 10. It is designed to be extremely user-friendly especially for people with vision disabilities. The content material is simple to navigate and the forms have been properly designed too. No issues are found while focusing, contrasting or scaling. Olivero is already stable in Drupal 9.3.

  New Started Kit Theme

There might be a brand new starter kit theme in Drupal 10, providing a new way for theming in Drupal. Developers were using the Classy theme for sub-theming requirements. Front-end developers could have a starting point for themes. It is important to understand that the starter kit changes will not have an effect on the production themes now. It will be easier to maintain. The introduction of the new tool will remove support for Classy as it will be deprecated. It is currently in alpha and is on track to be released by Drupal 10.

Final thoughts

Are you as excited as we are about Drupal 10? You can try out the Alpha release of Drupal 10 right away to play around with it just like we did. All of these new features we discussed will take Drupal’s usability and adoption to a whole new level. In Dries’ words, Drupal has made the web better and it is much bigger than just a CMS. It is used by 1 out of 30 websites in the world and without a doubt has a huge influence on the future of the web. As a Drupal development company, we contribute to the Drupal project so we can make an impact for a better web. If you’re looking to make an impact too, consider joining the Drupal community to contribute and make a difference.

Drupal 10 Drupal Development Drupal Planet Subscribe to our Newsletter Now Subscribe Leave this field blank

Leave us a Comment

  Recent Blogs Image What to expect in Drupal 10 Image Auditing your Drupal Website - A Checklist Image Get started with JMeter for Performance Testing your Website Featured Success Stories

Upgrading and consolidating multiple web properties to offer a coherent digital experience for Physicians Insurance

Upgrading the web presence of IEEE Information Theory Society, the most trusted voice for advanced technology

Great Southern Homes, one of the fastest growing home builders in the United States, sees greater results with Drupal 9

View all Case Studies

Community Working Group posts: Evaluating Drupal's Code of Conduct

Planet Drupal - Mon, 2022/05/23 - 10:25pm

Over the past couple of years, the Drupal Community Working Group has talked about reviewing and possibly updating the existing Drupal Code of Conduct. The process has had several starts, but mainly due to contributor bandwidth hasn't gained much traction to this point.

As reported in 2019, 

The current Drupal Code of Conduct was adopted in 2010 and last revised in 2014. Over the last two years, the CWG has received consistent feedback from the community that the Drupal Code of Conduct should be updated so that it is clearer and more actionable.

In the two years since, the Community Working Group has had several meetings focused on the Code of Conduct. They have identified some tasks, goals, and challenges including:

  • Reviewing Codes of Conduct from other communities.
  • Reviewing the findings from the community discussions led by Whitney Hess in 2017. 
  • How best to gather and utilize community feedback.

Recently, a group of Community Health Team members met to kickstart the process once again in hopes of finding the proper balance of tasks and timeline to determine what, if any, updates to the Code of Conduct are necessary. Community Health Team members at the first meeting include: 

The group, led by George DeMet, is still in the initial planning stages, trying to figure out a rough outline of tasks to achieve the goal. Our first activity was to work with a list of tasks and challenges to refine and organize them into logical groups, such as "project goals", "what are we missing", and "action items".

Snippet of the CoC update jamboard

We are still in the very early part of this effort, but are determined to keep momentum by having bi-weekly meetings, along with a blog post (like this) after each meeting to keep the community informed on the progress that’s being made and share opportunities for community participation.

Questions? Concerns? Let us know in the comments below!


Talking Drupal: Talking Drupal #348 - A Website’s Carbon Footprint

Planet Drupal - Mon, 2022/05/23 - 8:00pm

Today we are talking about A Website’s Carbon Footprint with Gerry McGovern.

  • Earth day
  • What is a carbon footprint
  • How do websites contribute
  • How can you calculate your site’s impact
  • Cloud vs dedicated hosting
  • How do you determine a vendor’s impact
  • Small sites VS FAANG
  • How to improve your site
Resources Guests

Gerry McGovern - @gerrymcgovern


Nic Laflin - @nicxvan John Picozzi - @johnpicozzi Chris Wells - - @chrisfromredfin


Config Pages At some point I was tired of creating custom pages using menu and form API, writing tons of code just to have a page with an ugly form where a client can enter some settings, and as soon as a client wants to add some interactions to the page (drag&drop, ajax etc) things starts to get hairy. The same story was with the creation of dedicated CT just to theme a single page (like homepage) and explaining why you can only have 1 node of this type, or force it programmatically.


DrupalEasy: Replacing Docker with Colima for use with DDEV - first impressions

Planet Drupal - Mon, 2022/05/23 - 6:15pm

Back in March, 2022, the DDEV team announced support for Colima, an open-source Docker Desktop replacement for Mac OS X. Based on the fact that Colima is open-source, Docker Desktop's new license terms, and the apparent performance gains of using Colima it seems like a no-brainer to give it a spin.

First off, it's almost a drop-in replacement for Docker Desktop. I say almost for one reason, as any existing DDEV projects will need to have their databases reimported. In other words, if you have an existing project up-and-running in DDEV, then add Colima, then restart the project, your database won't be found. The easy fix is to first export your database, then start Colima, then import it. Easy.

The reason for this (as I understand it) is because Colima uses the open-source Lima project for managing its containers and volumes (the latter being where DDEV project databases are stored). 

For those of us that are casual Docker users (outside of DDEV), one confusing bit is that we still need the open-source docker client installed - which is installed by default with Docker Desktop for Mac. The docker client is used on the command line to connect to the installed Docker provider (Colima or Docker Desktop for Mac, in this context). If you want to go 100% pure Colima and you uninstall Docker Desktop for Mac, you'll need to install and configure the Docker client independently. Full installation instructions can be found on the DDEV docs site

If you choose to keep using both Colima and Docker Desktop then when issuing docker commands from the command line, you'll need to first specify which containers we want to work with - Docker or Colima. More on this in the next section. 

How I use Colima

I currently have some local projects using Docker and some using Colima. Once I understood the basics, it's not too difficult to switch between. 

Installing Colima alongside Docker Desktop for Mac and starting a fresh Drupal 9 site
  • To get started, I first installed Colima using Homebrew "brew install colima"
  • "ddev powerof"f (just to be safe)
  • Next, I started Colima with "colima start --cpu 4 --memory 4" The --cpu and --memory bits only have to be done once. After the first time, only colima start is necessary. 
  • Next, I spun up a new Drupal 9 site via "ddev config", "ddev start", etc... (It is recommended to enabled DDEV's mutagen functionality to maximize performance). 
Switching between a Colima DDEV project and a Docker Desktop for Mac DDEV project
  • "ddev poweroff"
  • "colima sto"p
  • "docker context use defaul"t - this is the command I alluded to above that tells the Docker client which containers we want to work with. "default" is the traditional Docker Desktop for Mac containers. When colima start is run, it automatically switches docker to the "colima" context.
  • "ddev start" (on an existing project I had previously set up while running Docker Desktop for Mac).

Technically, starting and stopping Colima isn't necessary, but the "ddev poweroff" command when switching between the two contexts is. 

Also - recent versions of Colima revert the Docker context back to "default" when Colima is stopped, so the "docker context use default" command is no longer necessary. Regardless, I use "docker context show" to verify that either the "default" (Docker Desktop for Mac) or "colima" context is in use. Basically, the "context" refers to which Docker provider the Docker client will route commands to. 


Overall, I'm liking what I see so far. I haven't run into any issues, and Colima-based sites seem a bit snappier (especially when DDEV's Mutagen functionality is enabled). I definitely foresee myself migrating project sites to Colima over the next few weeks.

Thanks to Randy Fay for reviewing this blog post. Randy is the lead maintainer of the DDEV project. If you use DDEV, then you should support the DDEV project!


Drupal Association blog: Imre Gmelig Meijling joining the Board of Directors

Planet Drupal - Mon, 2022/05/23 - 3:53pm

The Drupal Association is proud to announce our newest Board of Directors member, Imre Gmelig Meijling. Imre will serve out the remainder of the term for Pedro Cambra, who resigned from the board in March 2022 after serving 1.5 years of a 2-year term. We're happy Imre is willing to step up and contribute to the Board this year.

Involvement with Drupal

Imre has been involved with the Drupal community since 2005 and was the Chair of the Board of the Dutch Drupal Association. He is a co-organizer of the Dutch Drupal camp Drupaljam and started the Splash Awards in 2014. He has also been an active contributor to DrupalCon Europe for the past few years as a member of the DrupalCon Europe Advisory Committee. Imre has worked for various agencies in Europe, creating Drupal adoption and raising awareness for Drupal within regional and international brands and communities. Besides being a Drupal volunteer, Imre is co-owner of Drupal agency React Online in The Netherlands. 

During the most recent at-large community elections, Imre came in second place, which makes him a natural fill-in for the at-large community elected position. Imre is excited to share his experience and join the Board, where he will help amplify Drupal's position and message across the global community and organizations.  

You can read more about Imre on his candidate page.  

The Drupal Association is a non-profit organization focused on accelerating Drupal, fostering the growth of the Drupal community, and supporting the project’s vision to create a safe, secure, and open web for everyone. Are you using Drupal or are you a Drupal community? Feel free to connect.


Danny Englander: Implementing a React App and Connecting it to a Custom Drupal Block to Pull in Remote API Data

Planet Drupal - Mon, 2022/05/23 - 7:00am

These days, Drupal core out of the box is sufficient for many website use cases and with the advent of Drupal 8 and 9, one can build a highly functional site with minimal contrib module add-ons. In the past few years, decoupled sites have also become quite popular which usually means a separate front-end framework such as Gatsby / React that queries data from a Drupal data endpoint, typically using something like GraphQL as middleware.

But there are also points in between where you might do something like "progressive decoupling", such as a custom block that is built with React and integrated right inside Drupal. At my current job, I was recently tasked with needing to pull in data from a remote API and have it render as a custom Drupal block. I decided upon using React for this task utilizing the Axios library, a promise based HTTP client for the browser and node.js, which is superb at pulling data from remote APIs.

Basic recipe

Here is an outline of the basic "ingredients" I used for this project.

  1. A custom Drupal module, react_jobs_teaser that will contain our React app, a custom block, and a Twig template for the block
  2. The React app pulls in data from the remote API via Axios
  3. Create a custom Drupal block in react_jobs_teaser/src/Plugin/Block/ReactJobsTeaserBlock.php
  4. Create a Twig template for the custom block with an ID that the React app will target viaReactDOM.render()
  5. A Drupal field that is rendered in the theme that the React app will target so as to make the API data contextual for each node
  6. Render the block in a theme template using Twig Tweak
  7. Expose the custom Drupal field data to React in the same theme Twig template
Getting started: the React app

The basic idea here is to build the React app and test it inside its own environment and then wire it up to Drupal for seamless integration. For my project, I used create-react-app which is a quick way to get up and running with a simple one page React site. We pull data from the USA ...


#! code: Drupal 9: The Correct Way To Redirect A Page

Planet Drupal - Sun, 2022/05/22 - 8:14pm

I was recently working with a Drupal 9 site and found some strange behaviour when saving certain types of content. The page would appear to save, but much of the content appeared to be missing. It had even failed to generate the paths for the page based on the path auto rules.

Digging deeper I found the root cause of the problem was an improperly created redirect in an insert hook within custom code written on the site. This code looked for the creation of a particular content type and then forced the redirect to happen.

This was more or less the code in question. 

use Drupal\Core\Entity\EntityInterface; use Symfony\Component\HttpFoundation\RedirectResponse; function mymodule_entity_insert(EntityInterface $entity) { if ($entity->getType() == 'article') { (new RedirectResponse('/node/' . ($entity->id())))->send(); exit(); } }

This isn't great code in itself, but the worst part is the call to the exit() function. This stops any code execution straight away, which is what caused out content type to be half created. By stopping code execution like this we are preventing any other hooks or services from acting upon the content type being inserted.

The secondary effect of this is that it also bypasses Drupal's shutdown functions. When Drupal starts a page request is registers a few methods that are to be called as the page response is closed down. This includes session management methods, but can also include a cron handler (if cron has been configured like that).

There is probably a reason why the exit() function was added. by default Drupal will perform a redirect after creating a page and I think the original developer was probably trying to prevent the upstream redirect from taking place. Unfortunately, they ended up creating more problems than just a redirect issue.

Read more.


Drupal Association blog: In Mourning and Recognition of Buffalo, Dallas, and Laguna Woods

Planet Drupal - Fri, 2022/05/20 - 4:04pm

* Content Warning: Racial violence, death, racist language * 

It’s Asian Pacific Islander American Heritage Month. This is usually one of my favorite months of the year, when I celebrate the rich culture and heritage of my fellow Asian Americans. We were excited to celebrate APAHM here at the Drupal Association, with the elevation of news and resources to support AAPIs in technology. 

But we can’t celebrate right now. Right now, it’s important to talk about the hate crimes over the last week and a half. It’s just 2 months after the 1 year anniversary of the attack on Asian women working in spas in Atlanta. This week feels frighteningly similar, with Korean hair salon workers being the target of anti-Asian violence in Dallas. Race- and gender-based violence is well-documented in the United States and has only escalated in the wake of COVID 19. 

Dallas is not the only instance of racial violence this month. Within days of each other, an attack on Taiwanese parishioners in Laguna Woods and Black community members at a Buffalo grocery store would follow. Buffalo being the deadliest of the 3, and the only one specifically linked to radical white supremacy. The perpetrators of these crimes are different races but are all driven by racial bigotry. It is also not lost on any of us that the majority of victims of all 3 of these violent attacks are our elders, who are undersupported and under-protected

This week, Asian and Black Americans are grieving, are frightened, and are exhausted. Racial violence in America is an ever-present threat to our communities and our people. We don’t move through the world separated from this threat. I would ask you to extend patience and grace to your Black and Asian staff this month. But beyond that, I would ask you to extend your support to Black and Asian folks, inside and outside of your workplace. These hate crimes don’t exist in a vacuum, and vicarious trauma is very real. It is debilitating to see people that look like you and the people you love continuously experience racial violence. 

The shooter in Buffalo cited his admiration for “East Asians” in their ethnic homogeneity, which may further the division between Black and Asian communities. Asian Americans are an invisible “minority” in the United States and are often pitted against Black Americans. Racial tension between the two racial groups is documented and ultimately displaced. The work to end Anti-Asian and Anti-Black racism is intrinsically intertwined, and we have a beautifully rich history of solidarity that continues today. 

I compiled some action steps you and your organization can take to show up for Black and Asian Americans this week and every week. I feel fortunate to be given the opportunity to engage the Drupal community on these events and to not have my voice silenced. I hope you will take some or all of these actions, and share them with your communities: 

  • Check on your Black, Asian-American, and/or Pacific Islander employees to understand how they are doing, especially if they are working from home, and see if they need any support. Then, accommodate their needs even if it’s outside your usual policies.

  • Continuously unpack your own bias against Black and Asian Americans with active learning and action. 

  • Get involved in the anti-racism movements in your local community.

  • Understand technology’s role in racial violence. 

  • Join the Ascend Action Agenda 

  • Donate to Resource Council of WNY to provide food and resources for the Buffalo community left without their only grocery store 

  • Donate to the Dallas/Fort Worth Chapter of the Korean American Coalition 

  • Support ​The Orange County Asian and Pacific Islander Community Alliance (OCAPICA)

  • Donate to the victims and families affected in Buffalo  

  • Donate to the families affected in Laguna Woods 

The Drupal Association will still elevate BIPOC voices, and continuously condemn acts of racist, hatred-driven violence. I will still celebrate APAHM with my community this month, and I hope you will too. I will still show up for Black Americans, Asian Americans, and all marginalized people in my work and in my life, and I hope you will too. 

I will also take it slow and allow myself to process and grieve as needed. To my Black and Asian siblings, I hope you will too. 

Articles referenced in this blog: 


Chapter Three: How to progressively decouple your Drupal site with Next.js and JSON:API

Planet Drupal - Thu, 2022/05/19 - 11:43pm
At Chapter Three, we believe that most Drupal websites could gain a performance boost by going headless. While this is how we’re planning to build future Drupal sites, we understand going all in on headless might not be feasible for existing sites. This is why we built next-drupal for progressive adoption: decouple your Drupal site page by page, content type by content type, one at a time. In this post, we’ll take a look at how we can decouple one content type from an existing Drupal site. We are going to take our own site as an example.

DrupalCon News: DrupalCamp Spain on June 3 to 5 in Zaragoza

Planet Drupal - Thu, 2022/05/19 - 10:35pm

One week of Drupal presentations, trainings and networking. 3 to 5 June.


Promet Source: 10 Reasons to Love Drupal 9

Planet Drupal - Thu, 2022/05/19 - 6:54pm
Next month marks two years since the release of Drupal 9, and among the hundreds of thousands of site owners who have migrated, there’s a general consensus that D9 is a bit of a masterpiece with unrivaled scalability, security, and flexibility. 

Evolving Web: Join the Evolving Web Team at DrupalCamp New Jersey 2022

Planet Drupal - Thu, 2022/05/19 - 6:24pm

DrupalCamp New Jersey has been held annually since 2012, and this year, as the event’s diamond sponsor, Evolving Web will be there hosting a number of sessions on various subjects, ranging from Drupal migration to user experience and project estimations.

One Day to Learn About All Things Drupal

In 2022, DrupalCamp NJ is focusing on topics of interest to Drupal users with a range of experiences and responsibilities. Topics include performance, accessibility, design, decoupled architectures, and much more. The camp will be one day full of activities, with 20 sessions and many opportunities to connect, learn, and contribute.

The camp will take place at Princeton University, with which we proudly partnered on several Drupal projects: Princeton International, Princeton University School of Public and International Affairs, and Princeton University Press.

Apart from hosting sessions, the Evolving Web team will be there to connect with other Drupalists, talk about Drupal, discuss projects, and also organize a prize draw for free training: just drop by our booth, leave your contact info, and wait to see if you’re the lucky winner!

👩‍🏫 Boost Your Drupal Knowledge with Our Upcoming Training Courses

Our Team’s Sessions

If you’re planning to attend, you can find DrupalCamp NJ’s full list of sessions. Also, if there’s any topic you’re missing, you can always submit your idea as a Birds of a Feather session, informal gatherings to discuss a certain topic without a pre-planned agenda.

Now let’s take a look at the sessions our team is presenting at DrupalCamp NJ this year:

  • Drupal Project Estimation, for Fun and Profit, by Alex Dergachev & Rukmini Halliwell

Being able to accurately estimate the time required to develop a product or feature is crucial for every Drupal developer. Whether you’re on the buying or selling side of a project, a mature estimation process can make the difference between project success and failure.

In this session, Alex and Rukmini will discuss the mysterious art of software estimation and show our basic Drupal estimation spreadsheet model, based on factors such as the number of content types, number of expected pages, content migration, and other parameters.

  • User Experience: How to Make Design Decisions that are Data-Driven, User-Centric, and Stakeholder-Influenced, by Suzanne Dergacheva

When we design user experiences, decide on information architecture, or prioritize content on a homepage, we must take all useful inputs into account, whether they’re data-driven or coming from a given stakeholder. This is a delicate balance, though, and it’s useful to know which metrics to focus on and what methods help us make different types of decisions.

In this session, Suzanne will talk about user research techniques, the pros and cons of data-driven design and content decisions, how to get the most value out of stakeholder input, and the dangers of “design by committee”.

  • Drupal Loves Composer, and You Can Love It Too, by Kevin Porras

With the Composer Support in Core Initiative, the adoption of Composer by the Drupal community has become wider. However, as good as it is, Composer can be intimidating and even problematic if you lack some basic knowledge.

Kevin will tell you about the basics (and not-so-basics) of Composer, including creating a Composer project, adding dependencies to it, dealing with merge conflicts, dependencies resolution problems, and popular Composer plugins.

  • Any Content Site Can Be Migrated to Drupal: I'll Show You How, by Jorge Diaz

In this session, Jorge will present how five completely different websites were migrated to Drupal. He will map out the process in detail, from the original legacy website to the final end product, giving a full perspective on the migration process.

  • Regression Testing with SiteDiff and Playwright, by Robert Ngo & Alex Dergachev

As part of building and maintaining Drupal projects, code changes and updates are progressively introduced and integrated into the code base. Sometimes, even a small change to a line of code can introduce unforeseen consequences.

To avoid that, regression testing ensures existing functionality continues to work after you make updates. To make this efficient and ensure that tests are run consistently, automating the testing process is essential. In this session, Robert and Alex discuss some use cases for SiteDiff and Playwright, two complementary regression testing tools.

We’re very excited about this year’s DrupalCamp NJ. This will be another great opportunity to learn, build connections, have fun, and make the Drupal community stronger. See you there!

About DrupalCamp NJ 2022

When: Friday, May 27, 2022

Where: Princeton University, Princeton, NJ, 08544

Register for DrupalCamp NJ here

+ more awesome articles by Evolving Web

Palantir: My Events Life Post-COVID

Planet Drupal - Thu, 2022/05/19 - 2:00pm

How an events professional turned communications manager got back her groove

How It Started

I missed the magic of events.

Having spent the majority of my life in the “before times” organizing, planning, and executing strategic events for organizations ranging in nature from small nonprofits to medium-sized private sector to large-scale public sector, events have always given me an energy that is hard to describe. There is a profound and extraordinary element to witnessing, in real time, the result of my weeks of hard work. It makes me want to wave my arms wildly and announce to anyone in earshot, “Hey, look! You see that awesome event? I did that!”

I ended 2019 knowing that 2020 would be the best events year yet. As an independent strategic communications and events consultant in Washington, D.C., I had clients lined up - there were weddings to plan, conferences to schedule, and trade shows to organize.

How It Transformed

Well, that didn’t go as planned.

Events transitioned to Zoom, or Google Meet, or to less than five people if it was in person. Happy occasions that should’ve been celebrated were dulled and diluted, and professional events electrified by the annual expectation of seeing old friends and meeting new faces came to a starkly bleak and screeching halt.

I didn’t know what to do.

I found myself limited, concerned, uninspired, stuck. I had lost my events fix, and it was becoming exceedingly apparent and incredibly difficult to navigate.

Then I moved from the East Coast to the Midwest in search of a fresh start - one that hopefully, at one point, would include a live event or two.

Within four months, I began my journey as Communications Manager with, which was the beginning of one of the best professional experiences of my life. And then, only about a year and a half later, I had the opportunity to attend DrupalCon.

For the record: I had zero experience in the open source tech industry, and had only a basic knowledge about what open source even was. Needless to say, I was also a complete stranger to Drupal and its community.

How It Went

Also for the record: DrupalCon was an absolutely amazing experience.

  • I got to see some of my colleagues again for the first time in months, and met some others for the first time, in person.
  • I got to have an amazing dinner with fellow Palantiri at Grain and Gristle. Its website offers farm fare, a locally-focused bar, and warm service - and we received all three.
  • I got to meet and connect with Drupal community members from companies big and small, both familiar and unfamiliar to me.
  • I went to informative classes with insightful speakers and insightful fellow attendees  - my highlight was The Women in Drupal Luncheon, which was an enlightening, empowering, and wholly collaborative experience.
  • I went to three after-conference events, where I got to know fellow Drupal community members on a personal level, from a rave at the Oregon Museum of Science and Industry, hosted by Acquia; to a much-needed chill night spent laughing on a gorgeous patio hosted by; and, the highlight of my afterparty experience, was meeting Caesar the No Drama Llama and dancing to an epic band covering '80s and '90s classics with The Goonies playing in the background, hosted by Pantheon.

Needless to say, I was exceptionally exhausted but exceptionally happy to be back in the in-person events world. It was something I didn't know I had craved and needed until the first hour into the conference. But after those 60 minutes? I was all in and couldn't have enjoyed it more. 

How It'll Go

From here, I have every intention to attend DrupalCon 2023 in Pittsburgh.

I also had the pleasure of connecting with folks who welcomed me into becoming involved with MidCamp - an event resuming in-person in 2023, which offers four days of Drupal fun including (but certainly not limited to) a community introduction day, livestream social, unconference, and contribution day.  

So, how does it go beyond that?

In my estimation, it goes very, very well. I feel like a full member of the Drupal community - a member who can provide input, connection, events advice, collaboration, and, most importantly, support.

It's a good feeling, and I'm glad to be back.

See you next year, Pittsburgh! 

Photo by Rachel Waddick featuring the Drupal drop

Community Drupal Events Open Source People

Drupal Association blog: GAAD Pledge 2022 - Extending Drupal's Accessibility

Planet Drupal - Thu, 2022/05/19 - 7:00am

Posted on behalf of the Drupal accessibility maintainers.

The Drupal community is again celebrating Global Accessibility Awareness Day (GAAD) but this time we are excited to also announce that the Drupal CMS has taken the GAAD pledge to formalize accessibility as a core value of our framework. Our commitment to accessibility isn’t new, but we are excited to join React Native and Ember JS, previous GAAD Pledgees, to be a public open source leader in pushing forward accessibility to the community.

Digital accessibility is an important issue because so much of our lives are currently mediated through the internet. Globally, over a billion people have some form of permanent disability. Not all people with disabilities face barriers on the web, but when looking at temporary and situational disabilities, they can affect us all. The Drupal community proudly includes people with disabilities. The million or so Drupal sites serve people with every combination of visual, mobility, auditory, physical, speech and cognitive disabilities.

Drupal has been a leader in CMS accessibility for over a decade. Drupal community events (local and global) have had presentations about WCAG and ATAG for nearly 20 years.

Drupal 7 (2011) embraced WCAG 2.0 for both the front-end and back-end of the interface. This is still uncommon for CMSes. As a blind developer, Everett Zufelt was key to bringing the community onboard with this. Everett led many of the early Drupal 7 discussions and became Core’s first Accessibility Maintainer. We were early adopters of ARIA and added limited implementations to Drupal years before ARIA 1.0 was released. We were one of the first CMSes that tried to build standardized patterns designed explicitly to address common accessibility problems.

Drupal 8 (2014) was one of the first CMSes to adopt ATAG 2.0 to support authors in creating more accessible content. We introduced a means to manage aria-live for dynamic content and control the tab order for keyboard-only users. Drupal made many advances in accessibility such as improvements to form errors and requiring image alt text. This release also benefited from the work of Vincenzo Rubano, a blind Italian student who contributed to Drupal Core. In this release we also took on broader adoption of ARIA and started deploying elements of WCAG 2.1.

There is a lot more in the works for Drupal 9 and 10. Drupal 9 saw the introduction of two new accessible themes, Claro and Olivero. Olivero is now our default theme, and named in memory of Rachel Olivero, a stand-out member of the Drupal Diversity and Inclusion community. Rachel, a blind user, also worked with the NFB (National Federation of the Blind) on building their web platform on Drupal. The NFB was generous enough to review this new Drupal theme prior to release.

Drupal was one of the CMSes represented in the We4Authors Cluster, with other CMSes used by governments in the European Union. Drupal is also looking ahead at WCAG 2.2 and WCAG 3.0, with one of our Accessibility Maintainers actively involved in the Working Groups for these guidelines.

We have done a lot, but accessibility is a journey. As long as Drupal continues evolving to keep up with ever emerging internet and accessibility technologies, there will be more to do.

Our 2022 Pledge
  1. Accessibility is a core value of the Drupal CMS, all Drupal websites, and our events (Our community embraces accessibility).
  2. In 2022 we will formally upgrade our standards to WCAG 2.1 AA (Our community process and project governance will continue to align with the latest recommended release of the WCAG guidelines).
  3. We will publish a new coding standards document to clarify our accessibility practices (Accessibility isn’t currently in our coding standards).
  4. Our documentation will be updated to ensure that it includes current best practices (Updating documentation is something that always needs to be done).
  5. We will continue tracking accessibility issues for all projects and tagging them for transparency.
How You Can Help

We also invite everyone to help make Drupal a more accessible framework. There are lots of ways to get involved! Here are a few ideas:

  • Download the latest version (ideally the Git release) and test for accessibility. This could just be using
  • Contribute accessibility bugs that you find back into the Drupal issue queue. Make sure to tag them with “accessibility” and ensure that you have included how to replicate the barrier.
  • Review the modules you are using in your site and contribute where you can to make them more robust and inclusive. Remember to tag those issues with “accessibility” as well.
  • Look through the We4Authors Cluster suggestions and see if there are opportunities to improve the support we are able to provide to authors.
  • Provide feedback to the team by joining the #accessibility channel on the Drupal Slack.

Today we reaffirm our commitment to accessibility by taking the GAAD Pledge. As we continually improve Drupal, accessibility will be a core part of what we do.