Forem: Alpha Olomi

PHPStan: Elevate Your PHP Code Quality with Static Analysis

Alpha Olomi — Sun, 10 Nov 2024 20:50:14 +0000

Managing code quality and ensuring error-free development can be challenging in the PHP ecosystem, where dynamic typing is prevalent. PHPStan is a static analysis tool tailored for PHP that’s designed to help developers catch bugs and potential issues before they even run their code. Through static analysis, PHPStan allows developers to write more reliable, maintainable, and robust code by catching errors early in development. In this post, we’ll explore what PHPStan is, who should use it, how to incorporate it into your development workflow, and some exciting updates in PHPStan 2.0.

What is PHPStan?

PHPStan is a static analysis tool for PHP that inspects your code and identifies issues without executing it. Unlike runtime testing, static analysis doesn’t require your code to run, which allows PHPStan to find issues and potential bugs in real time as you write code. This is particularly useful in PHP, where the dynamic typing system can sometimes allow issues to go unnoticed until runtime.

PHPStan operates by analyzing types, variables, function calls, and other code patterns to find inconsistencies or potential bugs. It helps identify errors such as:

Calling a method on a variable that could be null
Accessing undefined properties
Passing incorrect types to a function
Using undefined variables or classes

While these issues might otherwise be caught at runtime (if they’re caught at all), PHPStan catches them during development, creating a faster feedback loop for developers and leading to cleaner, more robust code.

Why Use PHPStan?

Using PHPStan brings many benefits, including:

Early Detection of Bugs: PHPStan helps you identify issues before they reach production, preventing runtime errors that can affect your application’s reliability and performance.
Improved Code Quality: By enforcing stricter type-checking and coding practices, PHPStan leads to more maintainable, readable code.
Confidence in Refactoring: Refactoring code becomes less intimidating when you have a tool like PHPStan validating your changes, ensuring that you aren’t introducing new issues.
Consistency Across Teams: PHPStan enforces coding standards and best practices, which can help teams create more consistent codebases, especially in collaborative environments.

Who Should Use PHPStan?

PHPStan is a great tool for PHP developers at all levels. However, it’s particularly valuable for:

Mid to Senior PHP Developers: More experienced developers will appreciate the extra level of polish and control PHPStan provides, especially for large codebases.
Teams and Organizations: PHPStan helps teams enforce consistent coding practices, making it easier for multiple developers to collaborate and understand each other’s work.
Open-Source Projects: For open-source maintainers, PHPStan can help to maintain high code quality standards across contributions, ensuring that new code doesn’t introduce issues.
Projects with Legacy Code: PHPStan can gradually help clean up and modernize legacy codebases, catching outdated or problematic patterns and ensuring they adhere to current best practices.

While PHPStan has a learning curve and might initially feel strict, it pays off quickly by improving the quality and maintainability of any PHP project.

How to Use PHPStan

PHPStan is relatively straightforward to set up and start using in your projects. Here’s a quick guide to getting started:

Install PHPStan: You can install PHPStan via Composer, the PHP dependency manager:

   composer require --dev phpstan/phpstan

Configure PHPStan:
PHPStan can be configured using a phpstan.neon or phpstan.neon.dist file, where you can specify analysis settings, levels, and rules. The configuration file allows for customization to match your project’s needs, including paths to analyze, and ignore rules and extensions.
Set an Analysis Level:
PHPStan offers different analysis levels (from 0 to 8), where 0 is the least strict and 8 is the strictest. It’s often recommended to start with a lower level and gradually increase as your codebase improves.

   phpstan analyse --level max src

Run PHPStan: To analyze your codebase, simply run:

   phpstan analyse src

PHPStan will output warnings and errors with context on where they’re found in the code, allowing you to address them before proceeding.

Integrate with CI/CD: PHPStan can be added to your CI/CD pipeline to ensure code quality checks are automated. Many CI services, like GitHub Actions, GitLab CI, and Travis CI, have options for easily integrating PHPStan.

By making PHPStan a part of your development and review process, you can reduce the likelihood of bugs, improve code quality, and instill more confidence in your PHP code.

On Laravel Projects

1: If you’re working on a Laravel project, you can leverage the larastan package, which is tailored for Laravel applications and provides additional features and checks specific to Laravel. To install larastan, run:

composer require --dev "larastan/larastan:^2.0"

2: Then, create a phpstan.neon or phpstan.neon.dist file in the root of your application. It might look like this:

includes:
    - vendor/larastan/larastan/extension.neon

parameters:

    paths:
        - app/

    # Level 9 is the highest level
    level: 5

#    ignoreErrors:
#        - '#PHPDoc tag @var#'
#
#    excludePaths:
#        - ./*/*/FileToBeExcluded.php
#
#    checkMissingIterableValueType: false

For all available options, please take a look at the PHPStan documentation: https://phpstan.org/config-reference

3: Finally, you may start analyzing your code using the phpstan console command:

If you are getting the error Allowed memory size exhausted, then you can use the --memory-limit option fix the problem:

./vendor/bin/phpstan analyse --memory-limit=2G

Ignoring errors

Ignoring a specific error can be done either with a php comment or in the configuration file:

// @phpstan-ignore-next-line
$test->badMethod();

$test->badMethod(); // @phpstan-ignore-line

When ignoring errors in PHPStan's configuration file, they are ignored by writing a regex based on error messages:

parameters:
    ignoreErrors:
        - '#Call to an undefined method .*badMethod\(\)#'

Baseline file
In older codebases it might be hard to spend the time fixing all the code to pass a high PHPStan Level.

To get around this a baseline file can be generated. The baseline file will create a configuration file with all of the current errors, so new code can be written following a higher standard than the old code. (PHPStan Docs)

./vendor/bin/phpstan analyse --generate-baseline

What’s New in PHPStan 2.0?

With PHPStan 2.0, the tool has introduced several powerful new features, enhancing its capabilities and making it even more effective for developers.

Enhanced Type Inference: PHPStan 2.0 offers improved type inference, which means it can more accurately understand complex type relationships in your code. This results in better detection of issues and a more reliable analysis.
Support for Generics: PHPStan 2.0 has significantly enhanced support for generics in PHP, providing more accurate type-checking for generic code patterns, especially within frameworks and libraries. This update allows for cleaner code with less boilerplate, making it easier to write generic classes and functions.
Better Handling of Legacy Code: PHPStan 2.0 has been optimized to analyze legacy codebases more efficiently, helping developers modernize older projects without overwhelming them with errors.
Increased Performance: The latest version of PHPStan is faster, allowing it to analyze larger codebases more efficiently, which is particularly beneficial in CI/CD environments where speed is critical.
New Rule Customizations: With PHPStan 2.0, developers have more control over which rules and checks are enforced. This is especially useful for teams that have specific coding standards or preferences.

PHPStan 2.0 represents a significant leap forward in static analysis for PHP, offering deeper insight, more flexibility, and better performance to streamline code quality efforts.

Tips for Maximizing PHPStan’s Impact

To get the most out of PHPStan, consider these tips:

Start Slowly: Introduce PHPStan at a lower analysis level and increase gradually as the team becomes more comfortable.
Use Baseline Files: PHPStan allows you to create a baseline of existing errors to focus on new issues. This is particularly helpful in legacy codebases where fixing all issues at once may not be feasible.
Invest in Custom Rules: If your project has specific coding standards, consider writing custom rules for PHPStan. This can help reinforce project-specific conventions and maintain consistency.
Embrace Type Hints: The more type hints you use in your code, the better PHPStan can analyze it. Encourage type hinting for variables, parameters, and return types throughout the project.

Conclusion

PHPStan has transformed static analysis for PHP developers, bringing a powerful set of tools to identify and address issues early in the development process. With the release of PHPStan 2.0, it’s more capable than ever, boasting enhanced type inference, better support for generics, and performance improvements that make it a vital tool for modern PHP development.

By integrating PHPStan into your development workflow, you’re investing in code quality, reducing bugs, and ultimately creating a more reliable and maintainable codebase. Whether you’re working on a large, collaborative project or just trying to improve a personal project, PHPStan is a valuable asset that every PHP developer should consider.

Mastering Laravel Password Reset Customization: A Comprehensive Guide

Alpha Olomi — Sat, 31 Aug 2024 19:39:24 +0000

Introduction

Password reset functionality is a critical component of any modern web application. While Laravel provides a robust out-of-the-box solution, there are times when you need to tailor this process to meet specific requirements or enhance user experience. In this tutorial, we'll dive deep into customizing Laravel's password reset workflow, covering everything from basic modifications to advanced techniques.

A Brief History of Laravel Authentication

Before we delve into customization, let's take a quick trip down memory lane to understand how Laravel's authentication solutions have evolved:

Laravel UI: The first iteration of a complete auth solution in Laravel, which served the community well for years.
Laravel Breeze: Born out of the growing popularity of Tailwind CSS, Breeze offered a minimal, lightweight, and modern authentication scaffolding.
Laravel Jetstream: For those needing more advanced features, Jetstream was introduced, covering a wide range of authentication including 2FA and team management functionalities.
Laravel Fortify: A headless authentication backend that can be used with any frontend, providing flexibility for developers to implement their own UI.

Understanding Laravel's Password Reset Flow

Laravel's password reset process typically involves the following steps:

User requests a password reset
A token is generated and stored
An email is sent to the user with a reset link (signed URL)
User clicks the link and enters a new password
The password is updated, and the token is invalidated

