DEV Community: Mahmoud Adel

Discover 7 Professional CSS Tools to Boost Your Design & Development Workflow — From Codezelo

Mahmoud Adel — Sun, 07 Dec 2025 14:38:20 +0000

In today’s fast-paced digital world, designers and developers need tools that are fast, intuitive, and efficient. Tools that reduce repetitive work, speed up experimentation, and help produce clean, professional results — without wasting hours adjusting values manually.

That’s exactly why Codezelo was created.
A free platform offering a suite of interactive CSS tools built to help front-end developers and UI/UX designers craft beautiful components with real-time preview and ready-to-use CSS code.

In this article, you’ll discover the 7 most powerful tools available right now on Codezelo — and how each one can level up your workflow.

1. Border Radius Playground

Create smooth, elegant corners in seconds

The Border Radius Playground allows you to experiment with different corner radius values using a clean and simple interface.
Whether you're designing cards, buttons, or layout components, the tool gives you precise control over each corner — with instant visual feedback.

Features:

Adjust each corner independently
Real-time preview
One-click CSS code generation

2. Box Shadow Playground

Design clean, realistic shadows effortlessly

Shadows play a major role in visual hierarchy and depth.
This tool lets you fine-tune offsets, blur, spread, and color — and preview every change instantly, making it easy to create shadows that fit your design perfectly.

Features:

Full control over X & Y offset
Adjustable blur and spread
Color customization
Ready-to-copy CSS code

3. CSS Gradient Playground

Turn colors into stunning visual backgrounds

Perfect for modern UI design, this tool lets you create beautiful color gradients with full control over direction, color stops, and style.

Features:

Supports linear and radial gradients
Unlimited gradient stops
Instantly generated CSS code

4. CSS Animation Playground

Bring motion to your UI with ease

Animations make interfaces feel alive and engaging.
Instead of writing keyframes from scratch, this tool allows you to visually control duration, delay, timing function, and iteration — with a live preview.

Features:

Visual animation builder
Full control over animation properties
Automatic @keyframes + CSS export

5. CSS Flexbox Playground

Master responsive layout design

Flexbox is one of the most essential tools in modern web layout creation.
This playground provides a hands-on environment to experiment with all major Flexbox properties and instantly understand how each value behaves.

Features include:

flex-direction
justify-content
align-items
flex-wrap
And more… with real-time preview

6. CSS Grid Playground

Build complex grid layouts effortlessly

CSS Grid is powerful — but sometimes tricky.
This tool makes grid design intuitive, allowing you to adjust columns, rows, spacing, and gaps visually.

Features:

Full control over rows and columns
Supports auto-fit & auto-fill
Instant CSS code output

7. CSS Transform Playground

Experiment with transformations visually

Transforms are great for creating dynamic and interactive UI effects.
This tool lets you try out scale, rotate, translate, and skew values in real time — and see immediate results on the element.

Features:

Live manipulation of transform values
Visual preview of effects
Ready-to-use CSS code included

Why Codezelo?

Clean, intuitive interface
Real-time previews for every change
Instant, ready-to-use CSS code
100% free
Designed for modern front-end developers and UI/UX designers

If you're looking to speed up your workflow, experiment faster, and create cleaner UI components — Codezelo offers tools that make your work simpler and more enjoyable.

Try the tools now on Codezelo

Free tools • Faster design • Better results

