Drupal Planet

Over the past two years, it took a few blog posts for me to fully explore and explain how to use Schema.org as the foundation for content models; this exploration led me to create the Schema.org Blueprints module. Early into its development, three goals became apparent - they became the intro on the module's project page.

These concrete goals helped me focus on the module's core functionality and APIs, yet none of these "primary" goals acknowledge my underlying desire to use Schema.org as a collaborative, open source foundation for building websites and applications using Drupal core and its vast ecosystem of contributed modules.

Open source software development has so many nuances; writing and sharing some code online with an MIT license is not always enough. For example, after an experienced developer determines an open source project addresses their business requirements, they have to ponder if this "free" source code is stable and maintainable.

I recognize that the Schema.org Blueprints could be the foundation for applications or websites built using Drupal's ecosystem of contributed modules. The Schema.org Blueprints module's code needs to be compatible, stable, maintainable, and extendable, and this led me to expand my primary goals to include secondary and tertiary goals.

Below is my complete list of goals for the Schema.org Blueprints module.

Primary
Content modeling

1. Structured Data
2. Application Program Interfaces (APIs)
3. Search Engine Optimization (SEO)

Secondary
Content authoring

1. Administration interface
2. Content authoring
3. Multilingual support

Tertiary
Collaboration

1. Open source
2. Modular and extendable
3. Stable and reliable

I’ll be the...Read More

DXPR Builder, the only Drupal page builder with a proven track record on enterprise scale Drupal platforms will have its first major update this summer!

We are excited to present a completely new visual live editing experience that will speed up content authoring and editing even more! 

DXPR Builder 2.0.0 live editing demo. The depicted product design is not final.

When editing your Drupal content all of the changes you make with DXPR Builder will appear on the page in real time! The new editing experience is super fast and responsive. It's practically instant! DXPR has always put user-experience first and software performance a close second. The result is the most fluent and intuitive content authoring experience you've ever seen!

When DXPR Builder 2.0.0 comes out we will offer new subscriptions. They will be priced similarly to our current offering but we will offer a monthly billing option alongside yearly billing. 

Along with this change we made DXPR Builder 2.0.0 completely GPL compatible. With our updated subscription terms, you no longer have to pay for a DXPR subscription for the lifetime of the web content you product with DXPR Builder. Instead you only pay as long as you need the editor!

No vendor lock-in, no content lock-up. When your website is "finished" or you simply don't need editing capabilities for a while, you can cease the subscription and not pay a dime while the DXPR Builder module remains installed. DXPR's unique features like circle counters, countdown timers, etc., will keep working after you stop the subscription.

Only when you need the DXPR Builder editor again you will need to reactivate your subscription.

For sites running DXPR Builder 2.x we are not charging anything per site. We believe the value of DXPR Builder is all in the productivity gains and happyness improvements for your content and communication talent. 

We are emphasizing this by getting rid of Site Licenses and keeping "DXPR Builder Editor Users" as the only "billable usage". To aid with this change we are including user licens dashboards and tools in DXPR Builder as well as at DXPR.com.

The following features are moved from the DXPR Builder enterprise tier to all DXPR Builder 2.x users:

• Content locking
• Unlimited user profiles
• Local video element

We will keep distinguising the enterprise tier with better services, training, and support, while maximixing product capabilities for all DXPR clients.

Can't wait to try the new DXPR Builder experience? We release a new beta version every week. Join our test group to receive the betas:

If you need global state management for your app(s) (and you probably do), a relatively new flavour of Redux called Redux Toolkit makes this considerably easier. Redux Toolkit includes a number of functions which make reusing similar "slices" of state quite easy, however there is a missing piece to this puzzle that will make things seamless!

This article assumes an understanding of (on the React side) Context, hooks, components, (and on the Redux side) actions & reducers, Redux hooks, and at least a little dabble in Redux Toolkit.

Whilst developing a recent project which utilises an Elasticsearch backend to provide a number of independent search interfaces, a need came up to have very similar state management for each application. In Redux there can only be one store, and we put this to the test with an initial prototype that threw caution to the wind and used a separate store for each application. The choice of using separate stores allowed us to easily reuse React components that implemented Redux's useSelector hook to retrieve data from the store.

However, it quickly became apparent that Redux had not been designed to work this way. Redux's excellent dev tools stopped functioning as intended, and the dev tools being a big driving point behind using Redux in the first place - meant we had to rethink our implementation.

The initial build featured a suite of reusable components that each implement useDispatch and useSelector to act on their independent state management. Take a Pagination component for example. It needs to keep track of which page a user is currently on, as well as update the current page. A useSelector hook allows it to retrieve the current page, and a useDispatch hook allows it to call an action which updates the current page.