While this flow works well for most applications, you might want to customize various aspects of this process to better suit your needs.

What We're Building

In this tutorial, we'll create a bare Laravel SaaS (minimal) application with a customized password reset flow. We'll cover:

Setting up a fresh Laravel application with Breeze
Customizing the password reset URL
Modifying the password reset email content
Adding a success notification after password reset
Implementing and customizing automated tests for our changes

Getting Started

Let's begin by setting up a new Laravel application:

composer create-project laravel/laravel password-reset-demo
cd password-reset-demo

Before we proceed, let's initialize Git for version control:

git init
git add .
git commit -m "Initial commit"

Now, let's install Laravel Breeze to get the basic authentication scaffolding:

composer require laravel/breeze --dev
php artisan breeze:install

When prompted, choose the stack that best fits your needs. For this tutorial, we'll use Livewire:

php artisan breeze:install

  Which Breeze stack would you like to install?
❯ livewire

  Would you like dark mode support? (yes/no) [no]
❯ no

  Which testing framework do you prefer? [PHPUnit]
❯ Pest

After installation, let's commit our changes:

git add .
git commit -m "Add Authentication and Pages"

Now, set up your database and run migrations:

php artisan migrate

Install and compile your frontend assets:

npm install
npm run dev

At this point, we have a basic Laravel application with authentication functionality. Let's run the tests to ensure everything is working as expected:

php artisan test

You should see all tests passing, giving us a green light to proceed with our customizations.

Customizing the Password Reset URL

By default, Laravel (using Breeze) uses a standard URL for password reset (/reset-password). Let's customize this in our AppServiceProvider:

<?php

namespace App\Providers;

use App\Models\User;
use Illuminate\Auth\Notifications\ResetPassword;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        ResetPassword::createUrlUsing(function (User $user, string $token) {
            return url(route('password.reset', [
                'token' => $token,
                'email' => $user->getEmailForPasswordReset(),
            ], false));
        });
    }
}

This customization allows you to modify the reset URL structure, add additional parameters, or even point to a completely different domain if needed. For example, you could change it to:

return "https://account.yourdomain.com/reset-password?token={$token}&email={$user->getEmailForPasswordReset()}";

Modifying the Password Reset Email

Next, let's customize the content of the password reset email. We'll do this by adding to our AppServiceProvider:

use Illuminate\Notifications\Messages\MailMessage;

// ...

public function boot(): void
{
    // ... previous customizations

    ResetPassword::toMailUsing(function (User $user, string $token) {
        $url = url(route('password.reset', [
            'token' => $token,
            'email' => $user->getEmailForPasswordReset(),
        ], false));

        return (new MailMessage)
            ->subject(config('app.name') . ': ' . __('Reset Password Request'))
            ->greeting(__('Hello!'))
            ->line(__('You are receiving this email because we received a password reset request for your account.'))
            ->action(__('Reset Password'), $url)
            ->line(__('This password reset link will expire in :count minutes.', ['count' => config('auth.passwords.' . config('auth.defaults.passwords') . '.expire')]))
            ->line(__('If you did not request a password reset, no further action is required.'))
            ->salutation(__('Regards,') . "\n" . config('app.name') . " Team");
    });
}

Note: The __() function is a helper for localization, allowing easy translation of strings in your application.

Adding a Password Reset Success Notification

To enhance user experience and security, let's add a notification that's sent after a successful password reset. First, create a new notification:

php artisan make:notification PasswordResetSuccessfullyNotification

Edit the newly created notification:

<?php

namespace App\Notifications;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Messages\MailMessage;
use Illuminate\Notifications\Notification;

class PasswordResetSuccessfullyNotification extends Notification implements ShouldQueue
{
    use Queueable;

    public function via($notifiable)
    {
        return ['mail'];
    }

    public function toMail($notifiable)
    {
        return (new MailMessage)
            ->subject('Password Reset Successful')
            ->greeting('Hello!')
            ->line('Your password has been successfully reset.')
            ->line('If you did not reset your password, please contact support immediately.')
            ->action('Login to Your Account', url('/login'))
            ->line('Thank you for using our application!');
    }
}

Now, create a listener for the PasswordReset event:

php artisan make:listener SendPasswordResetSuccessfullyNotification --event=PasswordReset

Update the listener:

<?php

namespace App\Listeners;

use App\Notifications\PasswordResetSuccessfullyNotification;
use Illuminate\Auth\Events\PasswordReset;
use Illuminate\Contracts\Queue\ShouldQueue;

class SendPasswordResetSuccessfullyNotification implements ShouldQueue
{
    public function handle(PasswordReset $event)
    {
        $event->user->notify(new PasswordResetSuccessfullyNotification());
    }
}

Remember to register this listener in your EventServiceProvider.

Testing Our Customizations

Testing is crucial to ensure our customizations work as expected. Update the existing password reset test in tests/Feature/Auth/PasswordResetTest.php:

<?php

namespace Tests\Feature\Auth;

use App\Models\User;
use App\Notifications\PasswordResetSuccessfullyNotification;
use Illuminate\Auth\Notifications\ResetPassword;
use Illuminate\Support\Facades\Notification;
use Tests\TestCase;

class PasswordResetTest extends TestCase
{
    public function test_reset_password_link_can_be_requested(): void
    {
        Notification::fake();

        $user = User::factory()->create();

        $this->post('/forgot-password', ['email' => $user->email]);

        Notification::assertSentTo($user, ResetPassword::class, function ($notification) use ($user) {
            $response = $this->get($notification->toMail($user)->actionUrl);
            $this->assertStringContainsString('Reset Password', $response->getContent());
            return true;
        });
    }

    public function test_password_can_be_reset_with_valid_token(): void
    {
        Notification::fake();

        $user = User::factory()->create();

        $this->post('/forgot-password', ['email' => $user->email]);

        Notification::assertSentTo($user, ResetPassword::class, function ($notification) use ($user) {
            $token = $notification->token;

            $response = $this->post('/reset-password', [
                'token' => $token,
                'email' => $user->email,
                'password' => 'new-password',
                'password_confirmation' => 'new-password',
            ]);

            $response->assertSessionHasNoErrors();

            Notification::assertSentTo($user, PasswordResetSuccessfullyNotification::class);

            return true;
        });
    }

    public function test_reset_password_email_contains_custom_content(): void
    {
        Notification::fake();

        $user = User::factory()->create();

        $this->post('/forgot-password', ['email' => $user->email]);

        Notification::assertSentTo($user, ResetPassword::class, function ($notification) use ($user) {
            $mailMessage = $notification->toMail($user);
            $this->assertStringContainsString('Hello!', $mailMessage->greeting);
            $this->assertStringContainsString('Regards,', $mailMessage->salutation);
            return true;
        });
    }
}

Conclusion

Customizing Laravel's password reset workflow allows you to create a more tailored and user-friendly experience for your application. We've covered how to modify the reset URL, customize the email content, add a success notification, and ensure everything works through automated testing.

Remember, while customization can be powerful, it's essential to maintain security best practices throughout the process. Always validate user input, use secure token generation and storage methods, and follow Laravel's security recommendations.

Some additional considerations for further improvements:

Implement rate limiting on password reset requests to prevent abuse.
Add logging for successful and failed password reset attempts for security auditing.
Consider implementing multi-channel notifications (e.g., SMS, push notifications) for critical security events like password resets.
Regularly review and update your password policies to align with current security best practices.

For more advanced topics and Laravel insights, check out the official Laravel documentation and stay tuned to the Laravel community resources for more in-depth tutorials and best practices.

Happy coding, and may your Laravel applications be ever secure and user-friendly!

Generating PDF documents in Laravel

Alpha Olomi — Tue, 02 Jul 2024 21:56:47 +0000

Laravel and DomPDF: Step by step guide to generating PDF Documents with Images and CSS

Creating PDF documents is a common requirement in web applications, especially for generating invoices, receipts, certificates, tickets, and various reports. In this comprehensive tutorial, we'll delve into using Laravel and DomPDF to generate PDF documents with images and CSS. We'll cover configuration options, design considerations, output size, performance, and database queries. Additionally, we'll discuss tips and tricks for handling page breaks, loading images using base64, and more.

Prerequisites

Before we start, ensure you have the following installed:

PHP >=8.2
Composer 2+
Laravel 10+

Introduction

DomPDF is a popular PHP library that allows you to generate PDF documents from HTML content. It supports CSS styling, images, and various configuration options. By integrating DomPDF with Laravel, you can easily create sophisticated PDF documents using Blade templates and Laravel's powerful features.

Other popular PDF libraries include TCPDF, FPDF, and Snappy.

However, DomPDF is widely used due to its ease of integration and robust feature set.

In this tutorial, we'll walk through the process of setting up a Laravel project, configuring DomPDF, creating a controller to handle PDF generation, designing a Blade template for the PDF content, adding routes, and optimizing performance. We'll also discuss advanced configuration options and provide tips and tricks for generating high-quality PDF documents.

Assumptions

This tutorial assumes you have a basic understanding of Laravel and PHP. If you're new to Laravel, consider going through the official Laravel documentation to familiarize yourself with the framework. Other wise you can follow the Laravel Bootcamp to get started with Laravel.

Step 1: Setting Up Laravel Project

First, create a new Laravel project if you don't already have one, or use an existing project, Of course, you can skip this step if you already have a Laravel project.

composer create-project --prefer-dist laravel/laravel pdf-tutorial
cd pdf-tutorial

Next, install DomPDF:

composer require barryvdh/laravel-dompdf

Publish the configuration file:

php artisan vendor:publish --provider="Barryvdh\DomPDF\ServiceProvider"

Step 2: Configuring DomPDF

Open the config/dompdf.php file. The configuration file contains various options for customizing the PDF output. Here you can set various options including the default paper size, orientation, font, and more.

Paper size: You can set the default paper size.

  'default_paper_size' => 'a4',

Orientation: Set the default orientation (portrait or landscape).

  'orientation' => 'portrait',

Font: You can specify the default font and add custom fonts.

  'default_font' => 'serif',

Step 3: Creating a Controller

Create a controller to handle PDF generation:

php artisan make:controller PDFController

In app/Http/Controllers/PDFController.php, add the following code:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use PDF;

class PDFController extends Controller
{
    public function generatePDF()
    {
        $data = [
            'title' => 'Laravel PDF Example',
            'date' => date('m/d/Y'),
        ];

        $pdf = PDF::loadView('myPDF', $data);

        return $pdf->download('document.pdf');
    }
}

Step 4: Creating a Blade Template

Create a Blade template for the PDF content:

touch resources/views/myPDF.blade.php

Add the following content to myPDF.blade.php:

<!DOCTYPE html>
<html>
<head>
    <title>Laravel PDF Example</title>
    <style>
        body {
            font-family: 'Arial, sans-serif';
        }
        .container {
            margin: 0 auto;
            padding: 20px;
        }
        .header {
            text-align: center;
            margin-bottom: 20px;
        }
        .content {
            font-size: 12px;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>{{ $title }}</h1>
            <p>Date: {{ $date }}</p>
        </div>
        <div class="content">
            <p>This is an example of a PDF document generated using Laravel and DomPDF.</p>
        </div>
    </div>
</body>
</html>

Step 5: Adding Routes

Add routes to handle PDF generation in routes/web.php:

use App\Http\Controllers\PDFController;

Route::get('generate-pdf', [PDFController::class, 'generatePDF']);

Step 6: Adding Images

You can add images to the PDF by embedding them as base64-encoded strings or using URLs.

Images can be embedded directly in the Blade template using base64 encoding. For example, to embed an image from the public/images this is how you can do it:

<img src="data:image/png;base64,{{ base64_encode(file_get_contents(public_path('images/logo.png'))) }}" alt="Logo">

Or directly from a URL:

<img src="{{ asset('images/logo.png') }}" alt="Logo">

Step 7: Optimizing Performance

Database Queries

When dealing with large datasets (e.g., 1,000+ records), use pagination or chunking to manage memory usage:

$data = DB::table('users')->paginate(50);

$pdf = PDF::loadView('myPDF', ['data' => $data]);

Output Size

To reduce the output size, minimize the use of heavy images and opt for vector graphics when possible. Also, use efficient CSS.

Page Breaks

Ensure content is well-structured for page breaks. Use CSS to handle page breaks:

.page-break {
    page-break-after: always;
}

And in your Blade template:

<div class="page-break"></div>

Step 8: Advanced Configuration

For more advanced configurations, refer to the DomPDF documentation. You can customize almost everything, from margins to the way fonts are loaded.

Using Custom Fonts

To use custom fonts, first, add them to your project and configure DomPDF to use them:

'custom_font_dir' => base_path('resources/fonts/'),
'custom_font_data' => [
    'custom-font' => [
        'R' => 'CustomFont-Regular.ttf',
        'B' => 'CustomFont-Bold.ttf',
    ]
],

In your Blade template:

<style>
    body {
        font-family: 'custom-font', sans-serif;
    }
</style>

Conclusion

By following this step-by-step guide, you can generate sophisticated PDF documents using Laravel and DomPDF, complete with images and CSS styling. This tutorial has covered essential configuration options, design considerations, performance optimization. You can expand this foundation to build a robust document generation system for your Laravel application.

Potential Series and Repository

This tutorial is part of a series on PDF generation with Laravel. A complete repository with various document templates (invoices, receipts, certificates, tickets, etc.) can be found here. Feel free to contribute and expand the collection.

Happy coding!

Enhancing Your Laravel API with Treblle Platform

Alpha Olomi — Sun, 25 Jun 2023 07:12:49 +0000

Welcome

In this blog post, we will explore features of Treblle, how to integrate Treblle into your Laravel API, enabling you to gain real-time insights, improve the quality of your API, and enhance the overall development process.

What is Treblle?

Treblle is a powerful API platform that simplifies the monitoring, documentation, analytics, and management of your APIs. In this blog post, we will explore how to integrate Treblle into your Laravel API, enabling you to gain real-time insights, improve the quality of your API, and enhance the overall development process.

Who is this tutorial for?

This tutorial is for developers who are building APIs using Laravel. It is also for developers who are responsible for monitoring, analyzing, and managing APIs. Or you are involved in building and maintaining APIs on a daily basis, Treblle is a valuable tool for you.

Integrations

Treblle provides official SDKs for various programming languages and frameworks. Not just Laravel. If you're using a different framework or language than Laravel, you can still integrate Treblle into your API. Here are some of the official Treblle SDKs:

PHP: Laravel, Symfony, Lumen
JavaScript: Node.js, Sails.js, AdonisJS, Fastify, Directus, Strapi, Express, Nest, Koa
Others: .NET, Go, .NET Core, Django, Rails, Spring

Learn more at treblle integrations docs page.

These SDKs enable you to seamlessly connect your API codebase to Treblle, leveraging the features and benefits offered by the platform.

Introduction

Features of Treblle API Platform

By integrating Treblle into API, you gain access to a range of powerful features, including:

Real-time API monitoring and logging: Monitor and track every request and response in real-time, gaining valuable insights into the performance and behavior of your API.
Auto-generated API documentation: Generate comprehensive API documentation including generating OpenAPI Specification, making it easier for developers to understand and consume your API.
API analytics: Measure key metrics such as response time, request load size, and more, enabling you to optimize the performance of your API and identify potential bottlenecks.
API quality scoring: Treblle calculates an API score based on best practices for performance, quality, and security, helping you ensure that your API meets industry standards.
Share requests: Easily share requests and responses with team members or stakeholders, facilitating collaboration and troubleshooting.
Error reporting: Treblle captures and reports errors that occur within your API, enabling you to identify and resolve issues promptly.

Who is Treblle for?

Treblle is designed to cater to both technical and non-technical roles that work with APIs. Whether you are responsible for monitoring, analyzing, and managing APIs, or you are involved in building and maintaining APIs on a daily basis, Treblle is a valuable tool for you.

HTTP APIs, or Application Programming Interfaces, serve as the communication bridge between different software systems using the HTTP protocol. They are extensively used in web applications, mobile apps, and system integrations. Treblle simplifies the API lifecycle tasks such as administration, documentation, support, debugging, and monitoring, allowing you to focus on building robust APIs.

How Treblle Works

Create a new Laravel project using the following command:

composer create-project laravel/laravel treblle-laravel

Using the Laravel installer

You can install the Laravel installer using the following command

composer global require laravel/installer

Then create a new Laravel project using the following command

laravel new treblle-laravel

Integrating Treblle into your Laravel API is a straightforward process. After creating a Treblle account and obtaining your API key and project ID, follow these steps:

Install the Treblle package using Composer:

composer require treblle/treblle-laravel:^4.0

Run the Treblle Artisan command to set up your account and obtain the necessary environment variables:

php artisan treblle:start

Update your .env file with the provided API key and project ID:

Going forward ensure that you have created a Treblle account and obtained your API key and project ID.

You can find your API key and project ID in the Treblle dashboard. And then update your .env file with the provided API key and project ID:

TREBLLE_API_KEY=YOUR_API_KEY
TREBLLE_PROJECT_ID=YOUR_PROJECT_ID

Register the Treblle middleware in the file app/Http/Kernel.php by adding to the following line to the $middlewareAliases property(array):

file: app/Http/Kernel.php location: $middlewareAliases property

'treblle' => \Treblle\Middlewares\TreblleMiddleware::class,

Apply the Treblle middleware to your API routes in

In the file routes/api.php, add the following line at the top of the file:

This will apply the Treblle middleware to all the routes in the file.

// add the following line 👇 at the top of routes/api.php file
use App\Http\Controllers\Api\ProductController;

file: routes/api.php location: top of the file

// Add the following lines 👇 at the bottom of routes/api.php file
use App\Http\Controllers\Api\ProductController;

// Add the following lines 👇 after all the routes in routes/api.php file
Route::middleware(['treblle'])->group(function () {
    // This will apply the Treblle middleware to products routes
    // For new projects, you can use the following line to generate the routes
    // for the ProductController
    Route::apiResource('products', ProductController::class);
});

With these steps, Treblle is seamlessly integrated into your Laravel API.

Configuration Options

Treblle offers various configuration options to customize your integration. To modify the configuration, you can publish the Treblle configuration file using the following command:

php artisan vendor:publish --tag=treblle-config

The configuration file config/treblle.php allows you to customize options such as masked fields. Treblle automatically masks sensitive information, such as passwords, credit card numbers, and API keys. To customize the masked fields, update the masked_fields array in the configuration file.

Additionally, you can configure Treblle using environment variables. For example, you can define the environments in which Treblle should not log by setting the TREBLLE_IGNORED_ENV variable in your .env file.

Setting Up your Product model

Let's create a Product model and a corresponding controller to demonstrate how Treblle works. Using the Laravel Artisan command, we can create a model and a controller.. We will use the following command to create a Product model:

php artisan make:model Product -msf -R

The -msf options will create a migration, seeder, and factory for the Product model. The -R option will create a request class for the Product model.

To generate a controller for the Product model its simple as running the following command:

php artisan make:controller Api/ProductController --api --model=Product

That will create an Api resource controller for your Product model with all the necessary methods.

The model is located at app/Models/Product.php is responsible for interacting with the database.
The migration is located at database/migrations/2023_06_30_000000_create_products_table.php is responsible for creating the products table in the database.
The factory is located at database/factories/ProductFactory.php is responsible for generating fake data for the products table.
The seeder is located at database/seeders/DatabaseSeeder.php is responsible for seeding the products table with fake data.
The controller is located at app/Http/Controllers/Api/ProductController.php is responsible for handling the incoming requests and returning the appropriate responses.

Migration

Add the following fields to the products table:

file: database/migrations/2023_06_30_000000_create_products_table.php

Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('description');
    $table->integer('price');
    $table->timestamps();
});