(https://www.codezelo.com/en/tags/css-tools/)

Final Thoughts

Whether you're a front-end developer, a UI/UX designer, or even a beginner exploring CSS, these tools will help you build cleaner, more professional designs — without writing complicated code.

If you found this article helpful, feel free to share it to help more developers discover these tools ❤️

Building an Online Store Using Only HTML, CSS, and JavaScript — My First Practical Coding Project

Mahmoud Adel — Thu, 16 Oct 2025 10:13:20 +0000

Hey everyone 👋

I recently completed my first real coding project — an online store built completely from scratch using only HTML, CSS, and JavaScript. 🛒

No frameworks, no libraries, no complex build tools — just pure, hands-on frontend coding.

🧠 Why I Did It

I wanted to understand how real online stores work at the most fundamental level.

So instead of relying on templates or pre-made frameworks, I built everything myself — step by step.

🛠️ What I Learned

Here’s a quick breakdown of what I built and learned along the way:

HTML Structure – I created the product layout, navigation, and cart sections using semantic HTML.
CSS Styling – Styled everything with Flexbox and Grid for a clean, responsive look.
JavaScript Logic – Added a simple cart system with “add” and “remove” functions.
Interactivity – Made the total update dynamically and displayed items in real time.

It’s not a massive project — but it helped me understand the core of frontend development better than any tutorial could.

🧩 See the Full Tutorial

I documented the full project on my website with step-by-step instructions and complete code examples.

👉 Read the full tutorial here in CodeZelo Website

If you’re just getting started with web development, this is a great beginner-friendly project to practice your HTML, CSS, and JS skills while creating something real. 💪

Let me know what you think — or share your version if you build it too!

Beginner's Guide to Learn HTML: Your First Step in Web Development

Mahmoud Adel — Wed, 25 Dec 2024 15:14:36 +0000

Now that we know the basics of web development, it's time to learn the basics of HTML, the backbone of the web development world. Especially the front-end.

Learn HTML

HTML is characterized by giving us the ability to control how content is displayed on the browser, and opens up wide areas for us to format texts, images, and other elements in an interactive and effective way.

An HTML file contains codes known as "tags", which allow us to direct the browser to perform certain commands, such as how to display texts or organize the page.

What is HTML? Understanding the basics of coding and tags for beginners

In HTML, coding is done using texts with special meaning called "tags". Most tags appear in a specific way,

<Opening-Tag> Specific text </Closing-Tag>

Where the text is surrounded by symbols less than < and greater than >. For example, the tag <strong> is used to make the text inside it prominent.

<strong>Bold Text</strong>

Here's another example of a tag used to emphasize text, called <em>. This tag itals the embedded text to indicate its importance, as in:

<em>Italic Text</em>

Using Tags in HTML

HTML Tag Structure Explained

Every element starts with an opening tag and ends with a closing tag. For example, the opening tag <figcaption> is followed by the closing tag </em>, where the latter is marked with a slash /.

In HTML, tags that come in pairs are essential; a tag cannot be opened without being closed, similar to parentheses where a parenthesis cannot be closed without being opened first.

This helps to build a proper structure for the content, which is a fundamental concept in programming languages.

Element vs. Tag: Understanding the Difference

In HTML, the entire unit that contains the opening tag and the closing tag, as well as the content inside, is called an "Element".

Element and Tag in HTML

Only the opening tag and the closing tag are called a "tag". Although some people use the term "tag" to refer to the entire element, knowing this distinction is important in programming to ensure proper interaction with the browser.

Click here To Read Full Article

Web Development Basics: Are You Ready to Start Your Journey?

Mahmoud Adel — Tue, 03 Dec 2024 12:02:32 +0000

To start your journey of learning web programming, it is essential to have a basic understanding of programming. In this guide, we will answer some of the questions that come to mind for any beginner who intends to enter the world of web development, the first of which is: What is web development?

Introduction to Web Development

Together we will learn about the concept of the web, then we will review the basic structuring language in this field, which is HTML. We will start by learning the basics of HTML, the language used to build and write web pages.

We will also discuss the concept of links or URLs, which represent addresses that point to other documents and sites on the Internet. Step by step, we will reach the stage of creating your first page on the web. But first of all, let's start by understanding the basics of the web and where we should start in this broad field.

What is Web Development?

It is one of the most famous fields of programming and freelancing. The field of web development specializes in creating and programming websites, applications and web pages.

What are the fields of web development?

For you, learning web programming is one of the most important decisions you will make in your life if you are passionate about this field. Then you will have to choose from the three most important fields in web development:

All of this will be explained in separate posts. In this article, we will just take a general idea about the field without going into many details.

Anyone interested in this field should take a quick look at some basic concepts, including the definition of the web.

What is the web: How does it work and how is it built?

What is web

We previously knew what web development is. But now we must define the web and also know its basic structure.

The web is a set of documents written in HTML, along with other resources such as images and videos, as well as programs and services that interact with each other to produce a distinctive web page.

Everything you can access using your web browser is part of the web, and these resources are distributed across thousands of different computer systems called servers.

The web is a hypertext system, which means that web pages can contain links to other pages, and users can follow those links to get to the information they want.

That’s what you do every time you click on a link in a blog post or news article. We call these hyperlinks, short for “link.” The ability to navigate from one page to another is what makes the web special.

This ability is also used when you embed an image, video, or piece of code in a web page. Hypertext is a very important element, as all web technologies are built around the idea of documents and data that can be linked to each other in a hypertext manner.

That’s why the web is called the “Spider Web” because pages, sites, and other resources are interconnected and interconnected like a spider’s web. How exactly does that work? That’s what we’ll learn in this article.

HTML: The basic language for building web pages and why it matters.

Why HTML is the foundation of every web page

HTML is not a programming language, but without it the web as we know it today would not exist. It is the main structure for building a web page and the basis for planning and building any website.

As we will learn in the future about HTML tags, we will discover how important these tags are in shaping the web page and designing its main structure exactly as you want. It is the first language that we will learn as part of the basics of web development.

HTML Evolution: How did it shape the future of web development?

The HTML (HyperText Markup Language) language has witnessed many developments since its inception to become the main pillar in web development. Since its beginnings, when it provided a few tags that were only enough to format texts, insert links and images, and create a simple web page,

until the latest version of it, HTML5 (version five), appeared, which brought many features such as LocalStorage, Canvas API, and SVG.

These features enabled web developers and designers to implement creative ideas that include exciting animated and interactive graphics directly on the browser. We do not know what the future holds for us!

How the Internet Communicates: Understanding the Relationship Between Browsers and Servers

How Browsers and Servers Work Together

What does a web server consist of?

Mostly. These servers are basically computers, although not the ones you're using now, that run programs that respond to browser requests.

What does a server do?

To complete the journey click here

How to delete data from one to many relationship in Laravel?

Mahmoud Adel — Sun, 20 Aug 2023 00:00:00 +0000

Delete data using the user form.

First go to routes/web.php file and add this route:

Route::get('/users/posts/delete', function () {
    $user = User::with('posts')->find(1);
    $user->posts()->whereIn('id', [1, 2])->delete();
    return response()->json($user);
});

We open the browser and go to the new URL http://127.0.0.1:8000/users/posts/delete to find that the post has been deleted successfully.

{
  "id": 1,
  "username": "John Doe Updated",
  "created_at": "2023-09-06T17:24:02.000000Z",
  "updated_at": "2023-09-06T18:49:54.000000Z",
  "posts": [
    {
      "id": 5,
      "title": "Post title 5",
      "body": "Post body 5",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    },
    {
      "id": 6,
      "title": "Post title 6",
      "body": "Post body 6",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    }
  ]
}

Delete data using the publication form.

First go to routes/web.php file and add this path:

Route::get('/posts/user/delete', function () {
    $post = Post::with('user')->findOrFail(2);
    $post->delete();
});

We open the browser and go to the new URL http://127.0.0.1:8000/posts/user/delete. We see that the post has been successfully deleted.

Conclusion

This article is a continuation of the entire series on Laravel Eloquent Relationships Relationships within Laravel. We have covered one-to-many relationship in a complete manner. We have not spared any information for you, and, God willing, we will learn in the following explanation about the relationship of many to many.

You can find the repo of this series on github here

How to update a one-to-many relationship in Laravel?

Mahmoud Adel — Sat, 19 Aug 2023 00:00:00 +0000

Update data using the user form.

1- Using push method.

First go to routes/web.php file and modify this route:

Route::get('/users/update', method () {
    $user = User::with('posts')->find(1);
    $post = $user->posts()->whereId(1)->first();
    $post->title = 'Post title 1 updated';
    $post->push();
    return response()->json($user);
});

We open the browser and go to the new URL http://127.0.0.1:8000/users/update to find that the post has been updated successfully.

{
  "id": 1,
  "username": "John Doe",
  "created_at": "2023-09-06T17:24:02.000000Z",
  "updated_at": "2023-09-06T17:25:58.000000Z",
  "posts": [
    {
      "id": 1,
      "title": "Post title 1 updated",
      "body": "Post body 1",
      "user_id": 1,
      "created_at": "2023-09-06T17:28:58.000000Z",
      "updated_at": "2023-09-06T18:37:30.000000Z"
    },
    {
      "id": 5,
      "title": "Post title 5",
      "body": "Post body 5",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    },
    {
      "id": 6,
      "title": "Post title 6",
      "body": "Post body 6",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    }
  ]
}

2- Using update method.

First go to the file routes/web.php and modify this route.

Route::get('/users/update', method () {
    $user = User::with('posts')->find(1);
    $post = $user->posts()->whereId(1)->first();
    $post->title = 'Post title 1';
    $post->update();
    return response()->json($user);
]);

We open the browser and go to the new URL http://127.0.0.1:8000/users/update to find that the post has been updated successfully.

{
  "id": 1,
  "username": "John Doe",
  "created_at": "2023-09-06T17:24:02.000000Z",
  "updated_at": "2023-09-06T17:25:58.000000Z",
  "posts": [
    {
      "id": 1,
      "title": "Post title 1",
      "body": "Post body 1",
      "user_id": 1,
      "created_at": "2023-09-06T17:28:58.000000Z",
      "updated_at": "2023-09-06T18:41:35.000000Z"
    },
    {
      "id": 5,
      "title": "Post title 5",
      "body": "Post body 5",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    },
    {
      "id": 6,
      "title": "Post title 6",
      "body": "Post body 6",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    }
  ]
}

Update data using the post form.

1- Using push method.

First go to routes/web.php file and add this route:

Route::get('/posts/update', method () {
    $post = Post::with('user')->find(1);
    $post->title = 'Post title 1 updated';
    $post->user->username = 'John Doe Updated';
    $post->push();
    return response()->json($post);
});

We open the browser and go to the new URL http://127.0.0.1:8000/posts/update to find that the post has been updated successfully.

{
  "id": 1,
  "title": "Post title 1 updated",
  "body": "Post body 1",
  "user_id": 1,
  "created_at": "2023-09-06T17:28:58.000000Z",
  "updated_at": "2023-09-06T18:50:30.000000Z",
  "user": {
    "id": 1,
    "username": "John Doe Updated",
    "created_at": "2023-09-06T17:24:02.000000Z",
    "updated_at": "2023-09-06T18:49:54.000000Z"
  }
}

2- Using update method.

First go to the file routes/web.php and modify this route.

Route::get('/posts/update', method () {
    $post = Post::with('user')->find(1);
    $post->user->username = 'John Doe';
    $post->update([
        'title' => 'Post title 1'
    ]);
    return response()->json($post);
]);

We open the browser and go to the new URL http://127.0.0.1:8000/posts/update to find that the post has been updated successfully.

{
  "id": 1,
  "title": "Post title 1",
  "body": "Post body 1",
  "user_id": 1,
  "created_at": "2023-09-06T17:28:58.000000Z",
  "updated_at": "2023-09-06T18:55:45.000000Z",
  "user": {
    "id": 1,
    "username": "John Doe",
    "created_at": "2023-09-06T17:24:02.000000Z",
    "updated_at": "2023-09-06T18:49:54.000000Z"
  }
}

You can find the repo of this series on github here

How can you retrieve data from a one-to-many relationship in Laravel?

Mahmoud Adel — Fri, 18 Aug 2023 00:00:00 +0000

We saw how data is saved in multiple different ways within the database using the One-To-Many relationship in Laravel.
But how to fetch data from the database?
There are several ways in which data can be fetched from a database.
These methods are divided into two basic methods:

Through the user `User Model`

This method is divided into two sub-methods depending on how the data is organized after it is fetched from the data base

Without using `API Resources`.

1- We go first to the routes/web.php file so that we can test these methods and make the following modifications.

use App\Models\User;
---
Route::get('/users', function () {
    $users = User::with(['profile', 'posts'])->get();
    return view('users.list', compact('users'));
});

Here we can choose the columns for each relationship as follows.

use App\Models\User;
---
Route::get('/users', function () {
    $users = User::with(['profile:id,firstname,lastname,user_id', 'posts:title,user_id'])->get();
    return view('users.list', compact('users'));
});

In order to know the difference between selecting or not selecting columns from the database, let us see the specific response to each case.

In the first case, with all data retrieved without exception, we find that $users contains that data.

[
  {
    "id": 1,
    "username": "John Doe",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "id": 1,
      "firstname": "John",
      "lastname": "Doe",
      "birthday": "08-11-1991",
      "user_id": 1,
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    },
    "posts": [
      {
        "id": 1,
        "title": "Post title 1",
        "body": "Post body 1",
        "user_id": 1,
        "created_at": "2023-08-07T06:23:41.000000Z",
        "updated_at": "2023-08-07T06:23:41.000000Z"
      },
      {
        "id": 5,
        "title": "Post title 5",
        "body": "Post body 5",
        "user_id": 1,
        "created_at": "2023-08-07T06:23:41.000000Z",
        "updated_at": "2023-08-07T06:23:41.000000Z"
      },
      {
        "id": 6,
        "title": "Post title 6",
        "body": "Post body 6",
        "user_id": 1,
        "created_at": "2023-08-07T06:23:41.000000Z",
        "updated_at": "2023-08-07T06:23:41.000000Z"
      }
    ]
  },
  {
    "id": 2,
    "username": "Tom Cruz",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "id": 2,
      "firstname": "Tom",
      "lastname": "Cruz",
      "birthday": "01-02-2000",
      "user_id": 2,
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    },
    "posts": [
      {
        "id": 2,
        "title": "Post title 2",
        "body": "Post body 2",
        "user_id": 2,
        "created_at": null,
        "updated_at": null
      },
      {
        "id": 3,
        "title": "Post title 3",
        "body": "Post body 3",
        "user_id": 2,
        "created_at": null,
        "updated_at": null
      },
      {
        "id": 7,
        "title": "Post title 7",
        "body": "Post body 7",
        "user_id": 2,
        "created_at": "2023-08-07T06:23:41.000000Z",
        "updated_at": "2023-08-07T06:23:41.000000Z"
      }
    ]
  },
  {
    "id": 3,
    "username": "Adam Smith",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "id": 3,
      "firstname": "Adam",
      "lastname": "Smith",
      "birthday": "01-01-1999",
      "user_id": 3,
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    },
    "posts": [
      {
        "id": 4,
        "title": "Post title 4",
        "body": "Post body 4",
        "user_id": 3,
        "created_at": "2023-08-07T06:23:41.000000Z",
        "updated_at": "2023-08-07T06:23:41.000000Z"
      }
    ]
  }
]

