Angular and Laravel: Breaking a Monolith to Microservices

Install Laravel by installing composer, paste the installation line in the terminal, customize the app name to Laravel Admin, and start the server with php artisan serve on port 8000.

Configure and run a microservices setup with Docker, Dockerfile, and Docker Compose, linking frontend, backend, and database containers, mapping ports and volumes for local development.

Define a get route returning hello, test with postman at localhost/api/hello, then create a UserController with an index method returning hello and map it to the route to retrieve users.

Learn to set up and migrate the user table in a Laravel docker environment, seed twenty users with a factory, and update controllers to return all users.

Build a Laravel rest api for users with full create, read, update, delete operations—index, show, store, update, and destroy—using resources and secure password handling with proper status codes.

Apply validation for user creation and updates using custom requests in Laravel, enforcing required first name, last name, and email, while omitting passwords and enabling partial updates.

Implement pagination for the Laravel rest API user index to avoid slow queries on large user sets, using a Laravel pagination package and exposing current page, last page, and total.

Learn how to implement user login and protect routes with Laravel Passport, including installation, migrations, user model changes, service provider setup, and passport routes configuration.

Implement login with Laravel Passport by creating an OAuth login controller. Return an admin access token to access private routes, and respond with unauthorized for invalid credentials.

Protect the users resource by adding a route group middleware, enforcing authorization. Access requires a valid token in the authorization header; unauthenticated requests are denied.

Implement the register functionality via a post request, validating first name, last name, email, password, and password confirmation, hashing the password, and creating the user.

Create three user routes in the profile section: get current user, update user info, and update password; implement corresponding controller methods to handle data and password changes.

Create and manage roles in Laravel by building a roles model, migration, API resource, and controller, enabling CRUD operations and testing with Postman while configuring timestamps.

Create a foreign key from users to urls by adding an unsigned big integer and referencing the idea column, then seed roles and assign random roles to users after a fresh migration.

Define and expose user data via API resources, linking users to roles, format responses with UserResource, and return collections with fields and pagination for consistent API results.

Create a products table via migration with title, description, image, and price, then build the model, controller, factory, and seeder to populate 30 sample products in the database.

Implement product routes in Laravel by creating a product resource and methods like index, show, store, update, and destroy. Validate API output with Postman and ensure proper pagination.

Learn how to upload images in a Laravel store and update method, move files to the public folder, generate random image names, and store the image URL on a product.

Introduce a dedicated image controller to upload images and return a URL, enabling products to store the URL and support create/update image requests with mime-type validation.

Create and seed the orders and order items schema with migrations, models, factories, and seeders; establish a one-to-many relationship and populate purchaser details, product titles, prices, and quantities.

Expose index and show routes for orders, and build order and order item resources with has many and belongs to relationships to return basic order data and items.

Learn to add a computed total attribute in Laravel by summing each order item’s price times quantity, exposing it as a property via getTotalAttribute for API responses.

Export orders to csv file by defining headers, setting content type to text/csv and content disposition to attachment, then stream order and order item data via a Laravel export endpoint.

Create a permissions table and a role-permission pivot to enable a many-to-many relationship, seed permissions, and assign admin, editor, and viewer roles with rights like view users and orders.

Create permissions alongside roles using a belongs-to-many relationship with a pivot table, and expose a role resource with id, name, and permissions; update by replacing permissions.

Add a dedicated permissions field to the authenticated user api for the front end, via a user model method and a resource extra field, exposing permission names.

Learn to implement a Laravel permission controller and a permission resource, exposing an index method that returns a permission resource collection for an API.

Explore implementing Laravel gates to restrict routes by user permissions, defining view and edit abilities in the service provider, and enforcing access in controllers.

Apply gates to controllers and requests, enabling authorization checks such as editing users, and decide where to implement gates for the preferred approach.

Build a dashboard chart by joining orders with order items, grouping by date, and summing daily totals (quantity × price) formatted for the Laravel API.