Run the migration:

php artisan migrate

Model factory

Add the following fields to the ProductFactory class:

file: database/factories/ProductFactory.php

<?php

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

/**
 * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Product>
 */
class ProductFactory extends Factory
{
    /**
     * Define the model's default state.
     *
     * @return array<string, mixed>
     */
    public function definition(): array
    {
        return [
            'name' => fake()->word(3),
            'description' => fake()->sentence(10),
            'price' => fake()->numberBetween(1000, 100_000),
        ];
    }
}

Model seeder

Add the following fields to the ProductSeeder class:

<?php

namespace Database\Seeders;

use App\Models\Product;
use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;

class ProductSeeder extends Seeder
{
    /**
     * Run the database seeds.
     */
    public function run(): void
    {
        Product::factory()->count(10)->create();
    }
}

To run the seeder, run the following command:

php artisan migrate:fresh --seed

Testing the API

By default, Laravel comes with PHPUnit for testing. However you can use Pest instead.

Generating Pest tests for your API

Generate a test for your Product API resource controller:

php artisan test:pest Api/ProductTest

Writing tests

Replace the contents of tests/Feature/Api/ProductTest.php with the following code:

<?php

use App\Models\Product;

it('can list products', function () {
    $response = $this->getJson('/api/products');

    $response->assertOk();
});

it('can view a product', function () {
    $product = Product::factory()->create();

    $response = $this->getJson("/api/products/{$product->id}");

    $response->assertOk();
});

Running tests

php artisan test

Testing the API

php artisan serve

Open Postman or Httpie or any client you use and create a new request to http://localhost:8000/api/products and send a GET request.

Opening the Treblle dashboard, you should see the request you just made.

Conclusion

Integrating Treblle into your Laravel API empowers you with powerful monitoring, documentation, analytics, and management capabilities. By gaining real-time insights, improving the quality of your API, and leveraging the range of features Treblle provides, you can streamline your API development process and ensure the optimal performance of your API. Start integrating Treblle today and experience the benefits firsthand.

Introducing EvPay: The Powerful Payment Gateway from Evmak

Alpha Olomi — Sat, 17 Jun 2023 18:37:59 +0000

In today's fast-paced digital world, businesses rely heavily on secure and efficient payment gateways to process transactions seamlessly. Meet Evpay, a robust payment gateway developed by Evmak, designed to simplify online payment processing for businesses. With its easy integration and powerful API and competitive rates, Evpay provides a reliable and secure platform for businesses to accept payments effortlessly.

To facilitate the integration process, Alpha Olomi, a talented developer, has created a Laravel package that wraps the Evpay API, making it even more convenient for developers to incorporate Evpay into their PHP/Laravel projects. This open-source package, available on GitHub at alphaolomi/php-evpay, streamlines the implementation of Evpay into Laravel applications, allowing developers to leverage its powerful features with minimal effort.

Let's explore some of the key features and benefits of Evpay:

Seamless Integration: Evpay offers a straightforward integration process, making it easy for businesses to start accepting payments quickly. The Laravel package further simplifies this process by providing a clean and intuitive interface to interact with the Evpay API.
Comprehensive Payment Options: Evpay supports a wide range of Mobile Network Operators, including Mpesa, Tigopesa and others. By offering multiple payment methods, businesses can cater to a broader customer base, enhancing their conversion rates and customer satisfaction.
Transaction Management: Evpay provides an intuitive dashboard that allows businesses to monitor and manage their transactions efficiently. This dashboard offers insights into transaction statuses, reports, and other valuable analytics, enabling businesses to make data-driven decisions and optimize their payment processes.
Developer-Friendly API: The Evpay API, wrapped by the Laravel package, is designed with developers in mind. It offers clear documentation, well-defined endpoints, and robust error handling, ensuring that developers can easily integrate Evpay into their Laravel projects without hassle.

The Laravel package acts as a bridge between the Evpay API and Laravel applications. It provides a set of convenient methods services, and utilities, simplifying the implementation process and allowing developers to focus on building their applications' core functionalities.

Whether you're a small business owner or an enterprise-level organization, Evpay offers a reliable and feature-rich payment gateway solution. With its seamless integration, comprehensive payment options, enhanced security, and developer-friendly API, Evpay empowers businesses to streamline their payment processes, boost conversions, and provide an exceptional customer experience.

If you're a developer working with Laravel and looking for a robust payment gateway solution, consider integrating Evpay using the Laravel package. Visit the GitHub repository at https://github.com/alphaolomi/php-evpay to explore the package, access the documentation, and contribute to its development.

Evpay from Evmak, along with the Laravel package developed by Alphaolomi, is set to revolutionize the way businesses handle online payments. Experience the power and convenience of open source and Evpay today and take your payment processing capabilities to new heights.

Next: Step by Step Guide to Integrating Evpay with Laravel (Coming Soon)

Be sure to follow Alpha Olomi at https://twitter.com/alphaolomi to stay up to date with the latest news and updates.

Step by step to Pest PHP testing framework in Laravel 10

Alpha Olomi — Sun, 11 Jun 2023 00:11:24 +0000

Introduction

Laravel is a web application framework with expressive, elegant syntax. We’ve already laid the foundation — freeing you to create without sweating the small things.

Automated testing is the execution of your test plan (the parts of your application you want to test, the order in which you want to test them, and the expected responses) by a script instead of a human. Automated tests are able to return results quickly, and are more accurate than their human counterparts.

PHPUnit is a testing framework for PHP. It is an instance of the xUnit architecture for unit testing frameworks.

Pest is a testing framework with a focus on simplicity. It was carefully crafted to bring the joy of testing to PHP. Pest is heavily inspired by Jest,

You can use a variety of different testing frameworks to write tests for your Laravel applications, Laravel version 10 by default ships with PHPUnit support out of the box.

In addition to PHPUnit, Laravel provides a variety of helpful assertions to make testing easier and faster. We will use Pest testing framework in this tutorial.

The PestPHP testing framework offers several benefits that make it an excellent choice for testing PHP applications, particularly in the context of Laravel projects. Here are some of the key benefits of using PestPHP:

Simplicity: PestPHP focuses on simplicity and aims to provide a delightful testing experience. It offers an intuitive and clean syntax that is easy to read and write. The framework encourages you to write tests that are expressive and straightforward, reducing complexity and improving code maintainability.
Powerful Assertions: PestPHP provides a wide range of powerful assertions including all in PHPUnit that enable you to write concise and precise tests. These assertions make it easy to verify the behavior and state of your application with minimal effort. With PestPHP, you can express your expectations in a natural and readable manner.
Test Driven Development (TDD) Support: PestPHP is designed to support Test Driven Development (TDD) practices. It encourages developers to write tests before implementing the corresponding functionality. By following a TDD approach, you can ensure that your code is thoroughly tested, leading to better code quality and fewer bugs.
Integration with Laravel: PestPHP integrates seamlessly with Laravel. It leverages Laravel's testing infrastructure and provides additional features and enhancements. This integration allows you to test your Laravel applications efficiently, taking advantage of Laravel-specific functionalities such as database seeding, HTTP testing, and more.
Parallel Testing: PestPHP supports parallel testing, allowing you to run your tests concurrently. This feature significantly reduces the overall test execution time, especially for larger test suites. With parallel testing, you can improve the efficiency of your testing process and get faster feedback on the health of your codebase.
Community and Ecosystem: PestPHP benefits from an active and growing community of developers. The community provides support, resources, and plugins, making it easier to adopt and leverage the framework effectively.

In summary, PestPHP offers simplicity, powerful assertions, TDD support, seamless Laravel integration, parallel testing, and a thriving community. These benefits make it a compelling choice for testing PHP applications, enabling you to write clean, expressive tests and ensure the reliability and quality of their code.

To install Pest in Laravel, we will use a Pest plugin for Laravel, which will install Pest and it to work with Laravel.

Step 0. Create new Laravel project

Create new Laravel project using Composer or Laravel installer. We will name the project pest-laravel

Using composer to create new Laravel project

composer create-project laravel/laravel pest-laravel

Or using Laravel installer

Ensure you have installed Laravel installer by running, this command
will install Laravel installer globally or update to the latest version

composer global require laravel/installer

laravel new pest-laravel

Step 0.1. Change directory to `pest-laravel`

cd pest-laravel

Step 1. Installation

Pest is a developer dependency, which means it should be installed using the --dev flag.

# Install Pest plugin for Laravel
composer require pestphp/pest-plugin-laravel --dev

