Building a Core PHP Single-Page CRUD API

This blog post demonstrates how to create a simple single-page CRUD (Create, Read, Update, Delete) API using only core PHP. The purpose of this project is to provide a clear and straightforward example for beginners who want to understand how to develop a RESTful API in PHP without using frameworks.

System Requirements

To run this project, ensure you have the following installed:

• PHP: This example uses the latest PHP features and syntax available in version 8.2.
• MariaDB: The example requires a MariaDB or MySQL instance for the database operations.
• cURL: A command-line tool for sending HTTP requests. Note that any REST client can be used to test the API endpoints.
• Composer: The composer.json file is included to provide context for PHP server requirements and dependencies, but it is optional for running this project.

Setup Instructions

1. Create the api.php file: Place the api.php file on any machine that has PHP configured.
2. Configure Database Connection: Ensure the database connection settings in the api.php file are correctly set for your database instance. This will allow the API to connect to the database and perform necessary operations.
3. Run the PHP Server: Start the PHP built-in server in the same folder as api.php to use the example REST calls as-is:

php -S localhost:8080

The Code

<?php

/*
 * CRUD API Example in core PHP.
 *
 * This script provides a basic implementation of a CRUD (Create, Read, Update, Delete) API
 * using PHP, PDO for database interactions, and JSON for data exchange. The API supports
 * creating, reading, updating, and deleting customer records in a MySQL database.
 * It also includes endpoints for setting up and tearing down the customers table, which are
 * available for illustrative purposes and convenience in this example, but should never be 
 * placed in a production environment.
 */

$host = '127.0.0.1';
$dbname = 'testing';
$username = 'username';
$password = 'password';

try {
    /* Establish database connection */
    $pdo = new PDO("mysql:host=$host;dbname=$dbname", $username, $password);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $exception) {
    die('Database connection failed: ' . $exception->getMessage());
}

/**
 * Validate user input data for creating or updating a customer.
 *
 * @param string[] $data The data to validate
 *
 * @return string[] The array of validation errors
 */
function validateInput(array $data): array
{
    $errors = [];
    if (empty($data['firstName'])) {
        $errors[] = 'First name is required';
    }
    if (empty($data['lastName'])) {
        $errors[] = 'Last name is required';
    }
    if (empty($data['email']) || !filter_var($data['email'], FILTER_VALIDATE_EMAIL)) {
        $errors[] = 'Valid email is required';
    }
    return $errors;
}

/* Retrieve HTTP method and path segments */
$method = $_SERVER['REQUEST_METHOD'];
$path = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
$segments = explode('/', trim($path, '/'));

/* Determine the resource and customer ID (if any) from the URL */
$resource = $segments[1] ?? '';
$customerId = $segments[2] ?? '';

switch ($resource) {
    case 'up':
        if ($method === 'POST') {
            try {
                /* Create 'customers' table if it doesn't exist */
                $sql = 'CREATE TABLE IF NOT EXISTS customers (
                    customerId CHAR(36) DEFAULT uuid() PRIMARY KEY,
                    firstName VARCHAR(255) NOT NULL,
                    lastName VARCHAR(255) NOT NULL,
                    email VARCHAR(255) NOT NULL,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                )';
                $pdo->exec($sql);
                echo json_encode(['message' => 'Table created successfully']);
            } catch (PDOException $exception) {
                http_response_code(500);
                echo json_encode(['error' => 'Failed to create table: ' . $exception->getMessage()]);
            }
        } else {
            http_response_code(405);
            echo json_encode(['error' => 'Method not allowed']);
        }
        break;

    case 'down':
        if ($method === 'DELETE') {
            try {
                /* Drop 'customers' table if it exists */
                $sql = 'DROP TABLE IF EXISTS customers';
                $pdo->exec($sql);
                echo json_encode(['message' => 'Table dropped successfully']);
            } catch (PDOException $exception) {
                http_response_code(500);
                echo json_encode(['error' => 'Failed to drop table: ' . $exception->getMessage()]);
            }
        } else {
            http_response_code(405);
            echo json_encode(['error' => 'Method not allowed']);
        }
        break;

    case 'customers':
        switch ($method) {
            case 'GET':
                if ($customerId) {
                    /* Read one customer */
                    $stmt = $pdo->prepare('SELECT * FROM customers WHERE customerId = :customerId');
                    $stmt->execute(['customerId' => $customerId]);
                    $customer = $stmt->fetch(PDO::FETCH_ASSOC);
                    if ($customer) {
                        echo json_encode($customer);
                    } else {
                        http_response_code(404);
                        echo json_encode(['error' => 'Customer not found']);
                    }
                } else {
                    /* Read all customers */
                    $stmt = $pdo->query('SELECT * FROM customers');
                    $customers = $stmt->fetchAll(PDO::FETCH_ASSOC);
                    echo json_encode($customers);
                }
                break;

            case 'POST':
                /* Create a new customer */
                $data = json_decode(file_get_contents('php://input'), true);
                $errors = validateInput($data);
                if (empty($errors)) {
                    $stmt = $pdo->prepare('INSERT INTO customers (firstName, lastName, email) VALUES (:firstName, :lastName, :email)');
                    $stmt->execute([
                        'firstName' => $data['firstName'],
                        'lastName' => $data['lastName'],
                        'email' => $data['email']
                    ]);

                    /* Fetch the customerId of the newly created customer */
                    $stmt = $pdo->query('SELECT customerId FROM customers ORDER BY created_at DESC LIMIT 1');
                    $customerId = $stmt->fetchColumn();

                    echo json_encode(['message' => 'Customer created successfully', 'customerId' => $customerId]);
                } else {
                    http_response_code(400);
                    echo json_encode(['errors' => $errors]);
                }
                break;

            case 'PUT':
                if ($customerId) {
                    /* Update an existing customer */
                    $stmt = $pdo->prepare('SELECT COUNT(*) FROM customers WHERE customerId = :customerId');
                    $stmt->execute(['customerId' => $customerId]);
                    $customerExists = $stmt->fetchColumn();

                    if ($customerExists) {
                        $data = json_decode(file_get_contents('php://input'), true);
                        $errors = validateInput($data);
                        if (empty($errors)) {
                            $stmt = $pdo->prepare('UPDATE customers SET firstName = :firstName, lastName = :lastName, email = :email WHERE customerId = :customerId');
                            $stmt->execute([
                                'firstName' => $data['firstName'],
                                'lastName' => $data['lastName'],
                                'email' => $data['email'],
                                'customerId' => $customerId
                            ]);
                            echo json_encode(['message' => 'Customer updated successfully']);
                        } else {
                            http_response_code(400);
                            echo json_encode(['errors' => $errors]);
                        }
                    } else {
                        http_response_code(404);
                        echo json_encode(['error' => 'Customer not found']);
                    }
                } else {
                    http_response_code(400);
                    echo json_encode(['error' => 'Customer ID is required']);
                }
                break;

            case 'DELETE':
                if ($customerId) {
                    /* Delete an existing customer */
                    $stmt = $pdo->prepare('DELETE FROM customers WHERE customerId = :customerId');
                    $stmt->execute(['customerId' => $customerId]);
                    echo json_encode(['message' => 'Customer deleted successfully']);
                } else {
                    http_response_code(400);
                    echo json_encode(['error' => 'Customer ID is required']);
                }
                break;

            default:
                http_response_code(405);
                echo json_encode(['error' => 'Method not allowed']);
                break;
        }
        break;

    default:
        http_response_code(404);
        echo json_encode(['error' => 'Endpoint not found']);
        break;
}