In the second case, when specifying the exact required columns from the database, we find that the response is as follows.

[
  {
    "id": 1,
    "username": "John Doe",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "id": 1,
      "firstname": "John",
      "lastname": "Doe",
      "user_id": 1
    },
    "posts": [
      {
        "title": "Post title 1",
        "user_id": 1
      },
      {
        "title": "Post title 5",
        "user_id": 1
      },
      {
        "title": "Post title 6",
        "user_id": 1
      }
    ]
  },
  {
    "id": 2,
    "username": "Tom Cruz",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "id": 2,
      "firstname": "Tom",
      "lastname": "Cruz",
      "user_id": 2
    },
    "posts": [
      {
        "title": "Post title 2",
        "user_id": 2
      },
      {
        "title": "Post title 3",
        "user_id": 2
      },
      {
        "title": "Post title 7",
        "user_id": 2
      }
    ]
  },
  {
    "id": 3,
    "username": "Adam Smith",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "id": 3,
      "firstname": "Adam",
      "lastname": "Smith",
      "user_id": 3
    },
    "posts": [
      {
        "title": "Post title 4",
        "user_id": 3
      }
    ]
  }
]

Here we see the difference between the two cases in the size of the data that was processed, and the matter increases if the size of the data is much larger than that.
When selecting specific columns in relationships, you must choose foreignKey because without choosing it, the data will not be returned correctly from the database.

2- We go to the following path resources/views/users and modify this file list.blade.php to display the users and their profiles. Also, what interests us here is displaying the posts for each user.

<table>
    <thead>
        <tr>
            <th style="text-align: center">Username</th>
            <th style="text-align: center">Firstname</th>
            <th style="text-align: center">Lastname</th>
            <th style="text-align: center">Posts</th>
        </tr>
    </thead>
    <tbody>
        @foreach ($users as $user)
            <tr>
                <td>{{ $user->username }}</td>
                <td>{{ $user->profile->firstname }}</td>
                <td>{{ $user->profile->lastname }}</td>
                <td>
                    <ul>
                        @foreach ($user->posts as $post)
                            <li>{{ $post->title }}</li>
                        @endforeach
                    </ul>
                </td>
            </tr>
        @endforeach
    </tbody>
</table>

3- Open the browser and go to the following link http://127.0.0.1:8000/users to see what results will appear.

By using `API Resources`.

1- We will create an API Resource for the Post form by executing this command in the command prompt.

php artisan make:resource PostResource

2- You go to the following path App/Http/Resources and we begin to modify each of the following:

PostResource.php.

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class PostResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'body' => $this->body,
        ];
    }
}

3- We first go to the routes/api.php file to add a new route.