# Install/Auto Configure Pest in your Laravel project
# will add Pest.php file in your project ./tests directory
php artisan pest:install

Optional add testing script in your composer.json. This will allow you to run composer test in your terminal to run your tests. It is a recommended practice to add a test script to your composer.json file so that other developers can run your tests by simply running the composer test command.

file: composer.json

// ...
"scripts": {
    "test": "vendor/bin/pest"
}
// ...

Step 2. Run tests

To run your tests, you may use the test Artisan command. The Artisan test runner provides a convenient wrapper around PHPUnit and Pest, allowing you to run your tests using a single command:

php artisan test

Or you may run the tests using the composer test command:

composer test

Or you may run the tests using the vendor/bin/pest command:

./vendor/bin/pest

All of these commands will execute the same tests. By default, the phpunit.xml file included with your application will instruct the test runner to exclude the tests in the vendor and node_modules directories.

Step 3. Delete the example tests

A new Laravel project comes with some example tests. These tests are located in the tests directory. In a new Laravel project, there are two directories within the tests directory: Feature and Unit. Feature tests may test a larger portion of your code, including how several objects interact with each other or even a full HTTP request to a JSON endpoint. Unit tests, on the other hand, are focused solely on a single class. Typically, each class in your application will have a corresponding Unit test that tests that class in isolation from the rest of the application.

We will delete the example tests, provided by Laravel default project. In the tests directory, delete the following files:

rm tests/Unit/ExampleTest.php
rm tests/Feature/ExampleTest.php

Step 4. Create new Pest unit tests

In this step, we will create a new unit test for Product model. We will create a new Product model using the following command:

php artisan make:model Product -m

Don't forget to add the name and price attributes to the products table migration file.

file: database/migrations/2023_06_11_000000_create_products_table.php

// ...
public function up()
{
    Schema::create('products', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->decimal('price', 8, 2);
        $table->timestamps();
    });
}
// ...

Then run the migration using the following command:

php artisan migrate

Then we will create a new unit test for Product model using the following command:

php artisan pest:test ProductModelTest --unit

In this Unit test we will test for

Product model has a name attribute
Product model has a price attribute

Copy the following code to the ProductModelTest.php file

file: ProductModelTest.php

it('has a name attribute', function () {
    $product = new Product([
        'name' => 'Product 1'
        'price' => 100
    ]);
    expect($product->name)->toBe('Product 1');
    expect($product->price)->toBe(100);
});

Step 5. Create Product controller

In this step, we will create a new Product controller using the following command:

php artisan make:controller ProductController --resource

Then add the following code to the ProductController.php file

file: ProductController.php

<?php

namespace App\Http\Controllers;

use App\Models\Product;

class ProductController extends Controller
{
    public function index()
    {
        $products = Product::all();
        return response()->json($products);
    }

    public function create()
    {
        $product = new Product([
            'name' => 'Product 1',
            'price' => 100
        ]);
        $product->save();
        return response()->json($product);
    }
}

Step 6. Add Product routes to `routes/api.php`

file: routes/api.php

use App\Http\Controllers\ProductController;

Route::get('/products', [ProductController::class, 'index']);

Step 7. Create new Pest feature tests

php artisan pest:test ProductTest

file: ProductTest.php

it('can list products', function () {
    getJson('/products')->assertStatus(200);
});
it('can create a product', function () {
    $data = [
        'name' => 'Product 1',
        'price' => 100
    ];
    // 201 http created
    postJson('/products/create',$data)->assertStatus(201);
});

`it` vs `test` function in Pest

The it function is an alias for the test function. Both functions are identical and you may use either one when writing your tests. The it function is provided for developers who prefer to use the it function when writing tests.

Step 8. Run tests

php artisan test

Or you may run the tests using the composer test command:

composer test

Or you may run the tests using the vendor/bin/pest command:

./vendor/bin/pest

If you want to run a specific test, you can use the --filter option:

php artisan test --filter ProductModelTest

Or you may run the tests using the composer test command:

Conclusion

In this tutorial, we explored how to set up and use the Pest testing framework in a Laravel project. We discussed the benefits of using Pest, a testing framework focused on simplicity and inspired by Jest. By following the step-by-step instructions, you learned how to install Pest in your Laravel project, run tests using various commands, and create new Pest unit and feature tests.

Testing your Laravel applications is crucial for ensuring their quality and reliability. Pest provides an intuitive syntax and powerful assertion capabilities, making the testing process more enjoyable and efficient. By writing tests with Pest, you can create readable and maintainable code that verifies the correctness of your Laravel application's functionality.

Remember to run your tests regularly to catch any bugs or issues early in the development process. Testing not only helps identify problems but also provides confidence in the stability of your codebase.

So, embrace the joy of testing with Pest in your Laravel projects and let your code be robust, reliable, and humorous!

Happy Coding!

Creating and Using Custom Helper Functions in Laravel

Alpha Olomi — Sat, 10 Jun 2023 23:23:48 +0000

Introduction

Laravel offers a variety of global "helper" functions that we can leverage in our applications, such as app_path, ucfirst, auth, and env. However, did you know that you can also define your own set of helper functions for Laravel applications and PHP packages? In this blog post, we will explore how to create and use custom helper functions in Laravel.

Why Use Custom Helper Functions?

Custom helper functions provide a convenient way to encapsulate frequently used code snippets and make them reusable across your application or even in multiple projects. They promote code modularity, improve code readability, and reduce code duplication. With custom helper functions, you can extend Laravel's functionality to suit your specific needs and enhance your development experience.

Setup:

To get started, let's create a file called Helper.php in the app/Helpers/ directory of your Laravel project. This file will serve as the home for your custom helper functions.

touch app/Helpers/Helper.php

Next, open the composer.json file and add the file path to the files key in the autoload section, as shown below:

"autoload": {
    "files": [
        "app/Helpers/helper.php"
    ],
    // rest of the auto load section
}

After modifying the composer.json file, run the following command to update the autoloader:

composer dump-autoload

Example

Now, let's dive into some practical examples of creating and using custom helper functions in Laravel.

Basic "hakuna_matata" Helper Function

if (! function_exists('hakuna_matata')) {
    function hakuna_matata($name = null) {
        if ($name) {
            return "Hakuna Matata, {$name}!";
        }
        return 'Hakuna Matata!';
    }
}

With this helper function, you call hakuna_matata() anywhere in your application. Composer will automatically load the Helper.php file, and the function will be available to use.

In this example, we simply echo the phrase "Hakuna Matata" to the screen. You can also pass in a default value to the helper function, which will be returned if no value is provided.

Facade VS Helper Function

When you create a helper function, you can use it anywhere in your application. However, if you want to use it in a class, you need to import the helper file into the class. This can be a bit cumbersome, especially if you have multiple helper functions.

Note: It is recommended* to create a helper function for Facades. Facades are a great way to access Laravel's core functionality, but they can be a bit cumbersome to use. With a helper function, you can encapsulate the Facade's functionality and make it easier to use.

Example

use MyCustomFacade;

if (! function_exists('myCustomFunc')) {
    return MyCustomFacade::myCustomFunc();
}

Now, you can use the helper function anywhere in your application. For example, you can use it in a controller:

class MyController extends Controller
{
    public function index()
    {
        return myCustomFunc();
    }
}

Helper functions usage in Laravel Documentation

Laravel provides a variety of helper functions that you can use in your application. For example, In the Laravel documentation, you you will find a plenty helper functions used in several areas like the view helper function, the route helper function, the asset helper function, the csrf_field helper function, to name a few.

In Conclusion

Custom helper functions are a powerful tool for extending Laravel's functionality and improving your development workflow. By encapsulating frequently used code snippets, you can enhance code modularity, readability, and reduce duplication. Whether you're creating a "myCustomFunc"

Azampay: A Convenient Payment Service Provider in Tanzania

Alpha Olomi — Wed, 07 Jun 2023 19:23:40 +0000

Introduction:

In today's fast-paced digital world, payment service providers play a vital role in facilitating secure and convenient transactions. One such provider making waves in Tanzania is Azampay. In this blog post, we will explore the features and benefits of Azampay and demonstrate how to integrate it into a Laravel application using the open-source package created by Alpha Olomi.

Getting Started:

To get started with Azampay, you'll need to sign up for an account on their website. Once you've registered, you will receive API credentials, including a AZAMPAY_CLIENT_ID and AZAMPAY_CLIENT_SECRET. These credentials are essential for authenticating your requests and ensuring the security of your transactions. Edit your .env file and add the following credentials:

AZAMPAY_APP_NAME="your_app_name"
AZAMPAY_CLIENT_ID="your_client_id"
AZAMPAY_CLIENT_SECRET="your_client_secret"
AZAMPAY_ENVIRONMENT="sandbox"
AZAMPAY_TOKEN="Your_Token"

Usage in Laravel:

To simplify the integration process for Laravel developers, Alpha Olomi, an independent open-source maintainer, has created a package called laravel-azampay. This package provides a seamless way to incorporate Azampay into your Laravel application.

To begin, you can install the package via Composer by running the following command in your terminal:

composer require alphaolomi/laravel-azampay

Next, you'll need to publish the package's configuration file using the artisan command:

php artisan vendor:publish --provider="AlphaOlomi\Azampay\AzampayServiceProvider"

This will create a azampay.php file in your Laravel project's config directory. Open this file and update the client_id and client_key fields with the credentials provided by Azampay config.