Operation Sequence Diagram

Below is a sequence diagram that shows the flow of API requests and interactions with the database.

API Endpoints

This API provides the following endpoints:

1. Bring the Application Up

• URL: /api.php/up
• Method: POST
• Description: Initializes the application and creates the customers table in the database.

curl --request POST \
  --url http://localhost:8080/api.php/up \
  --header 'Content-Type: application/json'

Example Output:

{
  "message": "Table created successfully"
}

2. Create a New Customer

• URL: /api.php/customers
• Method: POST
• Description: Creates a new customer record.

curl --request POST \
  --url http://localhost:8080/api.php/customers \
  --header 'Content-Type: application/json' \
  --data '{
  "firstName": "John",
  "lastName": "Doe",
  "email": "john.doe@example.com"
}'

Example Output:

{
  "message": "Customer created successfully",
  "customerId": "2090a31b-64aa-11ef-9cca-0242ac120002"
}

3. Update an Existing Customer

• URL: /api.php/customers/{customerId}
• Method: PUT
• Description: Updates an existing customer record by ID.

curl --request PUT \
  --url http://localhost:8080/api.php/customers/2090a31b-64aa-11ef-9cca-0242ac120002 \
  --header 'Content-Type: application/json' \
  --data '{
  "firstName": "Janet",
  "lastName": "Smith",
  "email": "jane.smith@example.com"
}'

Example Output:

{
  "message": "Customer updated successfully"
}

4. Retrieve a Customer by ID

• URL: /api.php/customers/{customerId}
• Method: GET
• Description: Retrieves a customer record by ID.

curl --request GET \
  --url http://localhost:8080/api.php/customers/2090a31b-64aa-11ef-9cca-0242ac120002

Example Output:

{
  "customerId": "2090a31b-64aa-11ef-9cca-0242ac120002",
  "firstName": "Janet",
  "lastName": "Smith",
  "email": "jane.smith@example.com",
  "created_at": "2024-08-27 19:25:32"
}

5. Retrieve All Customers

• URL: /api.php/customers
• Method: GET
• Description: Retrieves all customer records.

curl --request GET \
  --url http://localhost:8080/api.php/customers/

Example Output:

[
  {
    "customerId": "2090a31b-64aa-11ef-9cca-0242ac120002",
    "firstName": "Janet",
    "lastName": "Smith",
    "email": "jane.smith@example.com",
    "created_at": "2024-08-27 19:25:32"
  },
  {
    "customerId": "9b9a1019-65c0-11ef-87f6-0242ac140002",
    "firstName": "John",
    "lastName": "Marsh",
    "email": "john.marsh@example.com",
    "created_at": "2024-08-29 04:38:59"
  }
]

6. Delete a Customer

• URL: /api.php/customers/{customerId}
• Method: DELETE
• Description: Deletes a customer record by ID.

curl --request DELETE \
  --url http://localhost:8080/api.php/customers/2090a31b-64aa-11ef-9cca-0242ac120002

Example Output:

{
  "message": "Customer deleted successfully"
}

7. Bring the Application Down

• URL: /api.php/down
• Method: DELETE
• Description: Cleans up and destroys the customers table in the database.