use App\Models\User;
use App\Http\Resources\UserResource;
---
Route::get('/users', function () {
    $users = User::with(['profile', 'posts'])->get();
    $usersResource = UserResource::collection($users);
    return response()->json($usersResource);
});

4- Open the browser and go to the following link http://127.0.0.1:8000/api/users to see what results will appear.

[
  {
    "id": 1,
    "username": "John Doe",
    "profile": {
      "id": 1,
      "firstname": "John",
      "lastname": "Doe"
    },
    "postss": [
      {
        "user_id": 1,
        "title": "Post title 1"
      },
      {
        "user_id": 1,
        "title": "Post title 5"
      },
      {
        "user_id": 1,
        "title": "Post title 6"
      }
    ]
  },
  {
    "id": 2,
    "username": "Tom Cruz",
    "profile": {
      "id": 2,
      "firstname": "Tom",
      "lastname": "Cruz"
    },
    "postss": [
      {
        "user_id": 2,
        "title": "Post title 2"
      },
      {
        "user_id": 2,
        "title": "Post title 3"
      },
      {
        "user_id": 2,
        "title": "Post title 7"
      }
    ]
  },
  {
    "id": 3,
    "username": "Adam Smith",
    "profile": {
      "id": 3,
      "firstname": "Adam",
      "lastname": "Smith"
    },
    "postss": [
      {
        "user_id": 3,
        "title": "Post title 4"
      }
    ]
  }
]

We also see here that we fetch only the required data.

Through the post `Post Model`

This method is divided into two sub-methods depending on how the data is organized after it is fetched from the data base

Without using `API Resources`.

1- We first go to the routes/web.php file so that we can test these methods and add this new route.

use App\Models\Post;
---
Route::get('/posts', function () {
    $posts = Post::with('user', 'user.profile')->get();
    return view('posts.list', compact('posts'));
});

Here we can choose the columns for each relationship as follows.

use App\Models\Post;
---
Route::get('/posts', function () {
    $posts = Post::with('user:username,id', 'user.profile:firstname,lastname,user_id')->get();
    return view('posts.list', compact('posts'));
});

In order to know the difference between selecting or not selecting columns from the database, let us see the specific response to each case.

In the first case, with all data retrieved without exception, we find that $posts contains that data.

[
  {
    "id": 1,
    "title": "Post title 1",
    "body": "Post body 1",
    "user_id": 1,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "id": 1,
      "username": "John Doe",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 2,
    "title": "Post title 2",
    "body": "Post body 2",
    "user_id": 2,
    "created_at": null,
    "updated_at": null,
    "user": {
      "id": 2,
      "username": "Tom Cruz",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 3,
    "title": "Post title 3",
    "body": "Post body 3",
    "user_id": 2,
    "created_at": null,
    "updated_at": null,
    "user": {
      "id": 2,
      "username": "Tom Cruz",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 4,
    "title": "Post title 4",
    "body": "Post body 4",
    "user_id": 3,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "id": 3,
      "username": "Adam Smith",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 5,
    "title": "Post title 5",
    "body": "Post body 5",
    "user_id": 1,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "id": 1,
      "username": "John Doe",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 6,
    "title": "Post title 6",
    "body": "Post body 6",
    "user_id": 1,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "id": 1,
      "username": "John Doe",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 7,
    "title": "Post title 7",
    "body": "Post body 7",
    "user_id": 2,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "id": 2,
      "username": "Tom Cruz",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  }
]

In the second case, when specifying the exact required columns from the database, we find that the response is as follows.

[
  {
    "id": 1,
    "title": "Post title 1",
    "body": "Post body 1",
    "user_id": 1,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "username": "John Doe",
      "id": 1,
      "profile": {
        "firstname": "John",
        "lastname": "Doe",
        "user_id": 1
      }
    }
  },
  {
    "id": 2,
    "title": "Post title 2",
    "body": "Post body 2",
    "user_id": 2,
    "created_at": null,
    "updated_at": null,
    "user": {
      "username": "Tom Cruz",
      "id": 2,
      "profile": {
        "firstname": "Tom",
        "lastname": "Cruz",
        "user_id": 2
      }
    }
  },
  {
    "id": 3,
    "title": "Post title 3",
    "body": "Post body 3",
    "user_id": 2,
    "created_at": null,
    "updated_at": null,
    "user": {
      "username": "Tom Cruz",
      "id": 2,
      "profile": {
        "firstname": "Tom",
        "lastname": "Cruz",
        "user_id": 2
      }
    }
  },
  {
    "id": 4,
    "title": "Post title 4",
    "body": "Post body 4",
    "user_id": 3,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "username": "Adam Smith",
      "id": 3,
      "profile": {
        "firstname": "Adam",
        "lastname": "Smith",
        "user_id": 3
      }
    }
  },
  {
    "id": 5,
    "title": "Post title 5",
    "body": "Post body 5",
    "user_id": 1,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "username": "John Doe",
      "id": 1,
      "profile": {
        "firstname": "John",
        "lastname": "Doe",
        "user_id": 1
      }
    }
  },
  {
    "id": 6,
    "title": "Post title 6",
    "body": "Post body 6",
    "user_id": 1,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "username": "John Doe",
      "id": 1,
      "profile": {
        "firstname": "John",
        "lastname": "Doe",
        "user_id": 1
      }
    }
  },
  {
    "id": 7,
    "title": "Post title 7",
    "body": "Post body 7",
    "user_id": 2,
    "created_at": "2023-08-07T06:23:41.000000Z",
    "updated_at": "2023-08-07T06:23:41.000000Z",
    "user": {
      "username": "Tom Cruz",
      "id": 2,
      "profile": {
        "firstname": "Tom",
        "lastname": "Cruz",
        "user_id": 2
      }
    }
  }
]

When choosing specific columns in the relationships, you must choose id and you must choose the user relationship, because without you choosing it, the user will not return with the post.

<table>
    <thead>
        <tr>
            <th style="text-align: center">Username</th>
            <th style="text-align: center">Firstname</th>
            <th style="text-align: center">Lastname</th>
            <th style="text-align: center">Posts</th>
        </tr>
    </thead>
    <tbody>
        @foreach ($users as $user)
            <tr>
                <td>{{ $user->username }}</td>
                <td>{{ $user->profile->firstname }}</td>
                <td>{{ $user->profile->lastname }}</td>
                <td>
                    <ul>
                        @foreach ($user->posts as $post)
                            <li>{{ $post->title }}</li>
                        @endforeach
                    </ul>
                </td>
            </tr>
        @endforeach
    </tbody>
</table>

3- Open the browser and go to the following link http://127.0.0.1:8000/users to see what results will appear.

By using `API Resources`.

1- You go to the following path App/Http/Resources and we start editing the file PostResource.php:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class PostResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'body' => $this->body,
            'user' => UserResource::make($this->whenLoaded('user')),
        ];
    }
}

2- We first go to the routes/web.php file to add a new route.

use App\Models\Post;
use App\Http\Resources\PostResource;
---
Route::get('/posts', function () {
    $posts = Post::with(['user'])->get();
    $postsResource = PostResource::collection($posts);
    return response()->json($postsResource);
});

3- Open the browser and go to the following link http://127.0.0.1:8000/api/posts to see what results will appear.

