Symfony Bundle Development #33: We’ve got tests, but it’s time to add another superpower: PHPStan! Static analysis helps reveal sneaky issues your test suite might miss - let's dig in!

Symfony Bundle Development #32: With code and tests locked in, it's time to give our bundle a little polish 💅 — add metadata, clean up docs, tidy exports, and bring in consistent, automated code styling with PHP CS Fixer.

Symfony Bundle Development #31: Bundles don't get to be picky about their dependencies. So, let's widen those constraints and take our test suite on a tour of Symfony versions - including the wild, un-housebroken dev builds.

Symfony Bundle Development #30: Leveling up! 🚀 Let’s upgrade our bundle's integration test to use the object translator service - full entities, real database, the whole deal.

We don’t do sales often. In fact... 🎉 This is our ONE sale of the entire year. Get 40% OFF SymfonyCasts (yes, even if you’re already subscribed). Go learn something awesome! symfonycasts.com/blackfriday

Let's gooo #SymfonyCon Amsterdam! Come by our booth to grab some socks 🧦 and swag!

We're so excited for #SymfonyCon tomorrow! 🚀

We’ve got unit tests, which is fantastic - but nothing beats integration tests that spin up a real Symfony app and show our bundle hard at work. 👷🏽👷‍♀️

Our bundle has been living at home, mooching off our parent app's dependencies. Time to cut the apron strings and set it up with its own - and make sure it can run its tests independently, too!

Step 2 in managing object translations in our bundle: an import command to load translated values - and we'll handle a bug fix along the way.

This bundle is nearly ready for a 1.0 release! The final feature: managing object translations. Step one: an export command to extract all translatable fields. Let's roll!

Like any other service your bundle provides, console commands need a little manual wiring. Let's roll up our sleeves, hook up our warmup command - and squash a few sneaky bugs while we’re at it!

Bundles can totally have their own commands! Let’s create one to prepare the translation cache to keep apps snappy.

Okay, our ObjectTranslator class is getting a bit complex - let's refactor the Doctrine logic into its own class. Phew, that's better!

Add extra context to your PHP classes with zenstruck/class-metadata. This lightweight package lets you define short, readable identifiers for your classes - known as aliases - and attach custom metadata directly to them. symfonycasts.com/blog/package...

It's alllliiivvveee 🧟! Our Caching is up and running! Let’s make it customizable with more bundle config - and see that cache tagging in action.

Performance boost round 2: we'll Use Symfony’s Cache Contracts to cut DB queries - and check out cache tagging!

Time for a Performance boost! We can cut down database queries with memoization (love that word) and use PHP’s WeakMap to keep memory in check. 💥

Our bundle could use a Twig filter. Let's add one and use a Twig runtime to keep things snappy! Oh, and shhh... we'll look at hidden services too. 🕵️‍♀️

Our translations work 🥳 but relying on the idea that all entities will have a getId() method? Kinda risky. Let’s make it rock-solid by letting Doctrine handle ID fetching - no hoping and wishing needed!

Our Setup is done! Now for the real fun, translating our objects 🎉 We’ll fetch + normalize translations with Doctrine and finally see content switch between English & French -- Oh là là!

We need to mark our Doctrine entities as "translatable". Sure, we could use an interface - but let’s be modern (and a little hip) by using PHP attributes instead!

We worked a bit with TDD previously, just getting a feel for it. Now it’s time to really lean in and use it in all its glory—rolling out a brand-new feature completely test-first!

Let's roll up our sleeves, it's time to tackle our object wrapper Twig issue. We’ll replicate the problem in a unit test, then fix it - my favorite way to squash bugs!

Our bundle's object wrapper doesn’t play nicely with Twig. We'll fix that - but first, let’s write a unit test to be sure it works correctly outside of Twig. We'll all sleep better with code that's properly tested!

Our bundle is all about translating objects. How are we going to do this? Well, let's look at some options and implement a solution! Booyah!

Our bundle’s configuration is validated and ready to go, woohoo! Now, let’s put that config to work by injecting it into one of our bundle’s services so it can actually do something useful.

Bundle configuration nodes can have validation rules. These help make sure the user’s value is what you expect - no ‘cheeseburger’ when you wanted a number. Let’s look at some out of the box rules + create a custom rule!