curl --request DELETE \
  --url http://localhost:8080/api.php/down \
  --header 'Content-Type: application/json'

Example Output:

{
  "message": "Table dropped successfully"
}

Conclusion

This example demonstrates a fundamental RESTful API using core PHP and MariaDB. It is an excellent starting point for beginners looking to understand the basics of API development without requiring a framework. You can use this code to build upon and expand your knowledge of RESTful services in PHP.

Mastering String Concatenation in PHP: The Good, the Bad, and the Efficient

In the world of PHP development, strings are everywhere—from building dynamic HTML content to handling user input and managing database queries. But how you piece those strings together can significantly impact the performance, readability, and security of your code. While concatenating strings might seem like a basic task, choosing the right method can be the difference between efficient, maintainable code and a sluggish, hard-to-read mess. Let’s dive into the various ways to concatenate strings in PHP, explore their implications, and help you make informed decisions in your coding adventures.

1. Concatenation Operator (.)

The dot (.) operator is the workhorse of PHP string concatenation. It’s simple, intuitive, and widely used.

$str = "Hello" . " " . "World!";

Good Implications:

• Simplicity: The . operator is straightforward and easy to use.
• Ubiquity: It’s the most common method of concatenation in PHP, so it’s easily understood by most developers.

Bad Implications:

• Performance: In loops or when concatenating many strings, using . can lead to performance issues as PHP repeatedly allocates memory for the new strings.
• Readability: Concatenating multiple strings with . can reduce code readability, especially with complex expressions.

2. Concatenation Assignment Operator (.=)

When you want to append a string to an existing variable, the .= operator is your friend.

$str = "Hello";
$str .= " World!";

Good Implications:

• Efficiency: .=, which modifies the original string in place, is more efficient than repeatedly using ..
• Cleaner Code: It reduces the need for multiple variable assignments, making the code more compact.

Bad Implications:

• Performance Overhead: While more efficient than ., it can still cause performance degradation in large loops or heavy string operations.

3. Double-Quoted Strings with Variable Interpolation

PHP’s double-quoted strings allow you to insert variables directly into the string, making it a popular choice for combining strings and variables.

$name = "John";
$str = "Hello, $name!";

Good Implications:

• Readability: Variable interpolation makes your code cleaner and easier to read, especially when combining multiple variables and strings.
• Simplicity: Eliminates the need for explicit concatenation.

Bad Implications:

• Complexity in Expressions: Interpolating complex expressions can lead to confusion and potential syntax errors.
• Security Risks: Direct interpolation of user input can introduce security vulnerabilities if not properly sanitized.
• Limitations with "Deep" Variables: When dealing with "deep" variables (e.g., $parentClass->childClass->variable), simple interpolation can fail or produce unexpected results. In these cases, you should break down the expression or use concatenation with the . operator for clarity.

Example of a Deep Variable Issue:

echo "Variable: $parentClass->childClass->variable"; // This may not work as expected

Workaround:

echo "Variable: " . $parentClass->childClass->variable;

This approach ensures the variable is correctly interpreted, especially when accessing properties of nested objects.

4. Curly Brace Syntax with Variable Interpolation

For cases where variable names might collide with other text or when you want to clarify your code, curly braces {} offer a neat solution.

$name = "John";
$str = "Hello, {$name}!";

Good Implications:

• Clarity: Curly braces improve readability by clearly defining variable boundaries.
• Avoids Ambiguity: Prevents issues where variable names might conflict with adjacent text.

Bad Implications:

• Verbosity: While clear, the curly brace syntax is slightly more verbose than simple interpolation.
• Similar Risks: Shares the same risks as basic interpolation, particularly with unsanitized user input.

5. sprintf() Function

For more complex string formatting, sprintf() offers a powerful alternative, allowing you to embed variables in strings using placeholders.

$name = "John";
$str = sprintf("Hello, %s!", $name);

Good Implications:

• Flexibility: sprintf() is excellent for creating strings with complex layouts or formatting requirements.
• Control: It gives you fine-grained control over the formatting of variables, such as specifying decimal places or padding.

Bad Implications:

• Complexity: It’s more verbose and less intuitive for simple concatenations, which can make your code harder to follow.
• Performance: The formatting process adds a slight performance overhead compared to direct concatenation.

6. Array to String Conversion (implode() or join())

When dealing with arrays of strings, implode() or join() can efficiently combine them into a single string.

$parts = ["Hello", "World", "!"];
$str = implode(" ", $parts);

Good Implications:

• Efficiency: implode() is ideal for joining large numbers of strings, especially when they are already stored in an array.
• Cleaner Code: It provides a more organized way to handle multiple strings compared to repeated concatenation.

Bad Implications:

• Overkill: For simple or one-off string concatenations, using implode() might be more complex than necessary.
• Array Requirement: You need to have your strings in an array, which might not always be practical.

Conclusion

String concatenation in PHP offers multiple methods, each with its own strengths and weaknesses. Whether you’re looking for simplicity, performance, readability, or flexibility, there’s a method that fits your needs. However, understanding the implications of each approach is crucial for writing clean, efficient, and maintainable code. The next time you find yourself piecing strings together in PHP, consider the best tool for the job—and remember that sometimes, the simplest approach is the best one. And if you’re dealing with "deep" variables in classes, keep in mind the limitations of simple interpolation and adjust your approach accordingly. Happy coding!

