Forem: soheil-khaledabadi

Introducing php-smart-validator : A Lightweight, Intuitive PHP Validation Package

soheil-khaledabadi — Fri, 30 Aug 2024 10:24:45 +0000

Introduction

Validating data is a crucial part of any web application. Whether you're developing a small website or a large-scale enterprise application, you need to ensure that your data is clean, consistent, and in the right format. Today, I'm excited to introduce php-smart-validator, a lightweight and intuitive PHP package designed to simplify data validation.

In this post, I’ll walk you through the features of php-smart-validator, how to install it, and provide a few examples to get you started!

Why php-smart-validator?

With so many PHP validation libraries out there, you might wonder why I decided to create another one. The answer is simple: ease of use and flexibility. php-smart-validator is designed to provide a minimalistic yet powerful way to handle data validation without the bloat. It aims to reduce boilerplate code and improve readability while maintaining high flexibility and customizability.

Key Features:

Simple API: Easy to use and understand, making validation quick to implement.
Lightweight: The package is minimal, ensuring it doesn’t bloat your application.
Flexible Rules: Supports a variety of validation rules, and allows for custom rule creation.
Custom Error Messages: Provides detailed and customizable error messages.
Chainable Rules: Allows chaining of multiple rules for a single data point for better readability.

Getting Started

To start using php-smart-validator, you’ll need to install it via Composer. Run the following command in your terminal:

composer require geekgrove/php-smart-validator

Once installed, you can start validating data right away!

Basic Usage

Here’s a quick example of how you can use php-smart-validator to validate user input:

require 'vendor/autoload.php';

use GeekGrove\Validator\Validator;

// Sample data to validate
$data = [
    'username' => 'john_doe',
    'email' => 'john.doe@example.com',
    'age' => 25,
];

// Define validation rules
$rules = [
    'username' => 'required|alpha_num|min:3|max:15',
    'email' => 'required|email',
    'age' => 'required|integer|min:18',
];

// Create a new validator instance
$validator = new Validator($data, $rules);

// Run validation
if ($validator->fails()) {
    // Get validation errors
    $errors = $validator->errors();
    print_r($errors);
} else {
    echo "Validation passed!";
}

In the example above, we first define an array of data to validate and then set up our rules. The Validator class takes care of the rest. If any of the data fails to pass the rules, the fails method returns true, and you can retrieve the error messages using the errors method.

Custom Validation Rules

One of the powerful features of php-smart-validator is the ability to create custom validation rules. Here’s how you can add a custom rule to check if a username is unique:

$validator->addRule('unique_username', function ($field, $value, $parameters) {
    // Check if username exists in database (example logic)
    return !User::where('username', $value)->exists();
}, 'The :attribute has already been taken.');

$rules['username'] .= '|unique_username';

if ($validator->fails()) {
    // Handle validation errors
}

With this approach, you can tailor the validation process to suit the specific needs of your application, ensuring data integrity while providing clear feedback to users.

Custom Error Messages

php-smart-validator allows you to customize the error messages for each rule, making your validation process user-friendly and more informative:

$messages = [
    'username.required' => 'Please enter a username.',
    'email.email' => 'The email address format is invalid.',
];

$validator = new Validator($data, $rules, $messages);

Chaining Rules

You can chain multiple rules for better readability and management:

$rules = [
    'username' => Validator::rule('required')->rule('alpha_num')->rule('min', 3)->rule('max', 15),
];

Conclusion

php-smart-validator is a lightweight, flexible, and easy-to-use PHP validation package designed to simplify your development workflow. Whether you're a beginner or an experienced developer, you'll find it invaluable for ensuring data integrity and consistency in your projects.

Give php-smart-validator a try today, and let me know what you think! You can find the package on GitHub at geekGroveOfficial/php-smart-validator. Contributions, feedback, and stars are all welcome!

Happy coding!

Follow me for more updates on GitHub

🚀 Build a Simple CRUD API in PHP with the Flight Framework

soheil-khaledabadi — Fri, 23 Aug 2024 21:22:39 +0000

Hello, fellow developers! 👋

If you're looking for a straightforward and lightweight PHP framework to build a RESTful API, look no further than Flight. Today, I'm excited to share a project I've been working on: a Simple CRUD API built using the Flight framework. This project serves as a boilerplate for anyone looking to quickly get started with building a CRUD application in PHP.

Why Use Flight?