[
  {
    "id": 3,
    "title": "Post title 3",
    "body": "Post body 3",
    "user": {
      "id": 2,
      "username": "Tom Cruz"
    }
  },
  {
    "id": 4,
    "title": "Post title 4",
    "body": "Post body 4",
    "user": {
      "id": 3,
      "username": "Adam Smith"
    }
  },
  {
    "id": 5,
    "title": "Post title 5",
    "body": "Post body 5",
    "user": {
      "id": 1,
      "username": "John Doe Updated"
    }
  },
  {
    "id": 6,
    "title": "Post title 6",
    "body": "Post body 6",
    "user": {
      "id": 1,
      "username": "John Doe Updated"
    }
  },
  {
    "id": 7,
    "title": "Post title 7",
    "body": "Post body 7",
    "user": {
      "id": 2,
      "username": "Tom Cruz"
    }
  }
]

We also see here that we fetch only the required data.

You can find the repo of this series on github here

How to insert data in one to many relationship in database?

Mahmoud Adel — Thu, 17 Aug 2023 00:00:00 +0000

After we created a One-To-Many relationship between both Users table and Posts table and added hasMany inside User Model, also we added the inverse relationship inside Post Model by adding belongsTo to it.

The time has come to find out how the data is saved in the database while we use this relationship.
What are the methods used in this?

These methods are divided into three basic methods:

Without using function post.
By using function post.
By using the inverse relationship function user.

1.Without using function post.

Here there are two scenarios:

First: Add only one post for the user.
Second: Add more than one post for the user.

First: Add only one post for the user.

We first go to the routes/web.php file and add a new route so that we can test these methods.

use App\Models\User;
use App\Models\Post;
---
Route::get('/one-to-many', function () {
    $user = User::find(1);
    Post::create([
        'user_id' => $user->id,
        'title' => 'Post title 1',
        'body' => 'Post body 1',
    ]);
    return response()->json([
        'username' => $user->username,
        'post' => $user->posts
    ]);
});

We open the browser and go to this link http://127.0.0.1:8000/one-to-many to find that one post has been successfully added to user NoisyId No. 1.

{
  "username": "John Doe",
  "post": [
    {
      "id": 1,
      "title": "Post title 1",
      "body": "Post body 1",
      "user_id": 1,
      "created_at": "2023-08-05T03:18:22.000000Z",
      "updated_at": "2023-08-05T03:18:22.000000Z"
    }
  ]
}

Second: Add more than one post for the user.

We first go to the routes/web.php file and edit this route.

use App\Models\User;
use App\Models\Post;
---
Route::get('/one-to-many', function () {
   $user = User::find(2);
    Post::insert(
        [
            [
                'user_id' => $user->id,
                'title' => 'Post title 2',
                'body' => 'Post body 2',
            ],
            [
                'user_id' => $user->id,
                'title' => 'Post title 3',
                'body' => 'Post body 3',
            ],
        ]
    );
    return response()->json([
        'username' => $user->username,
        'post' => $user->posts
    ]);
});

We open the browser and go to this link http://127.0.0.1:8000/one-to-many to find that 2 posts have been successfully added to the user with ID No. 2.

{
  "username": "Tom Cruz",
  "post": [
    {
      "id": 2,
      "title": "Post title 2",
      "body": "Post body 2",
      "user_id": 2,
      "created_at": null,
      "updated_at": null
    },
    {
      "id": 3,
      "title": "Post title 3",
      "body": "Post body 3",
      "user_id": 2,
      "created_at": null,
      "updated_at": null
    }
  ]
}

2. By using function post.

Here also there are two scenarios:
First: Add only one post for the user
Second: Add more than one post for the user

First: Add only one post for the user

We first go to the routes/web.php file and edit this route.

use App\Models\User;
---
Route::get('/one-to-many', function () {
    $user = User::find(3);
    $user->posts()->create([
      'title' => 'Post title 4',
      'body' => 'Post body 4',
    ]);
    return response()->json([
        'username' => $user->username,
        'post' => $user->posts,
    ]);
});

We open the browser and go to this link http://127.0.0.1:8000/one-to-many to find that one post has been successfully added to the user with ID No. 3.

{
  "username": "Adam Smith",
  "post": [
    {
      "id": 4,
      "title": "Post title 4",
      "body": "Post body 4",
      "user_id": 3,
      "created_at": "2023-08-05T03:37:55.000000Z",
      "updated_at": "2023-08-05T03:37:55.000000Z"
    }
  ]
}

Second: Add more than one post for the user

We first go to the routes/web.php file and edit this route.

use App\Models\User;
---
Route::get('/one-to-many', function () {
   $user = User::find(1);
    $user->posts()->createMany([
        [
            'title' => 'Post title 5',
            'body' => 'Post body 5',
        ],
        [
            'title' => 'Post title 6',
            'body' => 'Post body 6',
        ]
    ]);
    return response()->json([
        'username' => $user->username,
        'post' => $user->posts,
    ]);
});

We open the browser and go to this link http://127.0.0.1:8000/one-to-many to find that 2 posts have been successfully added to the user with ID No. 1.

In addition to these posts, there is another post that was added in a previous step, and therefore there should be 3 posts for this user. This is actually the data obtained from the database in the following response.

{
  "username": "John Doe",
  "post": [
    {
      "id": 1,
      "title": "Post title 1",
      "body": "Post body 1",
      "user_id": 1,
      "created_at": "2023-08-05T03:18:22.000000Z",
      "updated_at": "2023-08-05T03:18:22.000000Z"
    },
    {
      "id": 5,
      "title": "Post title 5",
      "body": "Post body 5",
      "user_id": 3,
      "created_at": "2023-08-05T03:42:27.000000Z",
      "updated_at": "2023-08-05T03:42:27.000000Z"
    },
    {
      "id": 6,
      "title": "Post title 6",
      "body": "Post body 6",
      "user_id": 3,
      "created_at": "2023-08-05T03:42:27.000000Z",
      "updated_at": "2023-08-05T03:42:27.000000Z"
    }
  ]
}

3. By using the inverse relationship function user.

We first go to the routes/web.php file and edit this route.

use App\Models\User;
use App\Models\Post;
---
Route::get('/one-to-many', function () {
    $user = User::find(2);
    $post = new Post([
        'title' => 'Post title 7',
        'body' => 'Post body 7',
    ]);

    $post->user()->associate($user)->save();
    return response()->json([
        'username' => $post->user->username,
        'title' => $post->title,
        'body' => $post->body,
    ]);
});

We open the browser and go to this link http://127.0.0.1:8000/one-to-many to find that a post has been successfully added to the user with ID No. 2.

{
  "username": "Tom Cruz",
  "title": "Post title 7",
  "body": "Post body 7"
}

You can find the repo of this series on github here

How to create a One-To-Many relationship in Laravel?

Mahmoud Adel — Wed, 16 Aug 2023 00:00:00 +0000

After we learned about the types of relationships within Laravel in the previous part.
We discussed the first type of these relationships, which is the One-To-One relationship.

Today we continue the series we started learning about Laravel Eloquent Relationships.

We are talking about the second type, which is called One-To-Many or hasMany.

How to create a One-To-Many relationship in Laravel?