Session Management in Core PHP Diagrammed

 HTTP requests are inherently stateless, meaning each request from a client to a server is independent, with no inherent connection to previous requests. This stateless nature poses challenges when maintaining continuity and user-specific data across multiple interactions with a web application. PHP addresses this issue through session management, as depicted in the diagram. By using sessions, PHP allows for the storage of user-specific data on the server, while a session ID stored in the client’s browser cookie ties individual requests together. This approach enables PHP to maintain state across multiple requests, allowing for a consistent user experience despite the stateless nature of HTTP. The diagram illustrates how PHP handles session creation, continuity, and expiration, ensuring that user data persists across different interactions with the application.

How to Import UTF-8 CSV Files in Excel 2024 – A Step-by-Step Guide

Introduction

Have you encountered roadblocks when trying to import UTF-8 CSV files into Excel 2024? If you've attempted the double-click routine only to meet with frustration, you're not alone. But take heart—the journey to seamless importation is closer than you think. This streamlined guide is crafted to navigate you through the process effortlessly.

Procedure

Starting Up

Start by opening Microsoft Excel 2024 and selecting a Blank Workbook. This clean slate will serve as the foundation for your data import journey.

Data Tab Navigation

Direct your attention to the "Data" tab situated in the ribbon at the top of Excel. This hub is where the magic begins!

Acquiring Data

Within the "Data" tab, you will find the "Get Data" button. Click on "From Text (Legacy)" to initiate the import of your CSV file. This step is crucial as it sets the stage for proper file handling.

File Selection

Next, navigate to the location where your Unicode CSV file is stored, select it, and then confirm your selection by clicking the "Get Data" button.

Text Import Wizardry

Upon selection, Excel will display a preview of the data. It might auto-select a file origin type, but here's a critical tip: ensure you alter the "File Origin" to "Unicode (UTF-8)" for accurate Unicode character processing.

Setting the Delimiter

Ascertain that the delimiter is correctly set to "comma" or another appropriate character that segregates your CSV values, then proceed to click "Finish".

Finalizing Import

You are presented with a choice to embed the data into an Existing or New Sheet. Choose according to your data organization preferences.

 Conclusion

By following these methodical steps, you can ensure that your UTF-8 CSV files are imported into Excel 2024 without any character encoding issues, maintaining the integrity of your precious data.

This process may seem intricate at first glance, but with practice, it becomes second nature.

Please comment if you found it helpful!

Laravel 10 Local Development: A Docker Compose for SSL, Database, Mock API, and Email

Introduction

In the modern development environment, creating a robust and flexible local development setup is crucial for success as a programmer. Laravel, a popular PHP framework, has evolved over the years to adapt to these demands. In this article, we will take a closer look at an advanced Dockerfile configuration that extends Laravel 10's out-of-the-box setup to include SSL, local testing databases, Mock API servers, and a mock email server.

The Complete File

version: '3'
services:
    laravel.test:
        build:
            context: ./vendor/laravel/sail/runtimes/8.2
            dockerfile: Dockerfile
            args:
                WWWGROUP: '${WWWGROUP}'
        image: sail-8.2/app
        container_name: ${COMPOSE_PROJECT_NAME}-application
        extra_hosts:
            - 'host.docker.internal:host-gateway'
        ports:
            - '${VITE_PORT:-5173}:${VITE_PORT:-5173}'
        environment:
            WWWUSER: '${WWWUSER}'
            LARAVEL_SAIL: 1
            XDEBUG_MODE: '${SAIL_XDEBUG_MODE:-off}'
            XDEBUG_CONFIG: '${SAIL_XDEBUG_CONFIG:-client_host=host.docker.internal}'
            IGNITION_LOCAL_SITES_PATH: '${PWD}'
        volumes:
            - '.:/var/www/html'
        depends_on:
            - mariadb
            - smtp
            - mockApiServer

    mariadb:
        image: mariadb:10.6
        container_name: ${COMPOSE_PROJECT_NAME}-mariadb
        ports:
            - '${FORWARD_DB_PORT:-3306}:3306'
        environment:
            MYSQL_ROOT_PASSWORD: '${DB_PASSWORD}'
            MYSQL_ROOT_HOST: '%'
            MYSQL_DATABASE: '${DB_DATABASE}'
            MYSQL_USER: '${DB_USERNAME}'
            MYSQL_PASSWORD: '${DB_PASSWORD}'
            MYSQL_ALLOW_EMPTY_PASSWORD: 'yes'
        volumes:
            - './docker/mariadb/storage/data:/var/lib/mysql'
            - './vendor/laravel/sail/database/mysql/create-testing-database.sh:/docker-entrypoint-initdb.d/10-create-testing-database.sh'
        healthcheck:
            test: [ "CMD", "mysqladmin" ,"ping", "-p${DB_PASSWORD}" ]
            retries: 3
            timeout: 5s

    caddy:
        build:
            context: "./docker/caddy"
            dockerfile: Dockerfile
            args:
                WWWGROUP: "${WWWGROUP}"
        container_name: ${COMPOSE_PROJECT_NAME}-caddy
        restart: unless-stopped
        ports:
            - "${APP_PORT:-80}:80"
            - "${APP_SSL_PORT:-443}:443"
        environment:
            LARAVEL_SAIL: 1
            HOST_DOMAIN: laravel.test
        volumes:
            - "./docker/caddy/Caddyfile:/etc/caddy/Caddyfile"
            - ".:/srv:cache"
            - "./docker/caddy/storage/certificates:/data/caddy/certificates/local"
            - "./docker/caddy/storage/authorities:/data/caddy/pki/authorities/local"
            - "./docker/caddy/storage/data:/data:cache"
            - "./docker/caddy/storage/config:/config:cache"
        depends_on:
            - laravel.test

    smtp:
        image: mailhog/mailhog
        container_name: ${COMPOSE_PROJECT_NAME}-email
        logging:
            driver: none  # disable saving logs
        ports:
            - "1025:1025" # smtp server
            - "8025:8025" # web ui

    mockApiServer:
        # Mock API server to test against third-party services
        # without having to hit the real production server. One does need to
        # add any desired API configurations in the mockserver-initializer.json
        # file.
        container_name: ${COMPOSE_PROJECT_NAME}-mock-api-server
        image: mockserver/mockserver
        ports:
            - "1080:1080"
        environment:
            TZ: "America/New_York"
            MOCKSERVER_PROPERTY_FILE: /config/mockserver.properties
            MOCKSERVER_INITIALIZATION_JSON_PATH: /config/mockserver-initializer.json
        volumes:
            - './docker/mockApiServer:/config'
    