Our architecture has a top level App component which is unique for each search application. It acts as a container and wraps the layout and components. In our initial prototype it implemented it's own store and Redux's Provider component so the child components could implement Redux hooks directly.

So with a shared store, this architecture was at risk of becoming very complex. The App wrapper would need to implement the hooks and actions itself, and then pass them down via Context or props so child components could access the correct data and actions in the store.

Instead of doing this we came up with something new.

The updated architecture uses a React Context Provider to pass the applications "slice" down via Context. Then a custom useContext hook allows each reusable component to access store data and actions for that slice, without needing to be aware of which slice they are part of.

Let's look at it from the top.

A single global store is broken up into slices using the Redux Toolkit createSlice function. Each slice has its own name, initial state, reducers and actions.

Each application has it's own container which implements a Context provider called SliceProvider, which imports the slice and allows that to be accessed across the application.

All child components can then be shared and access the state slice via a series of custom hooks that implement useContext.

When you view things through Redux Dev tools, this is what it looks like:

To take a look at things I've spun up an example application, with two search interfaces - a "global" search and an "image" search.

The index.js looks like this, All it's doing is wrapping everything in the Redux `Provider`:

And our App.js combines both applications purely for demonstration purposes so we can see them working on screen in tandem:

Now components under each SliceProvider will have access to their slice of the shared store.

With this pattern, reducers are reusable chunks of logic. We'll maintain and export them from a reducers.js file:

If you haven't used Redux Toolkit yet, this simplified syntax for reducers makes it a clear winner. Also there is no need to use the Redux Toolkit createReducer function, as that is called below with createSlice.

Let's take a look at slices.js which creates each slice via a function which lets us:

1. Define a default "initialState" for each slice.
2. Define a set of default reducers for each slice.
3. Takes an argument for initialState to override certain values.
4. Takes an argument for reducers so we can add to the default reducers - if one application has more advanced features for example.
5. Includes a way to pass through extraReducers (more on this later).

This approach makes slice creation reusable but extensible.

Our store.js makes use of combineReducers to add our slices.

Now, to the secret magic sauce of this pattern - the SliceProvider context:

And because our components are wrapped in a SliceProvider, the useSliceActions hook allows access to the actions and the useSliceSelector hook allows access to the slice store data (via the Redux useSelector hook).

A child component can then be implemented as so:

Now both applications can share child components that provide totally unique sets of data and actions from each slice!

Now let's take things a step further and come back to the extraReducers piece I touched on above. In Redux Toolkit extraReducers are a way to listen to actions across all slices - meaning we can call an action in one place and have it update data everywhere!

To do this we need to define some actions in actions.js:

We must also write a new reducer which is suitable to be used across the whole store in reducers.js:

Now we can import the action and reducer and use them in slices.js (I love this syntax in Redux Toolkit):

A new component can import the action directly and call it via useDispatch:

This pattern can become very powerful for the following reasons:

1. It utilises all features of Redux Toolkit to provide reusable slices, actions, and reducers.
2. Each slice is completely independent, however it can share capabilities as needed.
3. Any state aware component can access a slice directly and be reused across slices.
4. Components can still update state across the whole store as needed.

Take a look a the example application.

When the marketing department suddenly requires synchronizing some product data from an MS-SQL database into their Drupal 9 site to display that data in a view - and keep that up-to-date on an hourly basis. A quick recipe.

Recently working on a Drupal site, creating new paragraph types as you do… While creating pages and testing the paragraphs, I got the following error: This entity (paragraph: ID) cannot be referenced. This was the first time I ever saw this error.

What I discovered was I accidentally unselected the paragraph type from the “Reference type” section on the entity reference revision field.

This can happen on any entity reference field not just a paragraph field.

If you create a page and reference an entity or create a paragraph. If the content or paragraph type is unselected from the reference type section. The next time you save the form you’ll get the error.

Founded in 2007, Evolving Web is happy to celebrate 15 years of improving the web and empowering organizations across the globe this year.

As one of our colleagues mentioned, a lot can happen in 15 years. We've seen some amazing technological advances. In 2007, Apple launched the iPhone, Facebook and Twitter went global; Kindle and Android were released; Airbnb was founded; Google bought YouTube; and IBM created its artificial intelligence system, Watson. 

And it's not just the tech sector that's evolving and growing – we're seeing changes across all industries. The way we work is changing, too. We're more connected than ever before, thanks to the internet and social media. And we're working in more collaborative, flexible ways. 