Once you have configured the package, you can start using it in your application.

php artisan serve

Now, You can initiate a payment by calling the Azampay facade's checkout methods example th e mobileCheckout method, passing the required parameters such as the account number ,provider, reference ID etc. The package handles the communication with Azampay's API.

There are two ways to initiate a payment. You can either use the Azampay facade directly or inject the Azampay class into your controller.

The following code snippet demonstrates how to initiate a payment using the Azampay facade. The mobileCheckout method accepts the amount and reference ID as parameters and initiates a payment. It returns a response object. Azampay supports two payment methods: mobileCheckout and bankCheckout. The mobileCheckout method is used to initiate payments via mobile money, while the bankCheckout method is used to initiate payments via bank transfers.

Example: Using Facades,

use Alphaolomi\Azampay\Facades\Azampay;

$data = Azampay::mobileCheckout([
    'amount' => 10000,
    'currency' => 'TZS',
    'accountNumber' => '0747991498',
    'externalId' => '08012345678', // your reference ID
    'provider' => 'Mpesa', // Mpesa, 
]);


// response
array:3 [▼
  "success" => true
  "transactionId" => "b85e971981844a6f8888b42579655b8f"
  "message" => "Your request has been received and is being processed."
]

Persistening your transactions using SQLite in Development:

Make sure you have the SQLite extension installed on your machine. If you're using a Mac, you can install it using Homebrew.

brew install sqlite

If you're using Windows, you can download the SQLite extension from the official website.

Once you have installed the SQLite extension, you can create a database file in your project's database directory. You can do this by running the following command in your terminal.

Setup

touch database/database.sqlite

DB_CONNECTION=sqlite
DB_DATABASE=/absolute/path/to/database.sqlite

php artisan make:model Transaction -m

This will make a model and migration file for you. Open the migration file and update the up method as follows:

In the migration file, update the up method as follows:

public function up()
{
    Schema::create('transactions', function (Blueprint $table) {
        $table->id();
        $table->string('transaction_id');
        $table->string('external_id');
        $table->string('amount');
        $table->string('currency');
        $table->string('account_number');
        $table->string('provider');
        $table->string('status');
        $table->string('message');
        $table->timestamps();
    });
}

Now, run the migration command to create the transactions table in your database:

php artisan migrate

In your, Transaction model, add the following code:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;

class Transaction extends Model
{
    use HasFactory;

    protected $fillable = [
        'transaction_id',
        'external_id',
        'amount',
        'currency',
        'account_number',
        'provider',
        'status',
        'message',
    ];
}

Now, you can update your controller to persist the transaction data in the database. The following code snippet demonstrates how to do this:

<?php

namespace App\Http\Controllers;

use App\Models\Transaction;

class TransactionController extends Controller
{
    public function store(Request $request)
    {
        $data = Azampay::mobileCheckout([
            'amount' => 10000,
            'currency' => 'TZS',
            'accountNumber' => '0747991498',
            'externalId' => '08012345678', // your reference ID
            'provider' => 'Mpesa', // Mpesa, 
        ]);

        Transaction::create([
            'transaction_id' => $data['transactionId'],
            'external_id' => $data['externalId'],
            'amount' => $data['amount'],
            'currency' => $data['currency'],
            'account_number' => $data['accountNumber'],
            'provider' => $data['provider'],
            'status' => $data['success'] ? 'success' : 'failed',
            'message' => $data['message'],
        ]);

        return $data;
    }
}

Note: You could use events to handle the persistence of transactions. This would allow you to decouple the persistence logic from the controller and keep your code clean and maintainable.

To simplify the initial setup and testing,we will use SQLite for persistance in development. SQLite is a file-based database engine that requires no additional configuration, making it perfect for local development and small-scale projects.

If you wish to use a different database driver for production, you can update the database configuration in your Laravel project's .env file.

Final Remarks:

In this blog post, we explored Azampay as a payment service provider in Tanzania. We elaborated using laravel-azampay package created by Alpha Olomi, which simplifies the integration of Azampay into Laravel applications.

By following the steps outlined in this post, you can easily get started with Azampay, initiate payments, and persist transaction details into your database. The open-source nature of the laravel-azampay package allows for community contributions and enhancements, making it an ideal choice for developers.

Integrating Azampay into your applications empowers you to offer secure and seamless payment experiences.

Tinker like a 10x: Mastering Artisan Tinker REPL for Laravel Part 2

Alpha Olomi — Wed, 03 May 2023 00:21:27 +0000

Introduction

Welcome back to our exploration of Tinker REPL in Laravel! In part one of this series, we explored the basics of using Tinker REPL in Laravel. In this article, we will delve into the practical applications of Tinker for various use cases. Tinker is a powerful tool that can execute PHP scripts, it allows developers to quickly test code snippets and experiment including Laravel-centric code like facades, helpers, and more. So let's take a look at how we can leverage Tinker to improve our workflow and productivity.

Read the first part of this series here: Tinker like a 10x: Mastering Artisan Tinker REPL for Laravel Part 1

Let's take a closer look at some of the most useful Tinker recipes.

Use Cases by Environment

Tinker can be used in a variety of environments, including development, production, and any environment with an accessible shell. Here are some examples of how Tinker can be useful in each environment:

In Development:
- Using a plethora of recipes: Tinker allows developers to quickly test code snippets and experiment with Laravel-centric code, including facades, helpers, and more.
In Production:
- For Debugging: Tinker can be used in production to quickly diagnose and fix issues, without the need for a full-blown development environment.
In Any Environment with an Accessible Shell:
- For Debugging: Tinker can be used to quickly diagnose and fix issues, regardless of the environment.

Recipes

Tinker can be used to execute PHP in a variety of recipes, from simple database access to testing code with fakerble facades. Here are some examples of the most common Tinker recipes:

Basic PHP Execution

Tinker can be used to execute PHP code in a variety of ways, including:

Using Bare PHP Functions: You can use Tinker to execute bare PHP functions:

>>> phpinfo();

Tinker can also be used to execute PHP code in a variety of ways. Here are some examples of the most common Tinker recipes:

Using an example of installing a PHP package and executing the class:

composer require alphaolomi/json-placeholder

In your Tinker REPL:

$api = new Json\Api();

$users = $api->users()->list();

var_dump($users);

Eloquent Access / Database Access

Tinker provides a simple and intuitive way to access Eloquent models and the database. Here are some examples of what you can do with Tinker:

Eloquent Retrieval: You can use Tinker to retrieve Eloquent models from the database:

>>> $user = App\Models\User::find(1);

Eloquent Insertion: You can use Tinker to insert new records into the database:

>>> $user = new App\Models\User;
>>> $user->name = 'John Doe';
>>> $user->email = 'john.doe@example.com';
>>> $user->password = bcrypt('password');
>>> $user->save();

Eloquent Relations: You can use Tinker to retrieve related models using Eloquent's relation methods:

>>> $user = App\Models\User::find(1);
>>> $user->posts()->get();

DB Facade Usage: You can use Tinker to execute raw SQL queries using the DB facade:

>>> DB::table('posts')->where('views', '>', 10)->get();

See Full List of Query Builder

Facades Like Config, App

Tinker can also be used to access Laravel's built-in facades, such as config and app. Here are some examples of what you can do with Tinker:

Config: You can use Tinker to access the configuration values from your config files:

>>> config('app.name');

Logging: You can use Tinker to log messages to Laravel's log files:

>>> Log::info('This is an info message');
// You can view the log file at storage/logs/laravel.log

// Assuming you have a SendMail job with log messages
>>> (\App\Jobs\SendEmail::dispatch($user))->dispatch();

See Full List of Facades: You can use Tinker to explore the full list of available facades:

>>> $cacheRepository =  app()->make('Illuminate\Contracts\Cache\Repository');

File System/ Storage Access

Tinker can be used to interact with Laravel's storage functionality, such as the storage and File facades. Here are some examples of what you can do with Tinker:

Using Bare PHP Function: You can use Tinker to execute bare PHP functions for interacting with files and directories:

// Create a file
>>> file_put_contents(storage_path('file.txt'), 'Hello World!');
>>> file_get_contents(storage_path('file.txt'));

// Create a directory
>>> mkdir(storage_path('test'));

// Check if file exists
>>> file_exists(storage_path('example.txt'));

// And more...

Using Laravel Code: You can also use Tinker to interact with Laravel's Storage facade. Debugging stores such as remote storages like S3, has never been easier but with Tinker you can do it like a pro. Here are some examples of what you can do with Tinker:

// Local Storage
>>> Storage::disk('local')->put('file.txt', 'Hello World!');
>>> Storage::disk('local')->get('file.txt');

// S3 Storage
// Assuming you have configured S3 in your filesystems.php config file

// Create a file
>>> Storage::disk('s3')->put('file.txt', 'Hello World!');

// List all files in the root directory
>>> Storage::disk('s3')->files('/');

Testing Code with Fakerble Facades

Tinker can also be used to test code with fakerble facades, such as Factory and Seeder. Here are some examples of what you can do with Tinker:

Factory: You can use Tinker to generate fake data with Laravel's Factory:

>>> $user = App\Models\User::factory()->create();

Seeder: You can use Tinker to seed the database with fake data using Laravel's Seeder:

>>> Artisan::call('db:seed');

Mocking: You can use Tinker to mock classes and methods using Laravel's Mockery:

Mockery is a powerful tool for mocking classes and methods. It's included in Laravel by default, and can be used to mock any class or method. Here are some examples of what you can do with Tinker:

>>> $user = App\Models\User::factory()->create();

>>> $userMockock = Mockery::mock('App\Models\User');

>>> $userMockock->shouldReceive('find')->once()->andReturn($user);

>>> $userMockock->find(1);
// Further explorations for you to explore 😃

And More

Tinker is a powerful tool with a lot of potential use cases, and this list is by no means exhaustive. You can use Tinker for anything from testing code snippets to exploring new packages and libraries.

Read the first part of this series here: Tinker like a 10x: Mastering Artisan Tinker REPL for Laravel Part 1

Conclusion

Tinker is a versatile and powerful tool that can help developers save time and increase productivity. Whether you're testing code snippets, exploring new packages and libraries, or debugging issues in production, Tinker is an essential tool in any Laravel developer's toolbox. I hope this guide has been helpful in exploring some of the most useful Tinker recipes, and that you feel confident in using Tinker to streamline your development process.

Tinker like a 10x: Mastering Artisan Tinker REPL for Laravel

Alpha Olomi — Mon, 01 May 2023 11:33:35 +0000

Introduction

As a Laravel developer, you probably spend a lot of time in the command line using Artisan commands to interact with your application. However, have you ever heard of Artisan Tinker? It's a powerful interactive REPL (Read-Eval-Print-Loop) tool that lets you interact with your Laravel application's code and data directly from the command line. In this article, we'll explore how to effectively use Artisan Tinker to supercharge your productivity and become a true 10x developer.

🖥 Getting started

To start using Artisan Tinker, simply run the php artisan tinker command from your terminal. This will launch the Tinker REPL, which allows you to execute PHP code in the context of your Laravel application.

Here are some tips to help you get the most out of Tinker:

✨ Magic variables

Tinker provides several magic variables that you can use to reference different parts of your Laravel application.

Variable	Value
`$_`	Last result
`$_e`	Last exception
`$__out`	Last `stdout` output
`$__file`	Last file path
`$__line`	Last line
`$__dir`	Last directory path
`$__class`	Last class name
`$__method`	Last method name
`$__function`	Last function name
`$__namespace`	Last namespace name

Last result

The result of the latest (successful) execution is always available as $_, so you can use it in your next input.



>>> 10 + 11
=> 21
>>> $_ * 2
=> 42
>>> $_
=> 42

Last exception

The last uncaught error or exception is available as $_e.

You can also use the wtf command to view the latest exception's backtrace, and show --ex to view the code which threw the exception.

To throw the most recent exception out of the current session, use the throw-up command.

Last `stdout` output

The stdout output from the last code executed is captured, and is available as $__out.



>>> echo "wat"
wat
>>> $__out
=> "wat"

Last file, line and directory

Some commands such as doc, dump, ls, and show---set additional $__file, $__line and $__dir variables, as appropriate.




>>> $__file
= "/Users/alpha/Documents/GitHub/alphaolomi/opgs/vendor/psy/psysh/src/functions.php"

>>> $__line
= 29
>>> $__dir
= "/Users/alpha/Documents/GitHub/alphaolomi/opgs/vendor/psy/psysh/src"
>>>

Last namespace, class, method and function names

Some commands such as doc and show---set additional $__namespace, $__class, $__method and $__function variables, as appropriate.



>>> show Psy\Shell::debug
  > 138|     public static function debug(array $vars = array(), $boundObject = null)
    139|     {
    140|         echo PHP_EOL;
    141|
    142|         $sh = new \Psy\Shell();
    143|         $sh->setScopeVariables($vars);
    144|
    145|         if ($boundObject !== null) {
    146|             $sh->setBoundObject($boundObject);
    147|         }
    148|
    149|         $sh->run();
    150|
    151|         return $sh->getScopeVariables(false);
    152|     }

>>> $__namespace
=> "Psy"
>>> $__class
=> "Psy\Shell"
>>> $__method
=> "Psy\Shell::debug"
>>> $__function
PHP error:  Undefined variable: __function on line 1
>>>

⏳ Managing history

Tinker also has a built-in history feature that allows you to easily recall previously executed commands. To access your command history, simply press the up and down arrow keys. The hist command is your primary interface to history. With this command, you can show, search, save or replay your shell history.

Showing history

When invoked without options, the history command shows all history. If there's a lot of it, the output will be paged.



>>> hist
0: function z() { throw new RuntimeException; }
1: function y() { z(); }
2: function x() { y(); }
3: x()
4: wtf
>>>

Show only a slice of history using the --show option: --show 3 will show a single line, --show 1..3 will show a range, and --show 3.. will show from the third to the last line of your history.



>>> hist --show 1..3
1: function y() { z(); }
2: function x() { y(); }
3: x()
>>>

The --head N and --tail M options show the first N lines and the last M lines, respectively.



>>> hist --head 3
0: function z() { throw new RuntimeException; }
1: function y() { z(); }
2: function x() { y(); }
>>> hist --tail 2
3: x()
4: wtf
>>>

Searching history

Use the --grep option to filter your history.



>>> hist --grep wtf
4: wtf
>>>

Use -i to do a case-insensitive search, and -v to show only lines which don't match the search pattern.



>>> hist --grep WTF -i -v
0: function z() { throw new RuntimeException; }
1: function y() { z(); }
2: function x() { y(); }
3: x()
>>>

The --grep search pattern can be a Perl-compatible regular expression as well.



>>> hist --grep /\{.*\}/
0: function z() { throw new RuntimeException; }
1: function y() { z(); }
2: function x() { y(); }
>>>

Replaying history

Replay your history with the --replay option. This works best when combined with --show, --head, --tail and --grep.



>>> hist --head 3 --replay
Replaying 3 lines of history
-->  function z() { throw new RuntimeException; }
-->  function y() { z(); }
-->  function x() { y(); }
>>> function_exists('x')
=> true
>>>

Saving history

Save your history to a local file with the --save FILENAME option. You can combine this with --show, --head, --tail and --grep options to limit the slice of history saved.



>>> hist --head 3 --save history.txt
Saving history in history.txt...
History saved.
>>>

Clearing history

Clear your history with the --clear option.



>>> hist --clear
History cleared.
>>> hist
>>>

💲 System shell integration

Tinker can be integrated with your system shell to provide even more powerful functionality. It can be super useful to access a system shell from inside a REPL session.

Execute arbitrary shell commands

To execute arbitrary shell commands, wrap the command in backticks.



>>> `pwd`
=> "/Projects/psysh\n"
>>> `ls`
=> = """
  README.md\n
  app\n
  artisan\n
  bootstrap\n
  composer.json\n
  composer.lock\n
  config\n
  database\n
  docs\n
  history.txt\n
  package.json\n
  phpunit.xml\n
  public\n
  resources\n
  routes\n
  storage\n
  tailwind.config.js\n
  tests\n
  vendor\n
  vercel.json\n
  vite.config.js\n
  """
>>>

PHP variables can be interpolated into shell commands as well.



>>> $readme = 'README.md'
=> "README.md"
>>> `ls -al $readme`
= "-rw-r--r--  1 alpha  staff  1441 May  1 12:34 README.md\n"
>>>

✨ Shell commands with magic variables

Some commands such as doc, dump, ls and show---update the $__file, $__dir and $__line after they run. These variables are especially useful when interpolated into shell commands.

For example, after using doc to show the documentation for a class or method, you can use the subl shell command to open that file in Sublime Text and jump to the definition.



>>> doc Psy\Shell
class Psy\Shell extends Symfony\Component\Console\Application

Description:
  The Psy Shell application.

  Usage:

      $shell = new Shell;
      $shell->run();

Author: Justin Hileman <justin@justinhileman.info>
>>> $__file
=> "/Projects/psysh/src/Psy/Shell.php"
>>> `subl $__file:$__line`
=> null
>>>

📢 Commands

Tinker provides several built-in commands that you can use to perform common tasks. You see a full list of available commands by running help.

Built-in commands

Command	Description	Aliases
	help	Show a list of commands. Type `help [foo]` for information about [foo].
	ls	List local, instance or class variables, methods and constants.
	dump	Dump an object or primitive.
	doc	Read the documentation for an object, class, constant, method or property.
	show	Show the code for an object, class, constant, method or property.
	wtf	Show the backtrace of the most recent exception.
	whereami	Show where you are in the code.
	throw-up	Throw an exception or error out of the Psy Shell.
	timeit	Profiles with a timer.
	trace	Show the current call stack.
	buffer	Show (or clear) the contents of the code input buffer.
	clear	Clear the Psy Shell screen.
	edit	Open an external editor. Afterwards, get produced code in input buffer.
	sudo	Evaluate PHP code, bypassing visibility restrictions.
	history	Show the Psy Shell history.
	exit	End the current session and return to caller.
	migrate	Run the database migrations
	migrate:install	Create the migration repository
	inspire	Display an inspiring quote
	clear-compiled	Remove the compiled class file
	down	Put the application into maintenance / demo mode
	env	Display the current framework environment
	optimize	Cache the framework bootstrap files
	up	Bring the application out of maintenance mode

🛠 Configuration

Tinker's behavior can be customized using Laravel's configuration system.

To publish Tinker's configuration file, run php artisan vendor:publish --provider="Laravel\Tinker\TinkerServiceProvider". This will create a tinker.php file in your application's config directory.

🎛 Config options

Together with the tinker.php config file, you can also directly pass options to the Psy\Shell using config files.