The One-To-Many relationship is one of the most important types of relationships inside Laravel Eloquent.
We also learned in the previous lesson that it is the connection of a row from the first table to more than one row from the second table.

And as a continuation of the practical application (content management system), which we started in the previous lesson.
We create a One-To-One relationship between the user and the personal profile.

Today we are going to create One-To-Many relationship between user and post.
Each user can own one or more publications.

We create Post Model with its own table.

php artisan make:model Post -m

We go to this path database/migrations and modify the publications table by adding some columns as follows:

Schema::create('posts', function (Blueprint $table) {
  $table->id();
  $table->string('title');
  $table->text('body');
  $table->foreignId('user_id')->constrained();
  $table->timestamps();
});

We modify the Post.php file.

protected $fillable = [
  'user_id',
  'title',
  'body',
];

We execute this command to update the database and add the Posts table.

php artisan migrate

We go to the User.php file and set the hasMany relationship.

public function posts() {
    return $this->hasMany(Post::class);
}

Let's learn how hasMany works

$this->hasMany(Post::class,
  'user_id' // foreignKey By Default Parent Model + Promary Key
  'id' // localKey => Primary Key In Parent Table By Default is Id
);

We go to the file Post.php and set the inverse relationship belongsTo.

public function user() {
    return $this->belongsTo(User::class);
}

We have explained belongsTo in this part of the previous article and we are explaining the One-To-One relationship.

You can find the repo of this series on github here

How to delete data from one to one relationship in Laravel?

Mahmoud Adel — Tue, 15 Aug 2023 00:00:00 +0000

Delete data using User Model.

We first go to the routes/web.php file and add this route:

Route::get('/users/profile/delete', method () {
    $user = User::with('profile')->find(1);
    $user->profile()->delete();
    return response()->json($user);
});

We open the browser and navigate to the new URL http://127.0.0.1:8000/users/profile/delete to find that the profile have been deleted successfully.

{
  "id": 1,
  "username": "Joun Doe",
  "created_at": "2023-08-07T06:23:03.000000Z",
  "updated_at": "2023-08-10T05:07:38.000000Z",
  "profile": null
}

Refresh the page twice to show that this user's profile has been deleted.

Delete data Using Profile Model.

We first go to the routes/web.php file and add this route:

Route::get('/profiles/user/delete', method () {
    $profile = Profile::with('user')->findOrFail(2);
    $profile->delete();
    $profile->user()->delete();
});

We open the browser and navigate to the new URL http://127.0.0.1:8000/profiles/user/delete. We see that both the user and the profile have been deleted successfully.

Conclusion

This article is the start of a whole series on Laravel Eloquent Relationships - Relationships within Laravel. We have covered the One TO One relationship in a complete way. We did not spare you any information, and God willing, in the following explanation, we will learn about the One To Many relationship.

You can find the repo of this series on github here

How to update a one-to-one relationship in Laravel?

Mahmoud Adel — Mon, 14 Aug 2023 00:00:00 +0000

Update data using the user form.

1- Using push method.

First go to routes/web.php file and modify this route:

Route::get('/users/update', method () {
    $user = User::with('posts')->find(1);
    $post = $user->posts()->whereId(1)->first();
    $post->title = 'Post title 1 updated';
    $post->push();
    return response()->json($user);
});

We open the browser and go to the new URL http://127.0.0.1:8000/users/update to find that the post has been updated successfully.

{
  "id": 1,
  "username": "John Doe",
  "created_at": "2023-09-06T17:24:02.000000Z",
  "updated_at": "2023-09-06T17:25:58.000000Z",
  "posts": [
    {
      "id": 1,
      "title": "Post title 1 updated",
      "body": "Post body 1",
      "user_id": 1,
      "created_at": "2023-09-06T17:28:58.000000Z",
      "updated_at": "2023-09-06T18:37:30.000000Z"
    },
    {
      "id": 5,
      "title": "Post title 5",
      "body": "Post body 5",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    },
    {
      "id": 6,
      "title": "Post title 6",
      "body": "Post body 6",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    }
  ]
}

2- Using update method.

First go to the file routes/web.php and modify this route.

Route::get('/users/update', method () {
    $user = User::with('posts')->find(1);
    $post = $user->posts()->whereId(1)->first();
    $post->title = 'Post title 1';
    $post->update();
    return response()->json($user);
]);

We open the browser and go to the new URL http://127.0.0.1:8000/users/update to find that the post has been updated successfully.

{
  "id": 1,
  "username": "John Doe",
  "created_at": "2023-09-06T17:24:02.000000Z",
  "updated_at": "2023-09-06T17:25:58.000000Z",
  "posts": [
    {
      "id": 1,
      "title": "Post title 1",
      "body": "Post body 1",
      "user_id": 1,
      "created_at": "2023-09-06T17:28:58.000000Z",
      "updated_at": "2023-09-06T18:41:35.000000Z"
    },
    {
      "id": 5,
      "title": "Post title 5",
      "body": "Post body 5",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    },
    {
      "id": 6,
      "title": "Post title 6",
      "body": "Post body 6",
      "user_id": 1,
      "created_at": "2023-09-06T17:29:49.000000Z",
      "updated_at": "2023-09-06T17:29:49.000000Z"
    }
  ]
}

Update data using the post form.

1- Using push method.\

First go to routes/web.php file and add this route:

Route::get('/posts/update', method () {
    $post = Post::with('user')->find(1);
    $post->title = 'Post title 1 updated';
    $post->user->username = 'John Doe Updated';
    $post->push();
    return response()->json($post);
});

We open the browser and go to the new URL http://127.0.0.1:8000/posts/update to find that the post has been updated successfully.

{
  "id": 1,
  "title": "Post title 1 updated",
  "body": "Post body 1",
  "user_id": 1,
  "created_at": "2023-09-06T17:28:58.000000Z",
  "updated_at": "2023-09-06T18:50:30.000000Z",
  "user": {
    "id": 1,
    "username": "John Doe Updated",
    "created_at": "2023-09-06T17:24:02.000000Z",
    "updated_at": "2023-09-06T18:49:54.000000Z"
  }
}

2- Using update method.

First go to the file routes/web.php and modify this route.

Route::get('/posts/update', method () {
    $post = Post::with('user')->find(1);
    $post->user->username = 'John Doe';
    $post->update([
        'title' => 'Post title 1'
    ]);
    return response()->json($post);
]);

We open the browser and go to the new URL http://127.0.0.1:8000/posts/update to find that the post has been updated successfully.

{
  "id": 1,
  "title": "Post title 1",
  "body": "Post body 1",
  "user_id": 1,
  "created_at": "2023-09-06T17:28:58.000000Z",
  "updated_at": "2023-09-06T18:55:45.000000Z",
  "user": {
    "id": 1,
    "username": "John Doe",
    "created_at": "2023-09-06T17:24:02.000000Z",
    "updated_at": "2023-09-06T18:49:54.000000Z"
  }
}

You can find the repo of this series on github here

How can you retrieve data from a one-to-one relationship in Laravel?

Mahmoud Adel — Sun, 13 Aug 2023 00:00:00 +0000

We have seen how data is saved in several different ways in the database using the one-to-one relationship in Laravel. But how do we retrieve the data from the database? There are several ways to retrieve data from the database.