In 2007, Evolving Web was a 2-person business and is now an international company with 80+ employees and 30+ contractors, representing 22 nationalities, and speaking 30+ languages. This is the story of how we got here.

Alex & Suzanne, Evolving Web founders 

Evolving Web started from a passion for improving the web experience and making websites easier to use for everyone. Straight out of university, co-founders Alex and Suzanne started Evolving Web to help people create better websites. From the beginning, the goal was to make a difference in the web experience for everyone.

The very first website Evolving built

As we look back, we’re proud of the impact we’ve had. We’ve partnered with some amazing organizations and worked on incredible projects that have helped shape the web as we know it today. And though a lot has changed, our commitment to making the digital world a better place remains the same.

15 years after Evolving Web was founded, there are a few values that we’ve held on to since the beginning that continue to guide us as we grow:

15 years anniversary cake

We’ve always been firm believers in the power of collaboration and community. We’ve seen how working together can create amazing things. We’ve also seen how building an inclusive and diverse community is essential to this process.

Evolving Web is an open-source company. This means that the work we do doesn’t exist in a vacuum, that it’s part of a larger community of people sharing code, design, and ideas. We believe that by collaborating openly, we can create better products and services that benefit everyone.

We’re also an international company, with employees and contractors located all over the world. This allows us to tap into a wealth of diverse perspectives and skillsets, which helps us create better solutions for our clients.

And finally, we’re an inclusive company. We believe that everyone should have the opportunity to participate in our work, regardless of background or experience. We’re committed to creating an environment where everyone feels welcome, respected, and valued.

"The best thing about working with Evolving Web, is to have the opportunity to be challenged and to grow. There is always something on the horizon that we are trying to accomplish and solve together as a team. It's that sense of collaboration."

Vuong Tong, Design Director

Our goal is to use our skills and expertise to make a positive impact in the world. We work with organizations that are making a difference in their communities, and we strive to create products and services that have a positive social and environmental impact.

We pride ourselves on training hundreds of Government of Canada employees to be more digitally savvy, helping their teams function better. We’ve also had the opportunity to work closely with the web services teams of universities across Canada to create or upgrade their underlying website platforms that back thousands of websites, including McGill University, Trent University and the University of Waterloo. 

Further, our contributions to Drupal multilingual have gone on to benefit millions of users around the world who speak different languages. All of this creates a positive, lasting impact — and we’re proud to have played a role in it!

“For me, it’s the belief in company goals. It’s all about the product with a capital P. It’s not about the portfolio of our prestigious clients or the ego of anyone at leadership.”

Chantal Theriault

The web has evolved from a static medium to a dynamic platform for collaboration and creativity. We’ve also seen how powerful open source tools and technologies can be in empowering people to build amazing things.

As we look to the future, we want to continue to build on these successes by creating more reusable, shareable web components. We believe that by making it easier for people to create and share components, we can help them build amazing things faster.

We’re also focused on continuing to evolve our own products and services. We want to make sure that they are always at the forefront of the latest trends and technologies, so that our clients can always rely on us to help them achieve their goals.

We’re incredibly proud of what we’ve accomplished. We’ve come a long way and we’re excited to see what the future holds. We want to thank everyone who has been a part of our journey so far, whether you’ve worked with us, contributed to our work, or simply been a supporter. We couldn’t have done it without you, and we’re looking forward to continuing to build this amazing community together.

"The family feel that we had 10 years ago, we have to find ways to keep that going as we grow in the next 15 years,"

Alex Dergachev, co-founder of Evolving Web.

As we look to the future, we’re excited to continue evolving and growing along with the digital ecosystem we’re part of.

"We aren’t just growing for the sake of growth. Growth means we can take a more strategic approach with our clients and choose projects we want to contribute to. We are looking forward to working with clients that are making an impact and changing the world for the better. Those are the projects that align with the Evolving Web culture."

Suzanne, co-founder, Evolving Web

Thank you for being a part of our journey! We can’t wait to see what the future will bring.

We answer the questions that we are frequently asked about staying on Drupal 7 as its end-of-life date approaches. 
 

If you find yourself thinking there’s got to be a better way to build a website than hiring a full time developer, you’re probably looking for something like Acquia’s Site Studio. It’s that perfect blend of robustness and usability that lets non-technical users like content editors, designers, marketers, and site owners build brand-compliant, unique websites. Formerly known as Cohesion, Site Studio provides the ability to create elegant and more powerful sites in half the time. Read more about Site studio and how to implement and use it for building beautiful Drupal sites.