Our bundle needs to know about our entity class. Sounds like the perfect job for bundle configuration! We'll define a "node" and add a description + example to help our future users! Go team!

Our bundle has a Doctrine "mapped superclass" successfully registered. Now we need create the "real" entity in our app, let's go!

Our bundle now has an object to be used as a Doctrine entity ✅. Our next task is to provide mapping information and let Symfony + Doctrine know about it.

Bundles can totally provide Doctrine entities... but there are some tricks. Let's discuss the entity we need, create the class, see some bundle-specific considerations and have a great time along the way 😎

In bundles, services need to be wired manually - just like Symfony apps in 2011! But don’t worry: it’s simpler now. While we can’t use autowiring inside the bundle, we can make our bundle’s services autowireable. Nice!

Our bundle is kinda boring still. Let's spice it up with it's first service class!

Even if you're developing bundles locally, you'll still need to install them with composer. Installation is a little different... but in a good way! We'll even stumble upon a hidden Symfony Flex feature 🌟

A bundle requires just one thing: a bundle class - the nerve center of your bundle. Let's create one, right after we fix a little quirk when working with multiple namespaces in the same project.

🚨 New course alert: Reusable Bundles 📦! Bundle development received a facelift in Symfony 6. Let’s check this out by creating a real, usable bundle that we’ll eventually push to Packagist for all to enjoy. Step 1: Initialize our bundle!

If a message fails repeatedly, instead of discarding it forever, let's send it to... the "failure transport"! Let's get this set up & learn how to find out exactly what advanced options each transport has. #Symfony symfonycasts.com/screencast/m...

Time to look deeper at Messenger's retry settings & more advanced transport config. Retries have an exponential delay built-in to help overcome temporary failures. And of course, you can control all of this. #Symfony symfonycasts.com/screencast/m...

Oh no! You sent your message to a transport/queue, but when it was handled (due to a temporary connection issue) an exception was thrown! Is it lost forever? Nope - Messenger automatically retries it. Let's see retries in action! #Symfony symfonycasts.com/screencast/m...

With deep sadness, we share that Ryan Weaver — co-founder of SymfonyCasts, father, husband, beloved teacher, and friend — has passed away after a long and courageous journey with brain cancer. symfonycasts.com/blog/remembe...

Symfony messenger is all about dispatching "messages". But did you know that you can also wrap your message in an Envelope & attach extra config via stamps? Let's use a stamp to *delay* a message *and* see what stamps are added internally. symfonycasts.com/screencast/m...

What happens if *part* of our handler fails? This is nothing new.... unless *some* of your handler is async. Let's route our second message to be async & learn some advanced features of message routing #Symfony symfonycasts.com/screencast/m...

Half of the work for deleting an image in our app must happen now... but half could happen later. The solution? Split the command into 2 & dispatch from *within* the handler. We're breaking things down into smaller pieces to gain more control. #Symfony symfonycasts.com/screencast/m...

Let's update our Messenger message class to hold the entity id instead of the entire object. That'll fix a bug and follow a nice rule: make your message as small as possible. Bonus: we'll start learning to fail gracefully & see retries in action #Symfony symfonycasts.com/screencast/m...

A quick aside about Messenger, serializing Doctrine entities & (nerd-alert) the identity map! A fun look into a bug in our app and how Doctrine works internally. #Symfony symfonycasts.com/screencast/m...

How can we *consume* messages from the queue asynchronously? By running Symfony’s worker command: php bin/console messenger:consume Dispatching new messages and watching them get handled async automatically? Gorgeous!

Say hello to Messenger transports: the key system that allows you to send message to a queue instead of handling them immediately. Let’s get the Doctrine transport set up, route some messages there and see what it all looks like in the database! #Symfony

We’re putting messenger to work, refactoring a controller down to 2 lines! That’s thanks to a new command class, a new handler and the debugging superpowers of debug:messenger... when I mess up #Symfony

The command (message) class and handler inside Messenger are a team: the message class holds *whatever* data you need to pass around while the handler uses that info (+autowired services) to do the work! It’s refreshingly... simple. #Symfony