Secure login stores a JWT in an HttpOnly cookie, enabling front-end unaware authentication, while logout removes the cookie and middleware reads it to set authorization.

Install the required tools and dependencies, then create a new Angular project named admin with routing. Start the development server and open localhost:4200 to verify the setup.

Open the Angular project, apply a bootstrap dashboard template, and copy the styles; run ng serve and load localhost 4200, then remove the chart placeholder for future plugin use.

Split the email feature into navigation and main components, generate them in the terminal, and wire them with the selector to update the model and display the menu and dashboard.

Learn to break a monolith into microservices by creating public and secure models, assembling a secure module with admin components, and wiring imports and declarations in the Angular app module.

Create the public module's logging component, implement a bootstrap login form, add and configure the login route, and use an outer outlet to render it in the browser.

Create and connect child components in Angular by building login and register forms under a public component. Learn sharing email field, using router outlet, and applying parent styles to children.

Create a login form in Angular using reactive forms by building a form group with a form builder, and binding email and password controls to handle submission and log inputs.

Create an authentication service in Angular that posts login data to localhost:1000/login, subscribes to response, uses the token to access private routes, and injects the service into the login component.

Build and wire the registered component form in angular, including first name, last name, email, password, and password confirm, to a register API using environment API variables, test by submitting.

Learn to configure Angular routing for a secure area by adding dashboard and users components, a router outlet, and routerLink plus routerLinkActive for seamless in-app navigation.

Learn how to configure routing to redirect an empty path to the dashboard on localhost, ensuring users land on the dashboard when visiting the app.

Protect the dashboard by requiring authentication and storing the login token in local storage. Attach the token to the Authorization header for protected requests and redirect unauthenticated users to login.

Define interfaces for user and role, including id, first name, last name, email, and role name; assign the data to a user variable and enable sign-out in the component.

Learn how to pass a user object between components using inputs in Angular, handle undefined data with optional chaining, and ensure first name and email render correctly in the nav.

Implement sign out by adding a click listener and a logout function, remove the local storage item, and navigate to the login page, resolving a double refresh by using javascript:void(0).

Build a profile component with routing to a profile page and implement two reactive forms—personal information and password—using the form builder in Angular to update user data.

Create an OAuth class with a private static _user and a public setter and getter to prefill the profile form with the current user's first name, last name, and email.

Update profile information by submitting form data to the API with authorized headers. The lecture shows wiring the profile form to update info and password, handling responses, and verifying changes.

Learn how to automatically attach authorization headers to every request using a token interceptor in Angular, by cloning requests and injecting the interceptor in providers.

Use event emitters to update user data in real time across components. Emit user changes and subscribe to refresh the profile and related sections automatically.

Loop through fetched user data to populate a table in the users component, displaying name, email, and role, while wiring a user service to retrieve all users from the API.

Implement pagination in Angular by using a current page state, prev and next controls, and a refresh function that fetches users from the user service with a page parameter.

Learn to implement a delete feature for users with an ID, including a confirmation dialog, a service call, and client-side removal to update the list without refreshing.

Create users through an Angular form by building a user create component, pulling roles, submitting to the user service, and navigating back to the user list.

Demonstrates editing a user: fetch by id, prefill the form, update via a put request, and return to the users list.

Refactor by implementing interfaces for API responses, handling optional meta, casting data as response, and standardizing response structures across components.

Implement roles management by creating the roles component, rendering a roles table with secure urls, and fetching all roles via the role service with delete actions.

Refactor by introducing a rest service base class with default get, create, update, and delete methods, using an abstract endpoint and a getter url, inherited by user and role services.

Learn to build a role creation form in Angular, using a permissions service and reactive forms to fetch permissions, render checkboxes, and post new roles.

Explore implementing dynamic permissions in Angular using form arrays, form builders, and form groups. Create checkbox-based permissions, initialize and map values, submit to a back-end service, and navigate post-creation.

Prefill the role edit form by fetching the role by id and populating its name and permissions. Update the role with selected permissions and navigate back to the previous page.