As we said earlier, Site studio makes it really easy to build component-based websites. 

Think of components as lego blocks and your website as a house you want to build with these blocks. As a builder, you are assembling various blocks in a way that helps you build your design. So in website terms, a component can be a block of text, an image, a featured snippet, a live Twitter feed, a header, a footer or so much more! All those components together help you complete your house/website design.

• Site Studio provides around 50 predefined components which you can start using immediately like Text, Image, Slider, Accordion, etc. Users can also use custom-built components that have been created by developers.
• It provides an excellent content editing user interface for adding components or templates in the layout by simply dragging and dropping
• It does not require as much time and effort
• Low code makes it appealing to users with less to no knowledge of building pages
• A powerful visual user interface and in-context editor that let’s you edit content directly on a live site
• Empowers users to preview their layout in various devices jus by changing the settings of the device aspect ratios
• Easy to maintain

Normally, to create a block type or paragraph type in Drupal 9, you need to have a specific Twig file for the markup. Then, based on the markup and design, you would write the CSS rules to create a card component. 

However, when building a card component in Site Studio, you use a template of the card that already includes the CSS properties within the component. Then, using its drag-and-drop feature, you can use predefined elements like image, text, and link to create a layout for the card. Each component has a ‘Properties’ tab, where you can control the look of the component. The best part is that all this is done without writing a single line of code.

Let’s get started by first installing and enabling the module and theme.

• Download them with the help of Composer or manually
• composer require acquia/cohesion:6.8.0
• composer require acquia/cohesion-theme:6.8.0
• Enable the modules
• Install the Acquia Cohesion minimal theme from the UI

Once you have successfully installed the module and theme, you will see a new menu item on the admin toolbar called Site Studio. Here’s where you will be playing around with Components, Templates, Styles, Packages, etc (see below).

You can now create a component by navigating to the Components page. You can also see a list of components that are already available on the site.

You can add styles to the Component elements by editing or double-clicking the element and then clicking on the Styles tab. Here you can see all the available styles. You can now add the CSS Styles by clicking on Properties Tab

You can create a page and add your components to the page by just dragging and dropping them into your layout.

You can refer to the official Site studio documentation here

• https://sitestudiodocs.acquia.com/6.9

Site Studio gives you the ability to build websites faster and is useful for everyone - from developers to marketers and even end users. Site managers, Content editors or Marketers can easily add entirely new sections to the website without needing the help of a designer or Drupal development team. They can simply reuse the assets that are available and then add new sections to the website or rearrange existing ones. As a Drupal development company, we can help build custom components to enable you to project your unique brand effectively. Thank you for reading!

Author: Subramanyam

Meet Subramanyam, a Drupal Frontend developer by profession. He dreams of traveling the world (or at least all of India) one day. Aside from working, you can find him guffawing at funny YouTube videos or binge-watching action movies.

Leave us a Comment

I wanted to outline the deployment workflow I use on dri.es, my personal website.

My site uses Drupal (obviously) and runs on Acquia Cloud (of course), but a lot of this is a best practice for any web application.

I manage my website's code and configuration in Git. Each time I commit a change to my Git repository, I go through the following steps:

1. I create a staging environment to test my code before deploying it to production. It's a complete staging environment: not just PHP, MySQL and Nginx, but also Varnish, Memcache, etc.
2. I check out my Git repository. My Git repository hosts my custom files only. It's a best practice not to commit Drupal core or third-party Drupal modules to your Git repository.
3. I run PHP Code Sniffer to make sure my code comforms my coding style rules. I specify my coding style rules in phpcs.xml and use phpcs to make sure my code adheres to them. If not, phpcbf tries to fix my code automatically. I like my code tidy.
4. I run PHPStan, a static code analysis tool for PHP, that scans my code base for bugs. It will find dead code, type casting problems, incorrect function arguments, missing type hints, unknown function calls, and much more. PHPStan is a fantastic tool.
5. I run PHP Unit, a PHP testing framework, to make sure my unit tests pass.
6. I run phpcs-security-audit, a static code analysis tool for PHP. It scans my PHP code for security vulnerabilities and security weaknesses.
7. I run ESLint, a static code analysis tool for JavaScript. It scans my JavaScript code for security vulnerabilities and weaknesses.
8. I run nodejs-scan to find insecure code patterns in Node.js applications. I don't use Node.js though, so this is a no-op.
9. I also run Semgrep, a static code analysis tool for a variety of programming languages.
10. I run Rector to make sure I don't use deprecated Drupal code. When I do, Rector will try to programmatically update any deprecated code that it finds.
11. As my Git repository only has custom files, I use Composer to download and install the latest version of Drupal and all third-party modules and components.
12. I run drush pm:security. Drush is a Drupal-specific tool, and the pm:security option verifies that I have no insecure dependencies installed.