Flight is a micro-framework for PHP that makes it easy to build web applications. It’s minimal, fast, and perfect for small to medium-sized projects where you want to avoid the overhead of a full-fledged framework like Laravel or Symfony. Here are some reasons why you might choose Flight for your next project:

Lightweight and Fast: With a small footprint, Flight provides just what you need to build your application without any bloat.
Easy to Learn: If you're familiar with PHP, you can quickly grasp Flight's syntax and start building right away.
Flexible: Flight allows you to structure your application as you see fit, providing freedom without enforcing a rigid structure.

About the Project

This project is a basic CRUD API that demonstrates how to use Flight for handling requests, connecting to a MySQL database, and performing CRUD operations (Create, Read, Update, Delete). It’s a great starting point for beginners or a quick setup for experienced developers.

Features

Basic CRUD Operations: Simple routes for creating, reading, updating, and deleting records in a MySQL database.
Database Configuration: Easily configurable database settings to connect to your own MySQL instance.
RESTful API Endpoints: Uses standard HTTP methods to interact with the API.
Minimal Setup: Get up and running with minimal configuration and dependencies.

Getting Started

To get started with the project, follow these steps:

1. Clone the Repository

First, clone the repository from GitHub:

git clone https://github.com/soheilkhaledabdi/php-crud-api-flight.git
cd php-crud-api-flight

2. Install Dependencies

Install the Flight framework and any other dependencies using Composer:

composer install

3. Configure Your Database

Set up your database connection in config/database.php:

return [
    'host' => 'your_database_host',
    'database' => 'your_database_name',
    'username' => 'your_database_username',
    'password' => 'your_database_password',
    'charset' => 'utf8mb4'
   ];

4. Run the Project

You can use PHP’s built-in server to run the project:

cd public
php -S localhost:8000

Then, open your browser and go to http://localhost:8000 to see the API in action.

How to Use the API

Once the server is running, you can interact with the API using tools like Postman or curl. Here’s a quick overview of the available endpoints:

Create a Record: Send a POST request to /create with JSON data.
Read Records: Send a GET request to /read to retrieve all records.
Update a Record: Send a PUT request to /update/{id} with JSON data.
Delete a Record: Send a DELETE request to /delete/{id}.

Contribute

If you have ideas to improve the project or find any bugs, feel free to open an issue or submit a pull request on GitHub. Contributions are always welcome!

Conclusion

This project is just a starting point, and there’s a lot more you can do with Flight. Whether you’re building a simple API or a more complex web application, Flight provides a flexible and lightweight solution.

I hope this project helps you get started with Flight and PHP. Happy coding! 🎉

Building an E-commerce Admin Panel with Laravel, Livewire, and Kotlin Multiplatform

soheil-khaledabadi — Fri, 24 Nov 2023 14:08:50 +0000

Hey Dev Community! 👋 Are you ready to delve into the realm of e-commerce management systems? I'm excited to share a project that combines the robustness of Laravel and Livewire for the admin panel, alongside Kotlin Multiplatform for a cross-platform shopping application.

Overview

Our aim was to craft an admin panel that streamlines the management of products, categories, and users, complemented by a dynamic API to foster seamless interactions with the shopping platform.

Application

Our shopping application, built with Jetpack Compose Multiplatform in Kotlin, empowers users to browse, search, and make purchases across Android and iOS devices with a user-friendly interface.

Tech Stack

Backend (Admin Panel):

Laravel for a strong backend foundation
Livewire for dynamic frontend interactions.

Cross-Platform Application:

Kotlin Multiplatform for shared UI components.
Kotlin Coroutines for asynchronous tasks.
Compose Multiplatform for declarative UI.
Material3 for consistent design.
Ktor for networking capabilities.
Datastore for efficient local data storage.
Precompose for streamlined development.
Koin for dependency injection.

Installation Guide

Laravel Installation:

Clone the repository: git clone https://github.com/soheilkhaledabdi/shop.git
Navigate to the directory: cd shop
Run composer install
Create a copy of .env: cp .env.example .env
Generate the application key: php artisan key:generate
Execute migrations and seed the database: php artisan migrate --seed

Key Features

Admin Dashboard: Seamlessly manage products, categories,
orders, and customers.
Laravel & Livewire: Harness Laravel's backend prowess with Livewire for reactive UI.
Full API: Enable external integrations and interactions with the shopping platform.
Table of Features

Postman Collection

Access the Postman Collection here. You can also download the JSON configuration file.