The Servers

System Diagram

caddy

The caddy server is an open-source web server with automatic HTTPS. It is used to provide SSL to the Laravel application and handle reverse proxying.

Configuration

• WWWGROUP: Similar to the Laravel application server, this variable defines the group used by the web server.
• Ports: Exposes the standard HTTP and HTTPS ports.
• Environment: Contains settings related to domain handling.
• Reverse Proxy: Redirects requests to the Laravel application, adding necessary headers for proper functioning.

laravel.test

This server is responsible for hosting the Laravel application. It handles web requests, communicates with the database and APIs, and sends notifications like email.

Configuration

• WWWGROUP: This variable defines the group ID for the web server process. If unset, the default group ID from the host system is used.
• WWWUSER: This variable defines the user ID for the web server process. If it is not set, the default user ID from the host system is used. These variables are optional and can remain unset, allowing the system to use default values.
• Ports: Maps the application's internal port to an external port on the host system.
• Environment: Contains environment-specific settings like XDEBUG and IGNITION.
• Volumes: Mounts the application code into the container's file system.

mariadb

This server provides the MariaDB database system, a popular and robust open-source SQL database management system, essential for storing and managing data in your Laravel application.

Configuration

• MYSQL_ROOT_PASSWORD, MYSQL_DATABASE, etc.: These variables control the database access, defining the root password, user credentials, and even allowing for an empty password. This flexibility provides different levels of security based on your environment needs. Out of the box, Laravel uses environment variables with the DB_ prefix.
• Ports: Allows communication with the database from the host system.
• Volumes: Ensures data persistence across container restarts.
• Healthcheck: Provides a mechanism to check if the database is running properly.

smtp

The SMTP server, implemented here using Mailhog, allows for the sending of test email messages. This aids in developing and testing email functionalities within the Laravel application without the risk of accidentally sending test messages outside the local environment to real people.

Configuration

• Ports: Exposes SMTP server and web UI for interaction and inspection.

mockApiServer

The Mock API server allows for mimicking interactions with third-party applications, without the need to interact with real production servers. It helps in testing and developing features that rely on external APIs.

Configuration

• Ports: Maps the internal port to allow interactions from the host system.
• Environment: Sets up specific properties like time zones and paths to configurations. For example, mockserver-initializer.json is where you configure mock responses that would normally go to third-party production REST APIs.

COMPOSE_PROJECT_NAME

The variable 'COMPOSE_PROJECT_NAME' is used to customize the naming of Docker containers, networks, and volumes, providing a way to make the Docker compose file more portable and reusable. It affects the prefixes and network name, helping to avoid conflicts and facilitate organization.

The .env File

Located in the same folder as the docker-compose file, the .env file is a powerful way to manage environment-specific settings.

COMPOSE_PROJECT_NAME=my_project

DB_CONNECTION=mysql
DB_HOST=mariadb
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=sail
DB_PASSWORD=password
...

Conclusion

This generic Docker compose file for Laravel 10 projects not only provides a seamless local development environment but also makes it easily adaptable across various projects. By encapsulating complex setups like SSL, test databases, Mock API servers, and email handling, it offers a robust platform that can be tailored to specific needs without unnecessary complexity. Future articles may delve into each server's functionality, providing readers with even more insights into this powerful configuration.

Please let me know in the comments section to tell me about your experiences with using Laravel in Docker. What kinds of challenges have you faced? What problems and solutions have you found? Are there other Docker containers that might be useful for other developers to consider (like Redis)? Would you like additional articles focused on individual servers?

Setting Defaults in Laravel Eloquent Models: 5 Powerful Techniques

Introduction

When working with Laravel Eloquent Models, setting default values for various attributes can be an essential requirement. In this post, we'll explore five different ways to set default values in a Laravel 10 Eloquent Model, each with unique characteristics and use cases.

1. Use of the $attributes Array
   The simplest and most straightforward way to set default values for your Eloquent model's attributes. Only accepts scalar defaults and applies only to the initial object.
2. Using Accessors
   Allows considering other attributes of the Model and applies dynamically throughout the lifecycle of the Model. It enables manipulation of attribute values dynamically.