It might sound like a lot of work to set up, and it can be. For Acquia customers and partners, Acquia Code Studio automates all the steps above. Acquia Code Studio is a fully managed CI/CD based on Gitlab, with specific steps optimized for Drupal. It couldn't be easier.

Acquia Code Studio also takes care of automating dependency updates. Code Studio regularly checks if Drupal or any of its dependencies have a new release available. If there is a new release, it will run all the steps above. When all of the above tools pass, Acquia Code Studio can deploy new code to production with one click of a button.

I love it!

Today we are talking about The Project Browser with Leslie Glynn & Tim Plunkett.

www.talkingDrupal.com/358

• What is Project Browser
• How are you involved?
• What is the Drupal Acceleration Team and how is it involved with Project Browser
• Will it be in Drupal 10 or 11?
• How are you organizing module data on d.o?
• How does PB showcase the community working on modules?
• How does PB work with other initiatives like Automatic Updates
• How has management changed over the project?
• Security?
• How is Chris Wells as an initiative lead?
• What makes a good project lead?
• Anything else?

• Drupal Acceleration Team post about things they’ve done
• The Update Framework (used by Automatic Updates)
• PHP implementation of The Update Framework: php-tuf
• Kanban board for content updates
• Upcoming contribution events
  • Drupal Colorado
  • DrupalCon Prague
• Driesnote DrupalCon North America 2021 - Announcing the Project Browser Initiative
  • Start around 50 minutes
• Driesnote DrupalCon Portland 2022 - Drupal 11 - Project Browser
  • The Project Browser section starts around 44 minutes
• Strategic Initiative page
• Project Browser module page
  • Includes link to GitPod to try Project Browser
• #project-browser channel in Drupal slack
  • Meetings (asynchronous in slack)
  • Tuesdays 4:00pm ET - Site builder Subcommittee
  • Wednesdays at 10:00AM ET

Tim Plunkett - @timplunkett Leslie Glynn - @leslieglynn

Nic Laflin - www.nLighteneddevelopment.com @nicxvan John Picozzi - www.epam.com @johnpicozzi Ryan Price - ryanpricemedia.com - @liberatr

Search API Algolia This module provides integration with the Algolia service, through Drupal’s Search API. This module is intended to be used by developers, as it does not currently provide any implementation of an actual search interface. Only indexing is currently supported. As a result, enabling that module will not have any visible effect on your application. Search functionality may be implemented using the Algolia Javascript API.

When looking to use a module from the Drupal community there are a number of factors to consider, beyond its functional use, that determine suitable quality and support for your organisation to use.

When you deploy a Drupal site into production, who is responsible for maintaining it? How long will that site live for? These types of questions shape the risk tolerances of the project. E.g. Lower Drupal competencies means you need greater community support and more stable modules.

All modules on Drupal.org are open source and fall under the GPLv2 open source license. They are free to download and use at your own risk. Each project has its own set of maintainers and a sub-community that uses the module, interacts through issues and contributes bug fixes and feature enhancements.

PHPStan is a great command line tool for looking at how your PHP code will run without actually running it. It's great for finding potential bugs that you wouldn't have otherwise discovered using other tools or through unit testing.

With regards to Drupal projects there is a little problem in that PHPStan doesn't know how to interpret Drupal plugins, entities, controllers or all the other Drupal architecture that goes into a Drupal module. For this reason, if you try to run PHPStan on your module code you'll find that it produces a lot of errors regarding missing objects or incorrect parameters.

Thankfully, it's possible to easily teach PHPStan about Drupal and make the tool more useful when writing Drupal code. First we need to install it.

To install PHPStan into a Drupal site you need to use composer and include the following pages.

The packages we are installing are:

• phpstan/phpstan - The core PHPStan package.
• phpstan/extension-installer - This is a composer plugin for automatically installing PHPStan extensions which means we can load packages into the PHPStan runtime.
• mglaman/phpstan-drupal - PHPStan Drupal is a package created by Matt Glaman that allows PHPStan to understand the Drupal object structure.
• phpstan/phpstan-deprecation-rules - A PHPStan package that will print out deprecation messages, which helps us detect deprecations in Drupal code.

Next, we need to create a configuration file so that PHPStan knows what level to run at and what paths we are interested in. Create a file called phpstan.neon in the root of your project and add the following configuration to it.

Read more.