Feel free to contribute to and enhance this project by visiting the repository here. Your support by giving a star ⭐ is immensely appreciated!

Let's collaborate and build remarkable solutions together! 🚀

A Comparative Analysis of Golang and Rust: Unraveling the Strengths and Trade-offs

soheil-khaledabadi — Mon, 24 Jul 2023 10:15:01 +0000

Golang (Go) and Rust are two powerful and emerging programming languages that have gained significant popularity in recent years. While both aim to address the challenges of modern software development, they have distinct design philosophies and cater to different use cases. This article aims to provide a comprehensive comparison between Golang and Rust, shedding light on their strengths, weaknesses, and use cases to help developers make informed decisions when choosing the appropriate language for their projects.

1.Background and Origins:

Golang, also known as Go, was developed by Google in 2007 and released to the public in 2009. Its creators, Robert Griesemer, Rob Pike, and Ken Thompson, designed it with a focus on simplicity, efficiency, and concurrent programming.

Rust, on the other hand, is a product of Mozilla Research, designed by Graydon Hoare. It was first announced in 2010 and reached its 1.0 stable version in 2015. Rust aims to provide memory safety without compromising on performance, making it suitable for system-level programming.

2.Syntax and Ease of Learning:

Both Golang and Rust offer straightforward syntax with an emphasis on readability and maintainability. Golang's syntax is similar to C, which makes it familiar to developers coming from C, C++, or Java backgrounds. On the other hand, Rust's syntax might require a bit more effort to grasp, especially for those new to low-level programming languages.

Example Golang code:


package main

import "fmt"

func main() {
    fmt.Println("Hello, Golang!")
}

Example Rust code:

fn main() {
    println!("Hello, Rust!");
}

3.Memory Management:

Golang uses a garbage collector to manage memory, automatically handling memory allocation and deallocation for developers. This approach simplifies memory management but may introduce some overhead in larger applications.

Rust takes a different approach to memory management by utilizing a system of ownership and borrowing. It enforces strict rules at compile-time to ensure memory safety without relying on a garbage collector.

4.Concurrency and Parallelism:

Golang is renowned for its built-in support for concurrency through goroutines and channels. Goroutines are lightweight threads that allow developers to efficiently handle concurrent tasks. Channels facilitate communication and synchronization between goroutines.
Rust, on the other hand, provides concurrency through async/await and multi-threading. Its async/await feature allows developers to write asynchronous code, while multi-threading enables true parallelism in CPU-bound tasks.

Example Golang concurrency:

package main

import "fmt"

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "processing job", j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 5; a++ {
        <-results
    }
}

Example Rust concurrency:

use std::thread;
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;

fn worker(id: usize, jobs: Arc<Mutex<Vec<i32>>>, results: mpsc::Sender<i32>) {
    while let Some(job) = jobs.lock().unwrap().pop() {
        println!("Worker {} processing job {}", id, job);
        results.send(job * 2).unwrap();
    }
}

fn main() {
    let (results_tx, results_rx) = mpsc::channel();
    let jobs = Arc::new(Mutex::new(vec![1, 2, 3, 4, 5]));

    let mut handles = vec![];

    for id in 1..=3 {
        let jobs = jobs.clone();
        let results_tx = results_tx.clone();
        let handle = thread::spawn(move || {
            worker(id, jobs, results_tx);
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    drop(results_tx);

    for result in results_rx {
        println!("Result: {}", result);
    }
}

5.Performance and Compilation:

Examine the performance characteristics of Golang and Rust. Compare their compilation processes, runtime overhead, and execution speeds for various types of applications. Present benchmark results for real-world use cases.

6.Safety and Error Handling:

Discuss the safety features in Golang and Rust, such as Golang's type system and Rust's strict ownership model. Compare their error handling mechanisms, including error types and exception handling, and their impact on code reliability.

7.Ecosystem and Libraries:

Evaluate the maturity of the ecosystems surrounding Golang and Rust. Compare the availability and quality of libraries, frameworks, and tools for both languages. Discuss how the ecosystems support various application domains.

8.Community and Support:

Analyze the size, activity, and supportiveness of the Golang and Rust communities. Explore the resources available for learning and troubleshooting, such as documentation, forums, and open-source contributions.
Use Cases and Real-World Examples:
Provide real-world use cases where Golang and Rust excel and discuss why they are preferred in those scenarios. Highlight success stories and case studies of projects built with each language.

Thank you for your time