Introduction

I'm thrilled to introduce my latest package: musonza/dynamo-breeze! Bridging Laravel with Amazon DynamoDB has never been this breezy. This package emerged from the necessity to simplify and streamline the interaction between Laravel applications and DynamoDB, especially when employing a single-table design.

Why DynamoBreeze?

Working with NoSQL databases like DynamoDB brings about numerous advantages: scalability, flexibility, and performance, to name a few. However, developers often face a hurdle when trying to merge the robustness of Laravel with the agility of DynamoDB.

That's where DynamoBreeze comes in, providing a seamless integration that allows developers to interact with DynamoDB without delving deep into its complexities.

Key Features

• Single or Multiple Table Support: Whether you're adhering to a single-table design or using multiple tables, DynamoBreeze adapts to your needs, allowing for efficient interactions with your data without the complexity.

• Streamlined Configuration: Define your table structures and access patterns in a central configuration, making it easy to manage and query your data.

• Multiple AWS Credentials: DynamoBreeze's architecture facilitates the use of different AWS credentials for various tables, perfect for interacting with multiple AWS accounts or applying specific keys and secrets to individual tables. This capability ensures a flexible and secure approach to managing your data across diverse environments.

• Expressive Syntax: Leverage the power of fluent syntax to build your DynamoDB queries, making them more readable and maintainable.

use Musonza\DynamoBreeze\Facades\DynamoBreeze;

// Perform an operation
$result = DynamoBreeze::withTableIdentifier('social_media')
    ->accessPattern('FetchUserPosts', [
        'user_id' => $userId,
    ])
    ->limit(10)
    ->exclusiveStartKey($startKey)
    ->projectionExpression('Content, CategoryId')
    ->get();

// Get the items returned from DynamoDB
$items = $result->getItems();

// Get the count of items
$count = $result->getCount();

// Access the raw AWS SDK result object
$rawResult = $result->getRawResult();

• Customizable: Ready to be used out of the box, but built with customization in mind, so you can adjust it according to your application's requirements.

• Artisan Command for Table Setup: Set up your DynamoDB tables swiftly using an artisan command that reads from your configuration.

Getting Started

Install dynamo-breeze via Composer:

composer require musonza/dynamo-breeze

After publishing the configuration file:

php artisan vendor:publish --provider="Musonza\DynamoBreeze\DynamoBreezeServiceProvider"

You'll be able to define your tables, keys, and access patterns, among other settings, directly in the published configuration file.

A Quick Glimpse

Here's a small peek at how you can define your DynamoDB tables and access patterns in the configuration:

// config/dynamo-breeze.php
return [
    'tables' => [
        'social_media' => [
            'table_name' => 'SocialMediaTable',
            'partition_key' => 'PK',
            'sort_key' => 'SK',
            'attributes' => [
                'PK' => 'S',
                'SK' => 'S',
            ],
            'access_patterns' => [
                'FetchUserPosts' => [
                    'key_condition_expression' => 'PK = :pk_val AND begins_with(SK, :sk_prefix_val)',
                    'expression_attribute_values' => [
                        ':pk_val' => ['S' => 'USER#<user_id>'],
                        ':sk_prefix_val' => ['S' => 'POST#'],
                    ],
                ],
                // Additional access patterns
            ],
        ],
    ],
    //...
];

Querying DynamoDB tables using predefined access patterns becomes as simple as:

public function fetchUserPosts(int $userId): DynamoBreezeResult
{
    return DynamoBreeze::withTableIdentifier('social_media')
        ->accessPattern('FetchUserPosts', ['user_id' => $userId])
        ->get();
}

Moreover, developers can utilize the provided Artisan command to set up DynamoDB tables directly from the configuration:

php artisan dynamo-breeze:setup-tables

Embracing Multiple Tables with DynamoBreeze

While the single-table approach is often highlighted due to its wide range of benefits in DynamoDB, we understand that different applications have different needs. Some may require multiple tables due to their complex business logic or historical database designs. This is why dynamo-breeze is engineered to support configurations for multiple tables out of the box, without compromising simplicity or developer experience.

Multi-Table Configuration

In your DynamoBreeze configuration file, you are not limited to defining just one table. You can specify as many tables as your application requires, each with its unique set of attributes and access patterns.

// config/dynamo-breeze.php
return [
    'tables' => [
        // Other tables...

        'another_table' => [
            'table_name' => 'AnotherTable',
            // ... other table-specific configurations
        ],

        // Add more tables as needed...
    ],
    //...
];

Each table maintains its set of configurations, and you can interact with them individually in your application. This provides a scalable structure, accommodating projects that must operate across multiple tables due to their requirements or constraints.

Interacting with Multiple Tables

Querying and interacting with multiple tables remain as straightforward as working with a single one. Here's how you can fetch data from a different table:

public function fetchAnotherResource(int $resourceId): DynamoBreezeResult
{
    return DynamoBreeze::withTableIdentifier('another_table')
        ->accessPattern('FetchSpecificResource', ['resource_id' => $resourceId])
        ->get();
}

Seamless Management with Artisan

Despite adding more tables to your configuration, the process of managing them doesn't get complicated. The provided Artisan command php artisan dynamo-breeze:setup-tables smartly reads from your configuration and sets up all the tables, regardless of their count.

php artisan dynamo-breeze:setup-tables

In Closing

Whether you're an advocate of the single-table design or your application demands multiple tables, DynamoBreeze accommodates your needs, ensuring you still enjoy a breezy developer experience. With support for multiple tables, it gracefully scales with your application's needs, ensuring you don't have to compromise on the database design principles pertinent to your project's success.

As always, for detailed documentation and examples, visit the official repository. Your feedback and contributions are invaluable in making dynamo-breeze even more versatile and suited to your needs!