3. Using Database Defaults
   Best for attributes that have little to do with data retrieved by the application, like timestamps and IDs. It may also be used as a last resort in some cases.
4. Use of Protected static function boot()
   Allows using a method or service to set a default value at initialization. Useful when scalar defaults are not sufficient.
5. Using CastsAttributes
   Casting allows converting attribute values and setting defaults through custom casting. Requires that the attribute already be set when retrieving and may require setting an initial value (typically null) in the $attributes array.

Example: Product Model

Let's create a Product model that utilizes all the mentioned techniques on different fields:

use Illuminate\Database\Eloquent\CastsAttributes;

class Product extends Model
{
    protected $attributes = [
        'status' => 'active',
        'metadata' => null, // Initial value for custom cast
    ];

    protected $casts = [
        'metadata' => MetadataCast::class, // Custom cast for metadata
    ];

    protected static function boot()
    {
        parent::boot();

        static::creating(function ($model) {
            $model->slug = Str::slug($model->name);
        });
    }

    public function getPriceAttribute($value)
    {
        // Apply a discount or format the price based on other attributes
        return $value * 0.9; // Example: 10% discount
    }

    public function getStatusAttribute($value)
    {
        return $value ?: 'active';
    }
}

class MetadataCast implements CastsAttributes
{
    public function get($model, $key, $value, $attributes)
    {
        return json_decode($value) ?: ['default_key' => 'default_value'];
    }

    public function set($model, $key, $value, $attributes)
    {
        return json_encode($value);
    }
}

// Migration example for database defaults
Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('slug');
    $table->decimal('price');
    $table->string('status')->default('active');
    $table->timestamps(); // created_at will be set by default
});

In this example, different attributes of a product are handled using different techniques, demonstrating the flexibility and power of Laravel's Eloquent.

Conclusion

Setting default values in Laravel Eloquent Models can be achieved in various ways, each with its own strengths and use cases. From the simplest $attributes array to more complex boot methods and custom casting, Laravel provides a rich set of tools for managing default values. The provided example illustrates how these can be combined in a cohesive manner to create a robust and flexible model.

I hope this has been helpful in understanding the different techniques available. If you have any questions or need further clarification on any of the methods discussed, please feel free to leave a comment below. Additionally, if you have discovered or utilized other ways to set default values in Laravel that were not covered in this post, we encourage you to share them with the community. Your insights and contributions can help others in their development journey.

Dynamically Resizing Cross-Domain IFrames

In the age of embedded content and third-party integrations, iframes have become an essential tool for web developers. They allow us to embed content from one site into another seamlessly. However, one common challenge is resizing the iframe to fit its content, especially when dealing with cross-domain iframes, and framed content that should change the size of the page over time.

Note that to use this technique, both the parent and the third-party child web site must have code to communicate with each other. All modern browsers enforce this.

Step 1: Embed the Iframe

<iframe id="myIframe" src="https://example.com/iframe-content" width="420" height="1024" style="width:100%;border:0;overflow:hidden;" scrolling="no" allowfullscreen="allowfullscreen"></iframe>

Note that the scroll bar is hidden in this iframe to prevent it flashing when the internal content changes size.

Step 2: Set Up the Parent Window

<script>
    window.addEventListener('message', function(event) {
        if (event.origin !== 'https://example.com') return;
        var iframe = document.getElementById('myIframe');
        iframe.style.height = event.data.height + 'px';
    }, false);
</script>

Step 3: Implement the Iframe Content

<script>
    window.addEventListener("DOMContentLoaded", function () {
        setInterval(function () {
            var height = document.body.scrollHeight;
            window.parent.postMessage({height: height}, document.referrer);
        }, 250);
    });
</script>

Note that this script posts an update every 1/4 second to handle dynamic page size changes in a responsive manner at a reasonable rate.

Conclusion

Dynamically resizing cross-domain iframes is a common challenge that can be effectively addressed using the postMessage method. By combining this method with some simple JavaScript code, we can create a responsive and user-friendly experience, allowing the iframe to adjust its height based on its content.

This approach ensures a seamless integration of third-party content and enhances the overall usability of the website. It demonstrates the flexibility and power of modern web development techniques, providing a robust solution for one of the more nuanced challenges in front-end development.

Dynamically Registering Service Classes in Laravel 10

Introduction

In the process of migrating a proprietary PHP application to the Laravel 10 framework, I faced an interesting challenge. The application I was working on had 44 service classes. In Laravel, service classes are typically registered manually in the AppServiceProvider.php file. However, the thought of manually registering all these services seemed daunting and inefficient. Plus, it would be a hassle to update the AppServiceProvider.php every time a service is added, renamed, or removed. Therefore, I decided to find a way to register these service classes dynamically. This post outlines the solution I came up with.

Problem Statement

When migrating a large PHP application into Laravel, manually registering a large number of service classes is not only tedious but also prone to errors. Moreover, it's not scalable: every time we add, rename, or remove a service, we need to manually update the AppServiceProvider.php file. We need a solution that allows us to dynamically register all service classes in the application and automatically adjust when changes are made.

Solution

The solution I came up with involves using Laravel's File::allFiles() method to get all PHP files in the service classes directory and then dynamically register these classes in the AppServiceProvider.php file. The service classes are registered using Laravel's service container, which allows Laravel to automatically resolve these classes when they're needed in other parts of the application.

Here is a code snippet used to find all the classes in any package. I happen to have it in a class called ClassUtil:

/**
 * This method is used to recursively retrieve all the classes within a package that have been configured in the Composer autoloader.
 *
 * @param string $package The package name
 *
 * @return string[] The classes
 */
public function getPackageClasses(string $package): array
{
    /* Get all PHP files in the package directory */
    try {
        $basePath = base_path($package);
        $files = File::allFiles($basePath);
    } catch (Exception) {
        /* Catches the case where the default Laravel "App" package resides in the "app" folder and the server is case-sensitive. */
        $basePath = base_path(lcfirst($package));
        $files = File::allFiles($basePath);
    }
    error_log($basePath);

    $rootPath = str_replace(str_replace('/', DIRECTORY_SEPARATOR, $package), '', $basePath);

    $classes = [];
    foreach ($files as $file) {
        /* Convert the file path to a namespaced class name */
        $class = str_replace(
            ['/', '.php'],
            ['\\', ''],
            Str::after($file->getRealPath(), $rootPath)
        );

        /* Check if the class exists and is not abstract */
        if (class_exists($class) && !(new ReflectionClass($class))->isAbstract()) {
            $classes[] = $class;
        }
    }

    return $classes;
}

And this is how I use it in AppServiceProvider.php:

/**
 * Register any application services.
 *
 * @return void
 */
public function register(): void
{
    parent::register();
    foreach ((new ClassUtil())->getPackageClasses('App/Services') as $class) {
        $this->app->singleton($class, function () use ($class) {
            return new $class();
        });
    }
}

Benefits

This technique has several benefits:

• Simplicity: It saves us the trouble of manually registering each service class.
• Scalability: It allows us to easily add, rename, or remove services without having to manually update the AppServiceProvider.php file.
• Flexibility: It provides a flexible way of managing service classes, especially in large applications.

Conclusion

Dynamically registering service classes in Laravel is a handy trick that can save you a lot of time and effort, especially when dealing with large applications. I hope this post helps you in your Laravel development journey. If you have any questions or comments, feel free to leave them below!

Creating and Nesting SimpleXMLElement Objects in PHP

Introduction

When working with XML data in PHP, the SimpleXMLElement class provides a convenient way to create and manipulate XML structures. One common requirement is to create a SimpleXMLElement and add it as a child to another SimpleXMLElement. In this blog post, we'll explore the correct solution to achieve this.

Creating the Parent and Child Elements

/* Create the parent SimpleXMLElement */
$parent = new SimpleXMLElement('<parent></parent>');

/* Create the child SimpleXMLElement */
$child = new SimpleXMLElement('<child></child>');

Adding Content to the Child Element

$child->addChild('name', 'John');
$child->addChild('age', 25);

Importing and Nesting the Child Element

Now comes the crucial part: importing and nesting the child element within the parent element. We'll use the dom_import_simplexml() function to convert the SimpleXMLElement objects to DOMNode objects. Here's how it's done:

$domChild = dom_import_simplexml($child);
$domParent = dom_import_simplexml($parent);
$domChild = $domParent->ownerDocument->importNode($domChild, true);
$domParent->appendChild($domChild);

In the above code, we import the child element into the parent element's document using the importNode() method. The second argument true indicates that we want to import the entire subtree of the child node.

Printing the Final XML Structure

To see the final XML structure, we can call the asXML() method on the parent element:

echo $parent->asXML();

This will output the complete XML structure, including the parent and nested child elements.

The xmlAdopt() Method

To simplify the process of adopting a child element into a parent element, we can use a helper method called xmlAdopt():

/**
 * Adopt a SimpleXMLElement into another SimpleXMLElement.
 *
 * @param SimpleXMLElement $parent the parent element
 * @param SimpleXMLElement $child  the child element to add to the parent
 */
private function xmlAdopt(SimpleXMLElement $parent, SimpleXMLElement $child): void
{
    $domChild = dom_import_simplexml($child);
    $domParent = dom_import_simplexml($parent);
    $domChild = $domParent->ownerDocument->importNode($domChild, true);
    $domParent->appendChild($domChild);
}

Using the xmlAdopt() Method:

$this->xmlAdopt($parent, $child);

Conclusion:

Creating and nesting SimpleXMLElement objects in PHP requires careful handling

MySQL AES Encryption in Ruby

I was asked to find a way to encrypt strings in Ruby that would be compatible with MySQL's AES_ENCRYPT and AES_DECRYPT functions. I found several solutions online, but none of them worked the way I expected. After cobbling together several examples, I finally came up with a solution that proved to be compatible with the MySQL version. This was written for use with Ruby 2.3.5. This module can be used as follows:

Running a Tomcat-based Spring Boot application in Docker

In one of the projects I am working on, I was tasked from taking a Tomcat application that ran on an EC2 server, and get it running with the Spring Boot framework in a Docker container. The twist is that the application needed read-write access to the resources folder within the project. In order to do that, the application needed to be run as an "exploded" WAR file (It had been run that way on the old server as well).

I accomplished this with this Docker file:

The WAR file is compiled with the "spring-boot-maven-plugin", and includes all the dependency JARs, so the application can be run stand-alone.

That entry in the POM is:

And the "org.springframework.boot.loader.WarLauncher" Class is what Spring Boot uses to bootstrap the applicatiton on the embedded Tomcat.

OpenPojo Java 9 Compatibility Workaround