Create a secure products component with a table showing image, title, description, price, and actions, and implement a product service and interface linked to the endpoint.

Implement a reusable paginator component in Angular, using current page and last page inputs and a page changed output to refresh product and user lists.

Create a product form using a form builder, including title, description, image, and price. Connect it to the product service, submit data, and navigate to the products list.

Updates products using the product create and product edit components with a shared form, implements routing, and uses the product service to get and update data, then tests in browser.

Implement an image upload flow in angular by adding a file input and sending form data to the backend via an image service, then storing url in product create component.

Create a reusable image upload component in Angular that emits a file uploaded event to bind the image value to product forms, reducing repeated code across components.

Implement orders in the microservice architecture by creating an order component and service, extending the rest service, and wiring order items, pagination, and a dynamic orders table in the browser.

Implements a view button by creating a new order view component and fetching order items with the order service for secure orders.

Export orders to a CSV file in an Angular app by wiring a button to a service, using a blob response, and programmatically triggering a download.

Build a dynamic dashboard in Angular using the c3 chart library to visualize daily sales from the order service, with a time-series x-axis.

Implement route permissions by creating a permission class and can activate checks to restrict viewing products and managing users, and drive menu visibility with can access.

Update the angular interceptor to use with credentials and HttpOnly cookies instead of bearer tokens, and add a logout function that posts to clear cookies and redirects to login.

Update the influencer api in the laravel project by reconfiguring docker-compose, renaming the database to influencer, creating the influencer schema, running migrations, and seeding the database to enable new functionality.

Add a route prefix to the API, such as admin, to expose admin-only endpoints and harden access, while separating admin and influencer routes with later-learned scopes.

Explore route namespaces by reorganizing Laravel controllers into an admin folder and admin namespace, ensuring endpoints work, and preparing influencer APIs alongside admin controllers.

Create an influencer product controller in Laravel, implement an index method to return all products, configure public API routes with influencer prefix and namespace, and test with Postman.

Enable product search by filtering with query string parameters, extract the search term from the request, and apply title and description like filters, returning results via the product resource.

Add common routes for admin and influencer, secure them with authentication middleware, and refactor user routes by moving to a common controller and renaming the user controller to OAuth controller.

Add an is_influencer field to users to differentiate admin from influencer in the Laravel API, and update migrations, the user resource, and the register flow to reflect permissions.

Drop the role_id from users, create a user_roles table with user_id and role_id, seed assignments, add foreign keys, and update models to has one through, then run migrations.

Explore Laravel Passport scopes that enforce admin and influencer roles by attaching scopes to login tokens and guarding routes with a scope middleware to prevent unauthorized access.

Build influencer links by creating links and link_products tables with user and product associations and a unique code, enabling a many-to-many relationship for checkout.

Learn how to implement checkout links by creating a dedicated checkout link controller, retrieving a link by code, and returning the user and products data through resources.

Create and migrate orders and order items tables, add shipping and influencer fields, and implement a store method to build orders with items and revenue shares (influencer 10%, admin 90%).

Implement a database transaction so that the order and order items are inserted together or not at all, using begin transaction and a final commit to ensure atomicity.

Learn how to integrate Stripe checkout in a Laravel-based workflow, configuring API keys, creating a checkout session, handling line items, and persisting transaction data.

Confirm an order by receiving the source, locating the matching order by transaction id, marking it complete, and saving it, via a post orders/confirm route with 404 if not found.

Notify admin and influencer when an order completes by sending two emails from dedicated templates, tested with a mail catcher, and update totals for admin revenue and influencer revenue.

Create and wire events and listeners through the event service provider to move email sending out of monolithic controllers, connecting a new order completed event to admin and influencer notifications.

Explore adding a revenue attribute to the influencer user model, compute revenue from completed orders using a Laravel collection, and expose an influencer revenue endpoint.

Fetch the authenticated user’s links and compute per-link order counts and revenue using Laravel collection map and sum, returning code, count, and revenue via the influencer stats API.