Add a file to ~/.config/psysh/config.php (or C:\Users\{USER}\AppData\Roaming\PsySH\config.php on Windows).



<?php
return [

    'startupMessage' => sprintf('<info>%s</info>', shell_exec('uptime')),
];

Per-project config files

For a per-project config create a .psysh.php config file in the project root directory. Both the global and the local config files are used if they exist. The global config.php is loaded first, and the local .psysh.php overrides and extends the global configuration.



<?php
return [
    'colorMode' => \Psy\Configuration::COLOR_MODE_FORCED,

    'startupMessage' => sprintf('%s', shell_exec('php artisan about')),

    'theme' => [
        // Use compact output. This can also be set by the --compact flag.
        'compact' => true,

        // The standard input prompt.
        'prompt' => '>>> ',
    ],
];

In our next article, we will dive into different recipes for using Tinker in your Laravel development. By demonstrating practical examples of how to use Tinker to debug, test, and interact with your application's code and data. Whether you are a beginner or an experienced developer, these recipes will help you improve your Tinker skills and become more efficient in your development process.

So, stay tuned for an upcoming article, and take your Laravel development skills to the next level with Artisan Tinker!

Never Miss Notifications Using SMS Github Action

Alpha Olomi — Sat, 18 Mar 2023 16:15:46 +0000

As a software engineer and open source enthusiast from Tanzania, I know firsthand the challenges of accessing the internet. Missing critical notifications when offline is a common problem in such scenarios. To tackle this problem, I created a Github Action that sends SMS notifications to a phone number using AfricasTalking Programmable SMS API. This action ensures that I receive notifications even when I am not online. In this blog post, I will introduce you to this action and show you how to use it.

This idea came when a project required a hot fix but I wasn't online in time and thus could take action in time. Then I though can't I set up a workflow that would send SMS notifications to a phone number whenever a pull request/issue is created. I was able to achieve this by using the AfricasTalking Programmable SMS API. I then decided to create a Github Action that would make it easier for other developers to set up SMS notifications in their workflows.

In 2020 I participated the GitHub Actions Hackathon. I made the first version of the action in the hackathon. I was able to improve the action and make it more robust by adding support for sending SMS notifications to multiple phone numbers. I am happy to announce version 2 of action is now available on Github.

The following are the steps to use the SMS notification Github Action:

Step 1: Create a `.github/workflows/sms.yml` file in your repository.

Step 2: Add the following content to the sms.yml file:

name: SMS Notifications
on:
  pull_request:

jobs:
  smsNotification:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: alphaolomi/actions-africastalking@main
        with:
          fromPhoneNumber: 'INFO' # or secrets.fromPhoneNumber
          toPhoneNumber: ${{ secrets.toPhoneNumber }}
          message: 'Hello World'
        env:
          AT_API_KEY: ${{ secrets.AT_API_KEY }}
          AT_USERNAME: ${{ secrets.AT_USERNAME }}`

You can customize the message to reflect the event that triggered the workflow. For example, you can send a message that says A new pull request has been created when a pull request is created. You can also send a message that says A pull request has been merged when a pull request is merged. You can also send a message that says A pull request has been closed when a pull request is closed.

Or more advanced use cases, example

message: PR \#${{ github.event.pull_request.number }} has been ${{ github.event.action }}' on ${{ github.repository }} by ${{ github.actor }}

Step 3: Add the following secrets to your repository:

AT_API_KEY - Your Africastalking API Key
AT_USERNAME - Your Africastalking Username

To get an API key, follow the instructions on the AfricasTalking website.

The SMS notification Github Action will send a notification message to the phone number specified in the toPhoneNumber field with the message specified in the message field. You can also specify a fromPhoneNumber field to set the phone number from which the message will be sent. If you do not want to expose your phone number, you can use the secrets.fromPhoneNumber field to specify a secret.

In conclusion, with this Github Actions, you can wire up many use cases and this is just one of them. This can be particularly useful for developers and community leaders in areas where internet access is challenging. By using AfricasTalking SMS API, you can easily set up SMS notifications in your workflow. The SMS notification Github Action is available on Github, and I encourage you to give it a try.

alphaolomi / actions-africastalking

Send an SMS from GitHub Actions using Africastalking Programmable SMS

📨 Africastalking SMS Action

A GitHub Action to send a text message to mobile number of choice using Africastalking Programmable SMS

Usage

Create a .github/workflows/sms.yml file in your repository.
Add the following content to the sms.yml file:

name: SMS Notification
on:
  pull_request:

jobs:
  smsNotification:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: alphaolomi/actions-africastalking@main
        with:
          fromPhoneNumber: 'INFO' # or secrets.fromPhoneNumber
          toPhoneNumber: ${{ secrets.toPhoneNumber }}
          message: 'Hello World'
        env:
          AT_API_KEY: ${{ secrets.AT_API_KEY }}
          AT_USERNAME: ${{ secrets.AT_USERNAME }}

Add the following secrets to your repository:

AT_API_KEY - Your Africastalking API Key
AT_USERNAME - Your Africastalking Username

Inputs

AT_API_KEY Required. You can get this from the Africastalking's Dashboard.
AT_USERNAME Required. Use 'sandbox' as the value for development in the test environment
fromPhoneNumber Required. The name or number the message will…

View on GitHub

Static Code analysis in Laravel with Larastan

Alpha Olomi — Thu, 16 Jun 2022 22:04:58 +0000

PHPStan focuses on finding errors in your code. It catches whole classes of bugs even before you write tests for the code.

Adds static typing to Laravel to improve developer productivity and code quality
Supports most of Laravel's beautiful magic
Discovers bugs in your code

Larastan is a phpstan/phpstan wrapper for Laravel. Discover bugs in your code without running it.

Installation



composer require nunomaduro/larastan:^2.0 --dev

Configure



touch phpstan.neon



includes:
    - ./vendor/nunomaduro/larastan/extension.neon

parameters:

    paths:
        - app

    # The level 9 is the highest level
    level: 5

    ignoreErrors:

    excludePaths:
        - ./*/*/FileToBeExcluded.php

    checkMissingIterableValueType: false

Add `format` script

Update composer.json, add a format script



"scripts": {
  "analyse": "vendor/bin/phpstan analyse",
    "post-autoload-dump": [
        "Illuminate\\Foundation\\ComposerScripts::postAutoloadDump",
        "@php artisan package:discover --ansi"
    ],
}

Ignoring errors

Ignoring a specific error can be done either with a php comment or in the configuration file:



// @phpstan-ignore-next-line
$test->badMethod();

$test->badMethod(); // @phpstan-ignore-line

When ignoring errors in PHPStan's configuration file, they are ignored by writing a regex based on error messages:

file: phpstan.neon



parameters:
    ignoreErrors:
        - '#Call to an undefined method .*badMethod\(\)#'

Run analyse



composer analyse

Further (Optional)

Try levelling up the stan level from 5 to 6 and fix the code



# from
level: 5
# to
level: 6

Run analyse



composer analyse

Happy Coding!

Forem: Alpha Olomi

PHPStan: Elevate Your PHP Code Quality with Static Analysis

What is PHPStan?

Why Use PHPStan?

Who Should Use PHPStan?

How to Use PHPStan

On Laravel Projects

Ignoring errors

What’s New in PHPStan 2.0?

Tips for Maximizing PHPStan’s Impact

Conclusion

Mastering Laravel Password Reset Customization: A Comprehensive Guide

Introduction

A Brief History of Laravel Authentication

Understanding Laravel's Password Reset Flow

What We're Building

Getting Started

Customizing the Password Reset URL

Modifying the Password Reset Email

Adding a Password Reset Success Notification

Testing Our Customizations

Conclusion

Generating PDF documents in Laravel

Laravel and DomPDF: Step by step guide to generating PDF Documents with Images and CSS

Prerequisites

Introduction

Assumptions

Step 1: Setting Up Laravel Project

Step 2: Configuring DomPDF

Step 3: Creating a Controller

Step 4: Creating a Blade Template

Step 5: Adding Routes

Step 6: Adding Images

Step 7: Optimizing Performance

Database Queries

Output Size

Page Breaks

Step 8: Advanced Configuration

Using Custom Fonts

Conclusion

Potential Series and Repository

Enhancing Your Laravel API with Treblle Platform

Welcome

What is Treblle?

Who is this tutorial for?

Integrations

Introduction

Features of Treblle API Platform

Who is Treblle for?

How Treblle Works

Using the Laravel installer

Configuration Options

Setting Up your Product model

Migration

Model factory

Model seeder

Testing the API

Generating Pest tests for your API

Writing tests

Running tests

Testing the API

Conclusion

Introducing EvPay: The Powerful Payment Gateway from Evmak

Step by step to Pest PHP testing framework in Laravel 10

Introduction

Step 0. Create new Laravel project

Using composer to create new Laravel project

Or using Laravel installer

Step 0.1. Change directory to pest-laravel

Step 1. Installation

Step 2. Run tests

Step 3. Delete the example tests

Step 4. Create new Pest unit tests

Step 5. Create Product controller

Step 6. Add Product routes to routes/api.php

Step 7. Create new Pest feature tests

it vs test function in Pest

Step 8. Run tests

Conclusion

Creating and Using Custom Helper Functions in Laravel

Step 0.1. Change directory to `pest-laravel`

Step 6. Add Product routes to `routes/api.php`

`it` vs `test` function in Pest

Last `stdout` output

Step 1: Create a `.github/workflows/sms.yml` file in your repository.

Add `format` script