These methods can be divided into two main categories:

Direct retrieval: This method involves directly querying the database for the data that you need. This is the most efficient way to retrieve data, but it can be difficult to use if you are not familiar with SQL.
Eloquent ORM: Laravel's Eloquent ORM provides a more user-friendly way to retrieve data from the database. Eloquent ORM uses a set of methods to map database tables to objects in PHP. This makes it easy to retrieve data from the database without having to know SQL.
In this tutorial, we will focus on using Eloquent ORM to retrieve data from the database.

While retrieving users data:

While collecting user data, we will obtain their personal profiles. After that, the matter of displaying that data is divided into two forms, not a third. The type of application you are working on and the theme used will determine which form to use.

First: an application that uses web routes.
Second: an application that depends on API routes.

First: Depends on `Web Routes`.

1- We first go to the routes/web.php file and make the following changes:

Route::get('/users', method () {
    $users = User::with(['profile'])->get();
    return view('users.list', compact('users'));
});

If we check the response for this command, we will find that all data has been obtained from the database.

[
  {
    "id": 1,
    "username": "John Doe",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "id": 1,
      "firstname": "John",
      "lastname": "Doe",
      "birthday": "08-11-1991",
      "user_id": 1,
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 2,
    "username": "Tom Cruz",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "id": 2,
      "firstname": "Tom",
      "lastname": "Cruz",
      "birthday": "01-02-2000",
      "user_id": 2,
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 3,
    "username": "Adam Smith",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "id": 3,
      "firstname": "Adam",
      "lastname": "Smith",
      "birthday": "01-01-1999",
      "user_id": 3,
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  }
]

Here, you can choose only the columns that you need in the following form:

Route::get('/users', method () {
    $users = User::with(['profile:firstname,lastname,user_id'])->get();
    return view('users.list', compact('users'));
});

If we now check again, you will find that the data size has been reduced.

[
  {
    "id": 1,
    "username": "John Doe",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "firstname": "John",
      "lastname": "Doe",
      "user_id": 1
    }
  },
  {
    "id": 2,
    "username": "Tom Cruz",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "firstname": "Tom",
      "lastname": "Cruz",
      "user_id": 2
    }
  },
  {
    "id": 3,
    "username": "Adam Smith",
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "profile": {
      "firstname": "Adam",
      "lastname": "Smith",
      "user_id": 3
    }
  }
]

Here, we see the difference between the two cases in the size of the processed data. The matter increases significantly if the data is much larger than that.

When choosing specific columns from relationships, you must always choose the foreign key column. Without choosing it, the data will not be returned correctly from the database.

2- Inside the views folder, we add another folder named users. Inside the users folder, we add the file list.blade.php. In list.blade.php, we add this simple table to display the users:

<table>
    <thead>
        <tr>
            <th style="text-align: center">Username</th>
            <th style="text-align: center">Firstname</th>
            <th style="text-align: center">Lastname</th>
        </tr>
    </thead>
    <tbody>
        @foreach ($users as $user)
            <tr>
                <td>{{ $user->username }}</td>
                <td>{{ $user->profile->firstname }}</td>
                <td>{{ $user->profile->lastname }}</td>
            </tr>
        @endforeach
    </tbody>
</table>

3- Open your browser and go to the following URL http://127.0.0.1:8000/users to see what results will appear.

Second: Depends on `Api Routes`.

What are API Resources?

Simply, it is an intermediate layer between Eloquent and the API response, converting data obtained from the database into JSON with the ability to specify specific data without others or manipulate that data.

1- We will create an API Resource for users and profiles. Execute this command at the command prompt.

php artisan make:resource UserResource
php artisan make:resource ProfileResource

2- Go to the following path: App\Http\Resources and edit both:

The file ProfileResource.php.

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class ProfileResource extends JsonResource
{
    public method toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'firstname' => $this->firstname,
            'lastname' => $this->lastname,
        ];
    }
}

The file UserResource.php.

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class UserResource extends JsonResource
{
    public method toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'username' => $this->username,
            'profile' => ProfileResource::make($this->whenLoaded('profile')),
        ];
    }
}

3- Go to your routes/api.php file and add a new route.

use App\Models\User;
use App\Http\Resources\UserResource;
---
Route::get('/users', method () {
    $users = User::with(['profile'])->get();
    $usersResource = UserResource::collection($users);
    return response()->json($usersResource);
});

4- Open your browser and go to the following URL http://127.0.0.1:8000/api/users to see what results will appear.

[
  {
    "id": 1,
    "username": "John Doe",
    "profile": {
      "id": 1,
      "firstname": "John",
      "lastname": "Doe"
    }
  },
  {
    "id": 2,
    "username": "Tom Cruz",
    "profile": {
      "id": 2,
      "firstname": "Tom",
      "lastname": "Cruz"
    }
  },
  {
    "id": 3,
    "username": "Adam Smith",
    "profile": {
      "id": 3,
      "firstname": "Adam",
      "lastname": "Smith"
    }
  }
]

We also see here that we have obtained the required data specified within the API Resources files only.

While retrieving profiles data:

While obtaining profile data, we will obtain each user associated with those profiles.
After that, the data can be displayed in two forms, not three.
The type of application you are working on and the theme used will determine which form of data display is most appropriate.

First: an application that uses web routes.
Second: an application that depends on API routes. #### First: Depends on Web Routes. 1- We first go to the routes/web.php file and make the following changes:

Route::get('/profiles', method () {
    $profiles = Profile::with('user')->get();
    return view('profiles.list', compact('profiles'));
});

If we check the response for this command, we will find that all data has been obtained from the database.

[
  {
    "id": 1,
    "firstname": "John",
    "lastname": "Doe",
    "birthday": "08-11-1991",
    "user_id": 1,
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "user": {
      "id": 1,
      "username": "John Doe",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 2,
    "firstname": "Tom",
    "lastname": "Cruz",
    "birthday": "01-02-2000",
    "user_id": 2,
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "user": {
      "id": 2,
      "username": "Tom Cruz",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  },
  {
    "id": 3,
    "firstname": "Adam",
    "lastname": "Smith",
    "birthday": "01-01-1999",
    "user_id": 3,
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "user": {
      "id": 3,
      "username": "Adam Smith",
      "created_at": "2023-08-07T06:23:03.000000Z",
      "updated_at": "2023-08-07T06:23:03.000000Z"
    }
  }
]

Here, you can choose only the columns that you need in the following form:

Route::get('/profiles', method () {
    $profiles = Profile::with('user:username,id')->get();
    return view('profiles.list', compact('profiles'));
});

If we now check again, you will find that the data size has been reduced.

[
  {
    "id": 1,
    "firstname": "John",
    "lastname": "Doe",
    "birthday": "08-11-1991",
    "user_id": 1,
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "user": {
      "username": "John Doe",
      "id": 1
    }
  },
  {
    "id": 2,
    "firstname": "Tom",
    "lastname": "Cruz",
    "birthday": "01-02-2000",
    "user_id": 2,
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "user": {
      "username": "Tom Cruz",
      "id": 2
    }
  },
  {
    "id": 3,
    "firstname": "Adam",
    "lastname": "Smith",
    "birthday": "01-01-1999",
    "user_id": 3,
    "created_at": "2023-08-07T06:23:03.000000Z",
    "updated_at": "2023-08-07T06:23:03.000000Z",
    "user": {
      "username": "Adam Smith",
      "id": 3
    }
  }
]

Here, we see the difference between the two cases in the size of the processed data. The matter increases significantly if the data is much larger than that.

When selecting specific columns in relationships, you must include the id field when choosing the user relationship. Otherwise, the user will not be returned with the profile.

2- Inside the views folder, we add another folder named profiles. Inside the profiles folder, we add the file list.blade.php. In list.blade.php, we add this simple table to display the profiles:

<table>
    <thead>
        <tr>
            <th style="text-align: center">Username</th>
            <th style="text-align: center">Firstname</th>
            <th style="text-align: center">Lastname</th>
        </tr>
    </thead>
    <tbody>
        @foreach ($profiles as $profile)
            <tr>
                <td>{{ $profile->user->username }}</td>
                <td>{{ $profile->firstname }}</td>
                <td>{{ $profile->lastname }}</td>
            </tr>
        @endforeach
    </tbody>
</table>

3- Open your browser and go to the following URL http://127.0.0.1:8000/profiles to see what results will appear.

Second: Depends on `Api Routes`.

1- Go to the following path: App\Http\Resources and edit the file ProfileResource.php:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class ProfileResource extends JsonResource
{
    public method toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'body' => $this->body,
            'user' => UserResource::make($this->whenLoaded('user')),
        ];
    }
}