Learn to build a rankings feature that lists influencers by revenue from completed orders, using a Laravel collection map to sum orders and sort descending for an api endpoint.

Install redis, switch the cache driver from file to redis, and restart docker compose to speed up revenue calculations by reducing the latency of the influencer revenue call.

Learn how to cache product data with Redis to reduce delay, using two approaches: a manual cache get/set with a five-second TTL, and Laravel's remember helper for automatic caching.

Invalidate the products cache on update or create by firing a product updated event and a listener that flushes the cache, ensuring fresh data before the 30-minute ttl expires.

Filter cache data by shifting from a database query to filtering a Laravel collection, matching title and description strings, and then clear the cache to reflect changes.

Maintain influencer rankings with Redis sorted sets and cache, update rankings automatically via a Laravel command and listener on order completion, and retrieve descending scores using zrange and zrevrange.

Build a multi-project Angular workspace by creating an influencer project with admin, influencer, and checkout apps, configure routing to SPAs, and run each app on separate ports 4200 and 4300.

Copy the admin source to the influencer project, delete end-to-end tests, install c3, run the admin app, and update services to the admin API with admin login scope.

Set up the influencer template, create header and product components, wire login and register routes, and configure separate ports for influencer and checkout services to enable new features.

Implement login and register flows in the influencer public module, aligning public and admin folders, configuring services and environment APIs, and setting up routing and redirects.

Update header title and description based on the authenticated user by subscribing to a health service, using a ready flag, and reflecting changes after login.

Implement a header logout and login flow by adding a logout button in the nav, toggling buttons based on user state, using local storage, and refreshing to reflect changes.

Retrieve products from the product service in a microservices setup, render them in a product component with image sources, titles, and prices, and manage data initialization and errors.

Create a shared common library to host interfaces, interceptors, OAuth logic, and services, enabling admin and influencer projects to share endpoints and environment variables.

Export shared files from the common library, configure the Angular Influencer Common package, and publish it to AMPM via MBM Publish so other apps can consume it.

Learn how to share libraries in Angular by importing from the common library or via a published distribution file, fix errors, and test on localhost:4300.

Add a secure profile update feature in a monolith-to-microservices app, enabling logged-in users to view and edit their first and last name via a reactive profile form.

Build a stats module by creating a stats service with an http client to fetch all stats, then render a table of links, users, and revenue in the stats component.

Create and display a rankings component by integrating the stats service, subscribing to ranking data, and rendering a table of number, name, and revenue.

Implement product search by typing, using a key up listener to send term to the product service and build a query string with page and search filters that update results.

Select products to generate a purchase link, toggling items in a selected array and updating styles, while revealing the link only when at least one product is chosen.

Create and wire a link service to generate checkout links from selected products, display the generated link in the user interface, and handle login errors when generating links.

Build and refine a checkout page by integrating bootstrap, updating the checkout component, and simplifying the form with required email, city, and zip fields for real products.

Implement a checkout component to fetch products, configure routing, set up the checkout API and service, and render the checkout template.

Calculate checkout total by binding product prices to user-selected quantities in an Angular and Laravel setup, looping over products to compute total using a checkout component and reactive forms.

Build and validate a form using form group and form builder, capture user details and cart items, submit to the order service via checkout API, and prepare a Stripe redirect.

Learn to implement Stripe checkout in an Angular and Laravel monolith migration, creating error and success pages, initializing Stripe, configuring environment keys, and handling session redirects.

Complete a Stripe payment and confirm the order by sending the source to the order service's confirm endpoint, then verify the result on the success page.

Split the monolith into microservices by relocating the Angular frontend and creating a Laravel emails service, then install an ID helper package and use RabbitMQ for event-driven emails.

Learn to set up RabbitMQ with Laravel using the Rapidan service, configuring host, port, user, vhost, and password. Install and configure the Laravel Q Rapidan package and define the RabbitMQ queue.

Fire a Laravel event from a command, create a matching job, and dispatch it through rapid mq to be consumed by another app, demonstrating event-driven microservice communication.