I am working on updating applications at work to Java 9. I have been using OpenPojo for years to test all my POJOs in one go. However, I found that the tests started throwing the exception:

java.lang.NoClassDefFoundError: Could not initialize class com.openpojo.reflection.java.packageloader.Package

I traced through the OpenPojo code and found that it was hard coded to read the Java class path from the old "sun.boot.class.path" system property. This property has been completely removed from Java 9, in favor of "java.class.path," which has been available since at least Java 7. (See https://docs.oracle.com/javase/8/docs/technotes/tools/windows/findingclasses.html)

I submitted my findings in an issue for the developers consideration: https://github.com/oshoukry/openpojo/issues/108

In the meantime, I developed the following workaround that can be inserted into a current POJO test class, and will allow the code to function the same way in Java 9.

Find All the Divisors for a Number

In some of my load testing, I want to run a certain number of transactions. My script takes parameters for a number of threads and the number of loops all the threads should go to. When I have a certain target number I want to get to, and an idea of what number of threads I want, I would like to figure out exactly how many loops I need to run for an exact number of threads.

For example, lets say I want to process 16,000,000 transactions with about 300 threads. I can run the following Java class, and figure out that if I use 320 threads, I need 50,000 loops.

Enter an integer: 16000000
Even divisors for 16000000
8000000 x 2 = 16000000
4000000 x 4 = 16000000
3200000 x 5 = 16000000
2000000 x 8 = 16000000
1600000 x 10 = 16000000
1000000 x 16 = 16000000
800000 x 20 = 16000000
640000 x 25 = 16000000
500000 x 32 = 16000000
400000 x 40 = 16000000
320000 x 50 = 16000000
250000 x 64 = 16000000
200000 x 80 = 16000000
160000 x 100 = 16000000
128000 x 125 = 16000000
125000 x 128 = 16000000
100000 x 160 = 16000000
80000 x 200 = 16000000
64000 x 250 = 16000000
62500 x 256 = 16000000
50000 x 320 = 16000000
40000 x 400 = 16000000
32000 x 500 = 16000000
31250 x 512 = 16000000
25600 x 625 = 16000000
25000 x 640 = 16000000
20000 x 800 = 16000000
16000 x 1000 = 16000000
15625 x 1024 = 16000000
12800 x 1250 = 16000000
12500 x 1280 = 16000000
10000 x 1600 = 16000000
8000 x 2000 = 16000000
6400 x 2500 = 16000000
6250 x 2560 = 16000000
5120 x 3125 = 16000000
5000 x 3200 = 16000000
4000 x 4000 = 16000000
3200 x 5000 = 16000000
3125 x 5120 = 16000000
2560 x 6250 = 16000000
2500 x 6400 = 16000000
2000 x 8000 = 16000000
1600 x 10000 = 16000000
1280 x 12500 = 16000000
1250 x 12800 = 16000000
1024 x 15625 = 16000000
1000 x 16000 = 16000000
800 x 20000 = 16000000
640 x 25000 = 16000000
625 x 25600 = 16000000
512 x 31250 = 16000000
500 x 32000 = 16000000
400 x 40000 = 16000000
320 x 50000 = 16000000
256 x 62500 = 16000000
250 x 64000 = 16000000
200 x 80000 = 16000000
160 x 100000 = 16000000
128 x 125000 = 16000000
125 x 128000 = 16000000
100 x 160000 = 16000000
80 x 200000 = 16000000
64 x 250000 = 16000000
50 x 320000 = 16000000
40 x 400000 = 16000000
32 x 500000 = 16000000
25 x 640000 = 16000000
20 x 800000 = 16000000
16 x 1000000 = 16000000
10 x 1600000 = 16000000
8 x 2000000 = 16000000
5 x 3200000 = 16000000
4 x 4000000 = 16000000
2 x 8000000 = 16000000
1 x 16000000 = 16000000
=== End ===

Essentially, this provides all the numbers that evenly divide the provided number. Or, in other words, find multipliers that will result in a desired product.

Cleaning Up the IntelliJ IDEA Clone Repository Dialogue Box

Over the course of the last couple of years, I have checked out dozens of projects with IntelliJ IDEA from various Git repositories. Many of these projects were one-time checkouts, and a slew of them are no longer valid because of domain name changes.

There is no internal mechanism to remove URLs from this dialogue box, and I had not found anything on the Internet on how to do this. I was certain that this information had to be in a configuration file somewhere.

I ran across this page: Directories used by the IDE, which headed me in the correct direction. I eventually found the file I was looking for (using Mac OS X):

~/Library/Preferences/<PRODUCT><VERSION>/options/vcs.xml

This file has a set of <UrlAndUserName> elements that can be individually deleted, as needed:


<application>
  <component name="GitRememberedInputs">
    <option name="visitedUrls">
      <list>
        …
        <UrlAndUserName>
          <option name="url" value="https://github.com/appium/sample-code.git" />
          <option name="userName" value="" />
        </UrlAndUserName>
        …
      </list>
    </option>
    <option name="cloneParentDir" value="$USER_HOME$/IdeaProjects" />
  </component>
</application>
 
Exit IntelliJ IDEA completely, and start it up again. The next time you use the Clone Repository dialogue box (e.g., using "Check out from Version Control" in the Welcome dialogue box), you will see the list reduced to whatever entries you left in the vcs.xml file.

This solution was tested in version 2017.1, and I confirmed the same file location for version 2016.1.