2- Go to your routes/api.php file and add a new route.

use App\Models\Profile;
use App\Http\Resources\ProfileResource;
---
Route::get('/profiles', method () {
    $profiles = Profile::with(['user'])->get();
    $profilesResource = ProfileResource::collection($profiles);
    return response()->json($profilesResource);
});

3- Open your browser and go to the following URL http://127.0.0.1:8000/api/profiles to see what results will appear.

[
  {
    "id": 1,
    "firstname": "John",
    "lastname": "Doe",
    "user": {
      "id": 1,
      "username": "John Doe"
    }
  },
  {
    "id": 2,
    "firstname": "Tom",
    "lastname": "Cruz",
    "user": {
      "id": 2,
      "username": "Tom Cruz"
    }
  },
  {
    "id": 3,
    "firstname": "Adam",
    "lastname": "Smith",
    "user": {
      "id": 3,
      "username": "Adam Smith"
    }
  }
]

How to improve Eloquent queries in Laravel?

When dealing with a large database with a lot of data, it is important to consider performance. This means not only how long it takes to get the data, but also how many queries are executed per page.

To test the performance of your application, you can use a library called Laravel Debugbar. Debugbar will show you all the queries that are executed on each page, as well as how long each query takes to execute. This information can help you to identify performance bottlenecks and optimize your application.

Let's run this command.

composer require barryvdh/laravel-debugbar --dev

Make sure that APP_DEBUG=true is inside the .env file.

The difference between the two cases is as follows:

$users = User::all();
$users = User::with('profile')->get();

We open the browser and go to the following URL: http://127.0.0.1:8000/users to see what results will appear in the library bar.

1- (Lazy Loading) - Retrieve data without using with.

At the bottom of the page, we will now find a bar for the Laravel Debugbar library. When you click on it, we will find that it works with a lot of data. The thing that interests us here is the number of SQL queries on this page, and as shown, they are 4 queries.

And we only retrieved 3 users, imagine with me if there are tens of thousands or millions of users inside this database, the time to load this page will be very slow because of the huge number of queries.

This is called the N+1 problem in Laravel. It is caused by lazy loading relationships, which means that the associated data is not loaded until it is actually needed. In this case, we are lazy loading the posts relationship for each user. This means that we are making a separate query for each user to get their profiles.

If there are 1000 users, we will make 1001 queries: 1 query to get the users, and 1000 queries to get their profiles. This is a waste of server resources and can make your application slow.

To solve the N+1 problem, you can eager load the relationships. This means that you will load the associated data when you first retrieve the data. In this case, you would use the with() method to eager load the profiles relationship. This would only make one query to get the users and their profiles.

Eager loading can improve the performance of your application by reducing the number of queries. It is a good practice to eager load relationships whenever possible.

2- (Eager Loading) - Retrieve data using with.

As you can see, by adding the with() method with the name of the relationship, each user's data will be fetched with their own profile without the N+1 problem.

So the number of queries was reduced from 4 to 2 only. This will clearly have an effect if this database is of medium size or large. This is what is called eager loading.

You can find the repo of this series on github here

DEV Community: Mahmoud Adel

Discover 7 Professional CSS Tools to Boost Your Design & Development Workflow — From Codezelo

1. Border Radius Playground

2. Box Shadow Playground

3. CSS Gradient Playground

4. CSS Animation Playground

5. CSS Flexbox Playground

6. CSS Grid Playground

7. CSS Transform Playground

Why Codezelo?

Try the tools now on Codezelo

Final Thoughts

Building an Online Store Using Only HTML, CSS, and JavaScript — My First Practical Coding Project

🧠 Why I Did It

🛠️ What I Learned

🧩 See the Full Tutorial

Beginner's Guide to Learn HTML: Your First Step in Web Development

What is HTML? Understanding the basics of coding and tags for beginners

HTML Tag Structure Explained

Element vs. Tag: Understanding the Difference

Web Development Basics: Are You Ready to Start Your Journey?

What is Web Development?

What are the fields of web development?

What is the web: How does it work and how is it built?

HTML: The basic language for building web pages and why it matters.

HTML Evolution: How did it shape the future of web development?

How the Internet Communicates: Understanding the Relationship Between Browsers and Servers

What does a web server consist of?

What does a server do?

How to delete data from one to many relationship in Laravel?

Delete data using the user form.

Delete data using the publication form.

Conclusion

How to update a one-to-many relationship in Laravel?

Update data using the user form.

Update data using the post form.

How can you retrieve data from a one-to-many relationship in Laravel?

Through the user User Model

Without using API Resources.

By using API Resources.

Through the post Post Model

Without using API Resources.

By using API Resources.

How to insert data in one to many relationship in database?

1.Without using function post.

First: Add only one post for the user.

Second: Add more than one post for the user.

2. By using function post.

First: Add only one post for the user

Second: Add more than one post for the user

3. By using the inverse relationship function user.

How to create a One-To-Many relationship in Laravel?

How to create a One-To-Many relationship in Laravel?

How to delete data from one to one relationship in Laravel?

Delete data using User Model.

Delete data Using Profile Model.

Conclusion

How to update a one-to-one relationship in Laravel?

Update data using the user form.

Update data using the post form.

How can you retrieve data from a one-to-one relationship in Laravel?

While retrieving users data:

First: Depends on Web Routes.

Second: Depends on Api Routes.

While retrieving profiles data:

Second: Depends on Api Routes.

How to improve Eloquent queries in Laravel?

Through the user `User Model`

Without using `API Resources`.

By using `API Resources`.

Through the post `Post Model`

Without using `API Resources`.

By using `API Resources`.

First: Depends on `Web Routes`.

Second: Depends on `Api Routes`.

Second: Depends on `Api Routes`.