Move emails to the email microservice by dispatching admin added events, adjust data as arrays, restart queues, and test with mailhog to verify admin and influencer emails for orders.

Learn to break an Angular and Laravel monolith into microservices by configuring Docker Compose, updating Docker files, and wiring databases, queues, and email services for containerized workflows.

Create a users microservice in a Laravel project to isolate users and boost security. Install id helper and migrate the users table with first name, last name, email, password.

Create docker files and a docker-compose setup to deploy the users microservice, map ports 8000 inside to 8001 outside, and run artisan migrate to create the users table and api.

Configure the user model with Laravel Passport, install and activate Passport, define the influencer scope, update the service provider, run migrations, and ensure Docker volumes refresh containers.

Move the auth controller, align imports and requests for microservices, remove the user resource, and test the register flow with OAuth routing, a server restart, and cross-service user API integration.

Import user data from another database into the Laravel app by creating a seeder, configuring a database connection, and seeding users.

Learn how to call internal APIs between microservices, handle authorization headers and tokens, resolve cross-token authentication issues, and fetch user data from a dedicated user service.

Create a user service in services, implement get user, and return a user object with first name, last name, email, roles, permissions, and influencer status. Verify by admin login.

Create a scope middleware to enforce admin and influencer permissions, wiring it into the kernel, updating routes and user service checks to ensure authenticated access by scope.

Update the user service with an allows method (action and argument) to authorize specific users, and apply it in the user controller to get users.

Move the user controller to the user microservice and expose index that returns paginated users through a resource. Format includes meta, links, data, and a page parameter with default 1.

Move the remaining user controller logic into the user service, implementing get, show, store, update, and destroy for users/{id}, and validate the microservice migration with docker testing.

Remove the user model everywhere, including the user controller, token command, user factory, stats controller, and service provider type hints; update rankings accordingly.

Filter users by influencer status and paginate results, returning all users when page equals minus one, and refactor to use a user service for cleaner rankings updates.

Refactor the user model into a normal class by removing extends, Laravel traits, and unused fields, and implement role retrieval via a user id lookup.

Set up the checkout module inside the bacon folder, complete a simple project setup, install the ID helper, and make initial changes to finalize the setup.

Execute migrations to remove users and password_resets, add failed_jobs, and implement migrations for products, orders, order_items, links, and link_products; then adjust product ids to unsigned integers and migrate via docker.

Run docker compose up to start services, restart containers, and perform a fresh migration to verify database tables.

Import data from the previous project by copying and adapting models for product, order, and item; configure seeders and link records, run artisan seeders, and verify linked records in database.

Learn how to break a monolith into microservices by creating a shared Laravel user service package. Publish it on GitHub, wire it via composer, and consume it in controllers.

Publish a shared PHP library to Packagist by creating a common package, configuring composer.json, pushing to GitHub, and linking Packagist to install and reuse the user service across microservices.

Listen to events from other services by creating and dispatching jobs for product created, updated, and deleted to update the checkout service.

Set up and run the queue listener for events in a microservices migration, configure a separate queue service, and route the admin audit job to the correct queue.

Publish events from the product controller and the link controller to the checkout queue, isolating checkout processing from the default queue, with container restarts and running tests.

Create the influencer microservice, access the project folder, install the id helper, and start making changes to the project.

Remove user creation and password fields and reuse checkout migrations. Keep code and user_id, rename admin revenue to influencer revenue, and prepare links and linked products for the next tutorial.

Import data into the influencer database by renaming files, configuring the influencer db, running artisan migrate to create tables, seeding data, and updating models for influencer revenue and order items.

Move and empower Laravel controllers by replacing the old controller with influencer approach, integrating the user service, and wiring resources and scope for a streamlined microservice architecture.

Install and configure the events system, bind event listeners, and dispatch the order completed event to multiple queues, including influencer, emails, and admin, with order items and revenues.

Explore how Redis is used to manage the cache on product creation or update, and how order creation triggers rankings updates as the monolith becomes microservices.