From collect() to Comprehension

In Laravel, when you want clean data transformation, you don’t write messy loops.

You write:

collect($users)
    ->filter(...)
    ->map(...)
    ->pluck(...);

In Python, instead of chaining methods, you compress that thinking into a readable one-liner.

Let’s see how that translates.

Transforming Data — Like ->map()

$doubled = collect($numbers)
    ->map(fn($n) => $n * 2)
    ->all();

numbers = [1, 2, 3, 4, 5]

doubled = [n * 2 for n in numbers]

How to read it

“Give me n * 2 for each n in numbers.”

Pattern:

[expression for variable in iterable]

This is the most common pattern in Python.

And once you understand this structure, everything else builds on it.

Filtering — Like ->filter()

collect($numbers)
    ->filter(fn($n) => $n % 2 == 0)
    ->values()
    ->all();

evens = [n for n in numbers if n % 2 == 0]

Pattern:

[expression for variable in iterable if condition]

This is basically filter() + map() combined.

Python doesn't chain methods — it nests logic inside the comprehension.

Map + Filter in One Line

collect($names)
    ->filter(fn($n) => strlen($n) > 3)
    ->map(fn($n) => strtoupper($n));

names = ['Alice', 'Bob', 'Charlie', 'David', 'Eve']

long_upper = [name.upper() for name in names if len(name) > 3]

Same logic with less code, or you can say a one-liner.

Working With Dicts — Like ->pluck()

collect($users)->pluck('name')->all();

users = [
    {'name': 'Alice', 'age': 30, 'active': True},
    {'name': 'Bob', 'age': 25, 'active': False},
    {'name': 'Charlie', 'age': 35, 'active': True},
]

names_list = [user['name'] for user in users]

Filter + pluck:

active_names = [
    user['name'] 
    for user in users 
    if user['active']
]

Once you see it, you can’t unsee it.

Building Dictionaries — Like ->keyBy()

Laravel:

collect($users)->keyBy('name');

users_by_name = {
    user['name']: user 
    for user in users
}

Pattern:

{key: value for item in iterable}

This is called a dict comprehension.

You’re building lookup structures instantly.

Unique Values — Like ->unique()

collect($ages)->unique();

ages = [25, 30, 25, 35, 30, 40]
unique_ages = {age for age in ages}

Curly braces without : mean set comprehension.

Sets automatically remove duplicates.

Flattening — Like ->flatten()

collect($matrix)->flatten();

matrix = [[1,2,3],[4,5,6],[7,8,9]]

flat = [num for row in matrix for num in row]

#Detailed example of shorthand
flat = []

for row in matrix:
    for num in row:
        flat.append(num)

Read it carefully:

“For each row in matrix, for each num in row.”

Nested logic, single expression.

When NOT to Use Comprehensions

As a Laravel dev, you already value readability.

Don’t use comprehensions when:

• Logic becomes too complex

• You need side effects (saving, printing, logging)

• The expression becomes hard to read

Clean code > clever code.

Why This Matters for ML

This isn’t just syntax sugar.

In Machine Learning, you will:

• Clean datasets

• Transform features

• Filter records

• Build lookup maps

• Generate derived values

And you’ll do it constantly.

List comprehensions train your brain to:

• Think in transformations

• Write declarative logic

• Manipulate datasets efficiently

This is the bridge between a backend developer and an ML engineer.

Exercise (Think Like Laravel, Write Like Python)

products = [
    {'name': 'Laptop', 'price': 999, 'in_stock': True},
    {'name': 'Mouse', 'price': 29, 'in_stock': True},
    {'name': 'Keyboard', 'price': 79, 'in_stock': False},
    {'name': 'Monitor', 'price': 449, 'in_stock': True},
    {'name': 'Webcam', 'price': 69, 'in_stock': False},
]

Try writing:

1. All product names

2. Names of products in stock

3. Products over $50 and in stock

4. {name: price} lookup

5. 10% discounted prices

If you can solve these comfortably, you're officially thinking in Python.

Closing Thought

Laravel trains you to think in collections, while Python trains you to think in comprehensions. The syntax may look different at first, but the mindset is surprisingly aligned, with clean transformations, readable logic, and expressive code. In the next lesson, we’ll move into Python functions, where things become even more powerful and flexible, and we’ll learn them the Laravel-to-ML way, simple, practical, and developer-focused.

As Laravel developers, we are spoiled by the PHP array. It’s our everything tool.

Need a list? Array. Need a map? Array. Need a stack? Array.

Python, however, prefers specialized tools for specialized tasks. This is the secret to why it handles massive ML datasets so efficiently.

Here is your guide to mastering Python data structures without losing your Laravel mindset.

1. Lists: Your New Indexed Array

In Laravel, when you’re fetching a collection of names, you’re working with an indexed array. In Python, this is a List.

The PHP Way

$frameworks = ['Laravel', 'Symfony', 'CodeIgniter'];
$frameworks[] = 'Lumen'; // Push to end
echo $frameworks[0];     // Laravel

The Python Way

frameworks = ['Laravel', 'Symfony', 'CodeIgniter']
frameworks.append('FastAPI') # Using a method instead of []
print(frameworks[0])         # Laravel

The ML Advantage: Slicing

In ML, you often need to "split" your data (e.g., take the first 80% for training). Python makes this incredibly easy compared to array_slice().

# Python "Slicing" syntax: [start:stop]
top_two = frameworks[:2]  # ['Laravel', 'Symfony']
last_one = frameworks[-1] # 'FastAPI' (Negative indexing is a lifesaver!)

2. Dicts: The Associative Array

When you’re defining an $user object in a controller, you use an associative array. In Python, we call this a Dictionary (or Dict).

The PHP Way

$config = [
    'driver' => 'mysql',
    'host' => '127.0.0.1'
];
$driver = $config['driver'];
$port = $config['port'] ?? 3306; // Null coalesce

The Python Way

config = {
    'driver': 'mysql',
    'host': '127.0.0.1'
}
driver = config['driver']
port = config.get('port', 3306) # The "get" method handles missing keys gracefully

The Human Touch: In Python, keys are typically strings or numbers. You’ll use these constantly in ML to hold Hyperparameters the settings for your models (like {'learning_rate': 0.01, 'epochs': 10}).

3. Tuples: The One You’re Missing

This is the one structure that doesn't have a twin in PHP. A Tuple is essentially an array that cannot be changed once it's born (it's "immutable").

Why would you want that?

Imagine you have an RGB color for a brand or geographic coordinates for a store. You don't want your code to accidentally change the Latitude halfway through a calculation.

# Defined with parentheses
coordinates = (34.0522, -118.2437)

# This will throw an error! 
# coordinates[0] = 35.0

Pythonic "Unpacking":

You know how we use list() or [] In PHP, to destructure? Python does this natively and beautifully.

// PHP Destructuring
[$lat, $long] = [34.0522, -118.2437];

# Python Unpacking
lat, long = coordinates
print(f"Lat: {lat}, Long: {long}")

The "Laravel to Python" Cheat Sheet

Exercise: The "Laravel Config" Challenge

To get these into your muscle memory, try this:

1. Create a Dict named app_settings containing a name, env, and a List of providers.

2. Add a new provider to the list.

3. Use .get() to try to print a version key that doesn't exist yet, providing 1.0 as a default.

4. Create a Tuple for your database credentials (host, port, user) and unpack them into three separate variables.

You start where you already are, building Laravel apps, handling requests, and working with data. The first few checkpoints are simple: Python basics and data handling. Nothing fancy. Lists feel like arrays, DataFrames feel like collections. You’re not learning ML, yet you’re just getting comfortable with the tools the ML world uses.

As you move forward on the path, you hit NumPy, Pandas, and visualization. This is the part where things start making sense. You stop seeing data as rows in a table and start seeing patterns. You clean messy data, join datasets, and draw charts to understand what’s really going on. Most of the time here feels like backend work, just with larger datasets and a bit more math.

Near the end of the road, you finally reach the ML part: algorithms, training, testing, and evaluation. By now, they don’t feel scary. They feel logical. You try them in one real project, end-to-end, and suddenly ML is no longer a buzzword; it’s just another system you understand. Past this point, the road opens up to deeper areas like NLP, deep learning, or MLOps.

That’s the idea behind the roadmap.
Not switching careers. Not chasing hype.
Just one developer adding a new skill, step by step.

Why stick to Laravel’s naming conventions?

1. Less hassle: Laravel figures out models, tables, and relationships for you.

2. Cleaner, friendlier code: Easy to read today and months later.

3. Fewer silly bugs: No more “Oops, I named it differently in the code and the database.”

4. Faster work: Skip the boring configuration steps and get straight to building features.

5. Team harmony: Everyone instantly understands the structure without a long onboarding session.

In this blog, we will explore naming conventions for:

1. Models

2. Controllers

3. Migrations

4. CSS files

5. JavaScript files

6. Blade templates

7. Models, Tables & Relationships

1. Models

Models in Laravel represent your database tables and are stored in app/Models.

Convention:

• Singular name

• PascalCase (StudlyCase)

• No underscores or hyphens

✅ Examples:

// Good
class User extends Model {}
class OrderDetail extends Model {}

// Bad
class Users extends Model {}
class order_detail extends Model {}

📌 Why singular?
Each model represents one record in the table (one User, one Order).

2. Controllers

Controllers handle your application logic and live in app/Http/Controllers.

Convention:

• PascalCase

• Always end with Controller

• Group logically based on purpose

✅ Examples:

class UserController extends Controller {}
class OrderDetailController extends Controller {}

🚫 Bad:

class usercontroller {}
class Order_Detail {}

📌 Tip: Use:

php artisan make:controller UserController

to auto-follow conventions.

3. Migrations

Migrations define your database structure and are stored in database/migrations.

Convention:

• snake_case

• Words separated by underscores

• Describe the action + table name

• Timestamp prefix auto-generated

✅ Examples:

2025_08_15_120000_create_users_table.php
2025_08_15_120100_add_status_to_orders_table.php

📌 Tip:

php artisan make:migration create_users_table
php artisan make:migration add_status_to_orders_table --table=orders

4. CSS Files

Usually stored in public/css or resources/css.

Convention:

• Lowercase

• Hyphen-separated

• Descriptive names

✅ Examples:

main.css
admin-dashboard.css
user-profile.css

5. JavaScript Files

Stored in resources/js (for build tools) or public/js.

Convention:

• Lowercase

• Hyphen-separated

• Use action-oriented names if script is specific

✅ Examples:

app.js
form-validation.js
user-profile.js

6. Blade Templates

Stored in resources/views.

Convention:

• Lowercase

• Hyphen-separated

• Use folders for grouping

• No underscores

✅ Examples:

resources/views/auth/login.blade.php
resources/views/admin/dashboard.blade.php
resources/views/user/profile.blade.php

📌 Tip: Use dots in view calls:

return view('admin.dashboard');

7. Models, Tables & Relationships

Laravel’s Eloquent ORM has default rules for naming tables and relationships.

Models & Tables

• Models: Singular, PascalCase

• Tables: Plural, snake_case

✅ Examples:

If your table doesn’t match the convention, define it:

class UserInfo extends Model {
    protected $table = 'user_information';
}

Relationships

Eloquent relationships also follow specific naming:

One-to-One / One-to-Many

• Method name: singular for one-to-one, plural for one-to-many

class User extends Model {
    public function profile() {  // one-to-one
        return $this->hasOne(Profile::class);
    }

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

Belongs To

• Method name: singular (refers to parent)

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

Many-to-Many

• Pivot table: alphabetical order, plural, snake_case

• Method name: plural

// Table: role_user (alphabetical: role before user)
class User extends Model {
    public function roles() {
        return $this->belongsToMany(Role::class);
    }
}

✅ Pivot Table Examples:

Primary and Foreign Key Naming Conventions in Relationships

In Laravel, following the right primary and foreign key naming patterns ensures that Eloquent relationships work without extra configuration.

• Primary Keys – Each table should have an id column as its primary key.

• One-to-Many (O2M) – The foreign key should be the singular form of the related model’s name followed by _id.

  • Example: If a Post belongs to a User, the posts table should have user_id.

• Many-to-Many (M2M) – Use a pivot table named with both related model names in singular, snake_case, arranged in alphabetical order, with each containing its foreign key in the same pattern.

  • Example: For User and Role models, pivot table → role_user

    • Columns: role_id, user_id

By sticking to these naming rules, you can define relationships without specifying custom keys, letting Laravel automatically link your models.

Final Thoughts

Following these conventions:

• Makes your Laravel codebase self-explanatory

• Allows Laravel’s “magic” features to work without extra configuration

• Keeps large projects clean and maintainable

Middleware

Defining middleware is very easy in Express JS it takes three parameters req, res and next and only in error handling middleware we have one extra parameter that is err .

/** req object represents the HTTP request made by the client to the server */
/** res object represents the HTTP response that the server will send back to the client */
/** next  function is used to pass control to the next middleware function in the stack */
app.use((req, res, next) => { });

Types of middlewares

As per the above example we can say middleware has many purposes to serve, we can categorize it into four types, Application level, Route level, Error handling, Built-in, and Third-party middleware

1. Application level
   As we have seen in the above example if you want to enter the college premises, you will need an ID card for authentication so we can use the application-level middleware to check for the authenticated requests.

    /**Importing the express Js */
   
    const express = require('express');
   
    /** Initializing the express application */
   
    const app = express();
   
    /**Applying application level middleware */
   
    app.use((req, res, next) => {
        /**Logic to check user is authenticated or not */
        next()
    });
   

2. Route level

   In the library, some sections are reserved for the college staff, so some areas are inaccessible even if you have an ID card(Authenticated user). To achieve this in express Js we need to secure those routes from other users to achieve this we will use Route level middleware.

    /** Importing the express Js */
    const express = require("express");
   
    /** Creating a new instance of router. */
    const router = express.Router();
   
    /**
    * Route level middleware are bound to an instance of express.Router().
    */
    router.use((req, res, next) => {
        /**Logic to validate whether a user is staff or not */
        next()
    });
   

   There are a few more examples of route-level middleware that will help us

   drill down to use middleware more effectively. We can say that we want to add a validation that a user can only issue a book of the course he/she has opted for to achieve this in express we will use the below code.

    /**
    * Middleware that will be applied on /books/stream/:streamName and /books/stream/:streamName/zyz
    */
    router.use('/books/stream/:streamName',(req, res, next) => {
        /**Logic to validate stream based on stream name and user */
        next();
    });
   

3. Error handling

   Error-logging middleware can be easily identified by an extra parameter in the middleware function, it is one of the default features provided by Express Js. We can use this feature whenever we have to throw an error.

    /**Registering a middleware to catch and log error and return 500 to users*/
    app.use((err, req, res, next) => {
      console.error(err.stack);
      res.status(500).send('Something went wron');
    })
   

4. Built-in

   Express provides several built-in middleware functions that help handle common tasks in web development, we will see a few examples of built-in middleware.

    /*
    * Used to convert JSON data in request to Javascript object and can be accesed by req.body
    * Used when Content-Type is application/json mainly in REST API's
    */
    app.use(express.json());
   

    /**
    * Used when user submit a web form with Content type application/x-www-form-urlencoded
    * To convert the urlencoded data into Javascript object.
    */
    app.use(express.urlencoded({ extended: true }));
   

    /**
    * Used to serve static files (HTML, CSS, JS, Images)from the public folder.
    * You can sepecify any other folder of you choice also.
    */
    app.use(express.static('public'));
   

5. Third-party

   There are many library available to simplify web development, so we don’t have to write everything from scratch. Instead, we can use these features by simply installing them with npm. We will see to most common example of third-party middleware.

    /** CORS Middleware */
    /** Allows your server to handle requests from different origins, which is essential for enabling Cross-Origin Resource Sharing (CORS). */ 
    /** npm install cors */
    const express = require('express');
    const cors = require('cors');
    const app = express();
   
    /** Use CORS middleware to allow requests from any origin */
    app.use(cors());
   
    app.get('/', (req, res) => {
      res.send('CORS is enabled for all origins!');
    });
   

    /** Parses cookies attached to the client request object and makes them available via req.cookies.*/
    /** Cookie parser middleware */
    /** npm install cookie-parser */
    const express = require('express');
    const app = express();
    const cookieParser = require('cookie-parser');
    /** Adding cookieParser middleware */
    app.use(cookieParser());
   

Conclusion

In summary, middleware in Express.js acts like checkpoints in a library, performing various tasks to ensure smooth operations. From application-level checks like authentication to route-level validation and error handling, middleware helps manage requests and responses efficiently. Built-in middleware such as express.json() and express.static() streamline common tasks, while third-party middleware like cors and cookie-parser enhance functionality with minimal setup. By understanding and utilizing these middleware types, you can build robust, well-organized web applications that handle various scenarios seamlessly.

What is Routing?

We access anything in any application using some endpoints(URL) and whenever we make any request some code on the server executes to complete our request and give us the response. If we divide it into parts we have two things one is the endpoint and the second is the code that executes on the server, this is where routing helps us to map our endpoints with the specific piece of functionality from our application.

Why do we need Routing?

Here's why routing is necessary.

1. URL Mapping

   Routing allows you to map URLs to specific functions or handlers within your application.

2. Separation of Concerns

   It helps to separate different parts of the application from one another like authentication, authorization, admin, and users.

3. Dynamic URL Handling

   A route /users/:id can dynamically match any user ID and allow your application to fetch or process data for that specific user.

4. Implementing RESTful APIs

In RESTful API design, routing is responsible for mapping HTTP methods (GET, POST, PUT, PATCH, DELETE) to actions on resources.

5. Middleware Integration

   It is a function that runs before the final request handler to process or modify the request or response in an application.

6. Error Handling

   With routing, you can define specific routes to handle errors or exceptions. For instance, you can create a catch-all route for 404 errors to handle cases where users navigate to a non-existent page.

7. Modular Code Structure

   Routing allows you to break your application into smaller, more manageable modules or files.

HTTP Methods

There are several HTTP methods, but the most commonly used ones are:

1. GET To retrieve resources from the server

2. POST Submit to create new resources on the server like registering a new user.

3. PUT To replace any resource from the server like replacing any image with a new

4. PATCH: To update resources on the server like updating a user's email address.

5. DELETE To delete resources from the server.

How to declare routes

/** Importing the express Js */
const express = require("express");

/** Creating a new instance of router. */
const router = express.Router();
/**
 * The first is method which we will choose according to our need.
 * The first parameter is the url we want to assign that functionality.
 * Second parameter is a callback function that will be executed when user hit that URL
 * Callback function will have two parameter that is request,response.
 */

router.get("/url", (req, res) => {});

As of now, we have gained a rough idea of routing and the purpose with methods, now we will see how Express Js helps with Routing. Express Js has a built-in routing mechanism we can access using the code below.

/** Importing the express Js */
const express = require("express");

/** Creating a new instance of router. */
const router = express.Router();

/**
 * GET
 * URI /list-of-tasks
 * To get the list of tasks to do
 */
router.get("/list-of-tasks", (req, res) => {
  const tasks = [
    { id: 1, name: "Task 1", description: "This is the first task" },
    { id: 2, name: "Task 2", description: "This is the second task" },
    { id: 3, name: "Task 3", description: "This is the third task" },
  ];
  res.json(tasks);
});
/** Exporting routes to register in the app to make it available to accept request and return response */
module.exports = router;

We will see how and when to use different HTTP methods for that we will do a basic CRUD and to get the request we will install a new package to parse the request body. Please run the command to install the package npm install body-parser after that create a file routes.js in the project folder(express-01) and paste the below code in main.js file that we have created in the last article.

NOTE: Don't worry about the HTML we will see in the upcoming article for handling views.

/**Importing the express Js */
const express = require('express');

/** Initializing the express application */
const app = express();
const bodyParser = require('body-parser');

app.use(bodyParser.urlencoded({ extended: true }));

/** Register the route to accept the get request */
app.get('/',(req,res,next) => {
    res.send('Hello World');
});

const customRoutes = require('./routes');

app.use(customRoutes);

/** Create server and start listing on the port of your choice */
app.listen(3000);

Paste the below code into the routes.js file

/** Importing the express Js */
const express = require("express");

/** Creating a new instance of router. */
const router = express.Router();

const tasks = [
    { id: 1, name: "Task 1", description: "This is the first task" },
    { id: 2, name: "Task 2", description: "This is the second task" },
    { id: 3, name: "Task 3", description: "This is the third task" },
];

/**
 * GET
 * URI /list-of-tasks
 * To get the list of tasks to do
 */
router.get("/list-of-tasks", (req, res) => {
    res.send(
        `<body style="font-family: Arial, sans-serif; margin: 20px;">

            <h1 style="text-align: center;">Task List</h1>
            <div style="text-align: center; margin-bottom: 20px;">
                <a href="/add-task" style="display: inline-block; background-color: #007BFF; color: white; text-align: center; border: none; border-radius: 5px; padding: 10px 20px; cursor: pointer; text-decoration: none; font-size: 16px; margin-bottom: 20px;">
                    Add New Task
                </a>
            </div>

            <ul style="list-style-type: none; padding: 0; max-width: 600px; margin: 0 auto;">`
                + tasks.map((task) => {
                    return  `<li style="border: 1px solid #ddd; border-radius: 5px; padding: 10px; margin-bottom: 10px; display: flex; justify-content: space-between; align-items: center;">
                    <div style="flex: 1;">
                        <h2 style="margin: 0; font-size: 18px; color: #333;">${task.name}</h2>
                        <p style="margin: 5px 0 0; color: #666;">${task.description}</p>
                    </div>
                    <a href="/edit-task/${task.id}" style="display: inline-block; background-color: #4CAF50; color: white; text-align: center; border: none; border-radius: 5px; padding: 8px 16px; cursor: pointer; text-decoration: none;">
                        Edit
                    </a>
                    <form action="/delete-task/${task.id}" method="POST" style="margin-bottom:0;">
                        <button type="submit" style="display: inline-block; background-color: #9e0132; color: white; text-align: center; border: none; border-radius: 5px; padding: 8px 16px; cursor: pointer;  margin-left:10px;">Delete</button>
                    </form>

                </li>`;
                }).join("")+`
            </ul>

        </body>`
    );  
});

/**
 * GET
 * URI /add-task
 * To get the list of tasks to do
 */
router.get("/add-task", (req, res) => {
    res.send(` <body style="display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
    <div style="text-align: center;">
        <h1>Add New Task</h1>

        <form action="/submit-task" method="post" style="display: inline-block; text-align: left;">
            <div style="margin-bottom: 15px;">
                <label for="name" style="display: block; margin-bottom: 5px;">Name:</label>
                <input type="text" id="name" name="name" required style="width: 100%; padding: 8px; box-sizing: border-box;">
            </div>
            <div style="margin-bottom: 15px;">
                <label for="description" style="display: block; margin-bottom: 5px;">Description:</label>
                <textarea id="description" name="description" rows="4" cols="50" required style="width: 100%; padding: 8px; box-sizing: border-box;"></textarea>
            </div>
            <button type="submit" style="padding: 10px 20px; font-size: 16px;">Submit</button>
        </form>
    </div>
</body>`);
res.end();
});

/**
 * POST
 * URI /add-tasks
 * To add new task.
 */
router.post('/submit-task',(req,res) => {
    const newTask = {
        id: tasks.length + 1,
        name: req.body.name,
        description: req.body.description,
    }
    tasks.push(newTask);
    res.redirect('/list-of-tasks');

});

/**
 * GET 
 * URI /edit-task/:id
 * To get an edit form to update the task
 */
router.get("/edit-task/:id", (req, res) => {
    const taskId = req.params.id;
    const task = tasks.find((task) => task.id === parseInt(taskId));
    if (!task) {
        res.status(404).send("Task not found");
        return;
    }

    res.send(` <body style="display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
    <div style="text-align: center;">
        <h1>Update Task</h1>

        <form action="/update-task/${task.id}" method="post" style="display: inline-block; text-align: left;">
            <div style="margin-bottom: 15px;">
                <label for="name" style="display: block; margin-bottom: 5px;">Name:</label>
                <input type="text" id="name" name="name" required style="width: 100%; padding: 8px; box-sizing: border-box;" value="${task.name}">
            </div>
            <div style="margin-bottom: 15px;">
                <label for="description" style="display: block; margin-bottom: 5px;">Description:</label>
                <textarea id="description" name="description" rows="4" cols="50" required style="width: 100%; padding: 8px; box-sizing: border-box;" value="${task.description}">${task.description}</textarea>
            </div>
            <button type="submit" style="padding: 10px 20px; font-size: 16px;">Submit</button>
        </form>
    </div>
</body>`);
});

/**
 * POST
 * URI /update-task/:id
 * To update task based on id
 */
router.post("/update-task/:id",(req,res) => {
    const taskId = req.params.id;
    const task = tasks.find((task) => task.id === parseInt(taskId));
    if (!task) {
        res.status(404).send("Task not found");
        return;
    }
    const newTask = {
        id: task.id,
        name: req.body.name,
        description: req.body.description
    }
    Object.assign(task, newTask);
    res.redirect('/list-of-tasks');
});

/**
 * POST
 * URI delete-task/:id
 * To delete the task based on id
 */
router.post('/delete-task/:id',(req,res) => {
    const taskId = req.params.id;
    const task = tasks.find((task) => task.id === parseInt(taskId));

    if (!task) {
        res.status(404).send("Task not found");
        return;
    }
    const index = tasks.indexOf(task);
    tasks.splice(index, 1);
    res.redirect('/list-of-tasks');
})
/** Exporting routes to register in the app to make it available to accept request and return response */
module.exports = router;

Conclusion

In conclusion, routing in Express.js is a fundamental aspect of building robust and organized web applications, whether you're developing REST APIs or full-stack solutions. By mapping URLs to specific functions or handlers, routing enables us to effectively manage and structure our application code.

We've explored the various components of routing, including URL mapping, dynamic URL handling, middleware integration, and error handling, each contributing to a cleaner and more maintainable codebase. With Express.js's built-in routing capabilities, we can efficiently handle different HTTP methods and modularize our application into manageable routes.

Before proceeding, let's understand some basics about Express JS. So Express JS is a framework for Node.js. It provides easy ways to define routes, handle requests and responses with middleware, and integrate various features. With Express, you can create REST APIs effortlessly and efficiently manage tasks like user authentication and data handling. Its flexibility and large community support make it a go-to choice for developers building fast and robust web applications.

We need a few things installed in our machine to learn to Express js Node and the code editor of your choice, I recommend VS code as it is free, easy to use, and understandable.

Steps

Create a folder express-01 and a file with the name main.js you can name it whatever you want and run the below command.

1. npm install express

   The above command will install the Express Js into the application folder(express-01).

2. After installing Express open the main.js file in the code editor and write the below code.

    /**Importing the express Js */
    const express = require('express');
   
    /** Initializing the express application */
    const app = express();
   
    /** Register the route to accept the get request */
    app.get('/',(req,res,next) => {
        /** sending Hello World as a response*/
        res.send('Hello World');
    });
   
    /** Create server and start listing on the port of your choice */
    app.listen(3000);
   

   In the above code, we have imported the Express js to use the routing feature and also we have created an instance of an application to serve the get request and return the response.

In the next article, we will learn more about routing including the route verbs request and response and how to use them in the Express application.

Why Laravel Blade?

1. Clean and Expressive Syntax

   Blade's syntax is like a breath of fresh air in the web development world. It's a mix of regular HTML and simple codes that make it super-readable and easy to understand. Unlike raw PHP, Blade keeps things tidy, making it a delight for developers to work with.

2. Template Inheritance for Consistency

   One big reason we love Blade is its template inheritance feature. This means you can create a layout for your website once and use it everywhere without rewriting the same code. It's like having a master plan for your website's design that you can reuse effortlessly.

3. Encourages Best Practices

   Blade encourages separating different parts of your code, like keeping logic in one place and design in another. This separation of concerns helps in better organization and makes your code easier to understand and maintain.

4. Directives and Control Structures

   Laravel Blade offers powerful directives and control structures (such as loops, conditional statements, and includes) to manipulate data and control the flow of the application logic directly within the views.

5. Performance and Optimization

   Blade doesn't just make things pretty, it's also efficient. Laravel allows caching views created with Blade, which means your website can load faster by saving pre-rendered views, especially useful for frequently visited pages.

6. Community and Support

   Laravel, with Blade as its shining star, has a vibrant community. This means plenty of resources, tutorials, and support available online. If you ever get stuck or want to learn more, there's always a helping hand or a tutorial just a click away.

Basics of Laravel Blade

1. Introduction to Blade Syntax

   1. Echo Variables {{$name}} shows the content of a variable, like displaying a person's name stored in $name, and it's automatically sent through PHP's htmlspecialchars function to prevent XSS (Cross-site scripting) attacks.

      You are not limited to just printing the values stored in the variable you can print the result of functions as well as you can you can put any PHP code you wish inside of a Blade echo statement

       <!-- Displaying Variables -->
       {{ $name }}
      
       <!-- Displaying resut of a funtion -->
       The current UNIX timestamp is {{ time() }}.
      

   2. IF conditions in Blade: It checks if someone is logged in ($isLoggedIn). If true, it says a welcome message with the name; otherwise, it asks to log in.

       @if($isLoggedIn)
           <p>Welcome, {{ $username }}!</p>
       @endif
      
       <!-- Using @if/@else -->
      
       @if($isAdmin)
           <p>Welcome, Admin!</p>
       @else
           <p>Welcome, User!</p>
       @endif
      
       <!-- Using @if/@elseif/@else -->
      
       @if($userRole === 'admin')
           <p>Welcome, Admin!</p>
       @elseif($userRole === 'moderator')
           <p>Welcome, Moderator!</p>
       @else
           <p>Welcome, User!</p>
       @endif
      

   3. Loops in Blade:

      Laravel Blade provides several directives for looping through arrays or collections and offers loop-related variables to access information about the current iteration. Let's explore each loop directive and its associated loop variables.

      1. @foreach Loop

         • Initiates a loop through the $items array or collection. $items represent the data source being iterated, and $item is the loop variable that holds each item during iterations.

         • <p>{{ $item }}</p>: Within the loop, {{ $item }} displays each item in the $items array within <p> tags.

             @foreach($items as $item)
                 <p>{{ $item }}</p>
             @endforeach
           

      2. @forelse Loop:

         The @forelse directive in Laravel Blade is specifically designed to handle looping through data while also managing empty states more elegantly compared to traditional loops.

         @empty: This section is executed if the $user array is empty. It shows a message, like "No users"

          @forelse ($users as $user)
              <li>{{ $user->name }}</li>
          @empty
              <p>No users</p>
          @endforelse
         

      3. @for Loop:

         • @for($i = 0; $i < count($numbers); $i++): Sets up a traditional for loop. Here, $i serves as the loop counter starting from 0, iterating until the condition is met ($i < count($numbers)).

         • <p>{{ $numbers[$i] }}</p>: Displays each element of the $numbers array using the loop counter $i to access individual elements.

              @for($i = 0; $i < count($numbers); $i++)
                  <p>{{ $numbers[$i] }}</p>
              @endfor
           

      4. @while Loop

          @php
              $counter = 0;
          @endphp
         
          @while($counter < 5)
              <p>{{ $counter }}</p>
              @php
                  $counter++;
              @endphp
          @endwhile
         

      5. Loop Variables in Blade:

         1. $loop->index The index of the current loop iteration (starts at 0).

         2. $loop->iteration The current loop iteration (starts at 1).

         3. $loop->remaining The iterations remaining in the loop.

         4. $loop->count The total number of items in the array being iterated.

         5. $loop->first Whether this is the first iteration through the loop.

         6. $loop->last Whether this is the last iteration through the loop.

         7. $loop->even Whether this is an even iteration through the loop.

         8. $loop->odd Whether this is an odd iteration through the loop.

         9. $loop->depth The nesting level of the current loop.

         10. $loop->parent When in a nested loop, the parent's loop variable.

            $countries = ['USA', 'Canada', 'UK', 'Australia'];

            @foreach($countries as $country)
                <p>
                    Index: {{ $loop->index }} |
                    Iteration: {{ $loop->iteration }} |
                    First: {{ $loop->first ? 'Yes' : 'No' }} |
                    Last: {{ $loop->last ? 'Yes' : 'No' }} |
                    Count: {{ $loop->count }} |
                    Total Items: {{ $loop->total }} |
                    Odd/Even: {{ $loop->odd ? 'Odd' : 'Even' }} |
                    {{ $country }}
                </p>
            @endforeach

1. @switch @case and @default

   The @switch, @case, and @default directives in Laravel Blade provide a structured way to handle complex conditional logic. They function similarly to the switch-case-default construct in PHP.

    @switch($role)
        @case('admin')
            <p>Welcome, Admin!</p>
            @break
   
        @case('user')
            <p>Welcome, User!</p>
            @break
   
        @default
            <p>Unknown Role</p>
    @endswitch
   

Laravel Blade Directives

Blade directives are special syntax or instructions used in Laravel Blade templates to streamline and enhance the readability and functionality of your views. Here's an overview of some commonly used Blade directives

1. @include

   1. The @include directive in Laravel Blade is used to include and render other Blade views or partials within a Blade template. It enables the reusability of code by allowing you to insert the contents of another Blade file into the current file.

      This includes the content of the partials/header.blade.php file in the current Blade template at the location where the @include directive is placed.

       @include('partials.header')
      

   2. With Variables

      In this case, the partials/product.blade.php file is included, and it's passed a variable $product to use within that included file.

       $product = App\Models\Product::all();
      
       @include('partials.product', ['product' => $product])
      
       <!-- Second Exampe -->
      
       @include('partials.product', compact('product'))
      

2. @includeWhen

   The @includeWhen directive in Laravel Blade is a conditional way to include a Blade view or partial based on a given condition. It's similar to the @include directive but includes the specified view only when the condition provided evaluates to true.

   Difference between @include and @includeWhen:

   @include It unconditionally includes the specified Blade view or partial in the current template regardless of any condition.

   It's used for unconditional inclusion.

   @includeWhen: It includes the specified view based on a condition. If the condition is true, the view is included; otherwise, it's skipped. It's suitable for conditional inclusion.

    @includeWhen($condition, 'partials.header')
     <!-- With Variable -->
    @includeWhen($user->isAdmin(), 'partials.admin-menu', ['user' => $user])
   

3. @auth and @guest

   The @auth and @guest directives in Laravel Blade provide convenient ways to conditionally display content based on whether a user is authenticated (@auth) or is a guest (not authenticated, @guest). These directives simplify the rendering of specific content based on the user's authentication status.

    @auth
        <!-- Display content if user is authenticated -->
    @endauth
   
    @guest
        <!-- Display content if user is a guest (not authenticated) -->
    @endguest
   

4. @isset and @empty

    @isset($variable)
        <!-- Display content if $variable is set and not null -->
    @endisset
   
    @empty($items)
        <!-- Display content if $items is empty -->
    @endempty
   

5. @verbatim
   The @verbatim directive in Laravel Blade is used to render content as raw, plain text, ignoring Blade's default templating behavior. This directive allows you to display code snippets, text blocks, or any content without being processed by Blade's syntax parser.

   Avoid excessive use of @verbatim as it bypasses Blade's powerful templating capabilities. It's typically used sparingly in specific scenarios where you need to preserve the original content without modification by Blade.

   In this case, the content inside @verbatim will be displayed exactly as written, without Blade interpreting the {{ }} or @if conditions. The entire block will be rendered as plain text.

    @verbatim
        <p>{{ $name }}</p>
        @if($status == 'active')
            <span>Status: Active</span>
        @else
            <span>Status: Inactive</span>
        @endif
    @endverbatim
   

6. @csrf

   @csrf in Laravel Blade is a directive used for security purposes, specifically to prevent Cross-Site Request Forgery (CSRF) attacks. CSRF attacks occur when a malicious website tricks a user's browser into performing actions on another site without the user's knowledge, using their authenticated session.

   By using @csrf in your forms, Laravel ensures that your application is better protected against CSRF attacks, safeguarding the actions performed by your users.

    <form method="POST" action="/submit">
        @csrf
        <!-- Other form fields -->
        <button type="submit">Submit</button>
    </form>
   

Conclusion

Laravel Blade is a super easy way to make awesome websites and web applications. It's like using magic blocks to build your webpage. With simple commands, you can create cool designs, show different things to different people, and keep your site safe. Plus, it helps your webpage load faster, and there are lots of online friends to help you learn more. Start using Blade and make something amazing!

Laravel Sanctum primarily solves two problems

1. API Tokens

   Sanctum provides API tokens without the complication of OAuth by providing personal access tokens inspired by GitHub and other applications that use personal authentication tokens for authentication and authorization. Sanctum achieves this by storing the access token in the database and authorizing incoming HTTP requests via the Authorization header.

2. SPA Authentication

   Sanctum offers an easy way to authenticate Single Page Applications (SPA), communicating with the APIs developed using Laravel. You can use Sanctum whether you are using a separate application for frontend developed in Vue or React, or you are using Laravel with Vue or React with Laravel in one project.

   Sanctum uses the default cookie-based service for authentication that comes in the default authentication for the web in Laravel, That's why you don't need any token-based authentication for your Single Page Application.

   The benefits of using this is you will get CSRF Protection and session authentication, and also gives protection against the leakage of authentication credentials vis XSS(Cross-Site Scripting.).

   It is not compulsory to use cookie-based authentication, you can use token-based authentication also. Sanctum will only use cookie-based authentication if it's coming from your SPA otherwise it will look for the Authorization header for a valid API token.

   As of now, we have a detailed introduction to Sanctum and the working mechanism, so now we will explore how to implement it in our application.

3. Sanctum Implementation

   1. Installation

       composer require laravel/sanctum
      

   2. Publish Configuration

       php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"
      

   3. Run migration

      To create a table in your database to store authentication tokens

       php artisan migrate
      

   4. Adding Middleware

      If you want to use the sanctum for your Single Page Application (SPA) you should add the below middleware to your api middleware group or else you can ignore this step. The EnsureFrontendRequestsAreStateful middleware to the API middleware group. This middleware is provided by Sanctum and is crucial for ensuring that authentication tokens are properly handled between the SPA and the backend. It maintains the statefulness of the authentication session, allowing users to remain logged in while navigating your SPA.

       'api' => [
           \Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful::class,
           \Illuminate\Routing\Middleware\ThrottleRequests::class.':api',
           \Illuminate\Routing\Middleware\SubstituteBindings::class,
       ],
      

   5. Configure CORS (Cross-Origin Resource Sharing)

      CORS is a security feature implemented in web browsers to control which web pages can access resources on a given domain. In this step, you are configuring your Laravel application to allow requests from your SPA's domain. By specifying your SPA's URL in the allowed_origins array, you are permitting it to make requests to your Laravel application. This step ensures that your SPA can communicate with your API without encountering CORS-related issues.

      Add the below code in config/cors.php add your SPA URL in paths array.

       'paths' => ['api/*', 'sanctum/csrf-cookie', 'login', 'logout'],
       'allowed_methods' => ['*'],
       'allowed_origins' => [env('SPA_URL')], // your SPA URL
       'allowed_origins_patterns' => [],
       'allowed_headers' => ['*'],
       'exposed_headers' => [],
       'max_age' => 0,
       'supports_credentials' => true,
      

   6. Create API Routes

      Create your API routes in routes/api.php file.

       use App\Http\Controllers\API\AuthController;
       use App\Http\Controllers\API\YourController;
      
       Route::prefix('auth')->group(function () {
           Route::post('/login', [AuthController::class, 'login']);
           Route::post('/register', [AuthController::class, 'register']);
           Route::middleware('auth:sanctum')->post('/logout', [AuthController::class, 'logout']);
       });
      
       Route::middleware('auth:sanctum')->group(function () {
           Route::get('/user', [AuthController::class, 'user']);
       });
      

   7. Implement SPA Authentication

      In your SPA (Single Page Application), you need to implement the frontend logic for user authentication. Here, Axios, a popular HTTP client for JavaScript, is configured to handle requests. Axios is used to send HTTP requests to your Laravel API. The withCredentials property is set to true to include credentials (such as cookies) with requests. The login and logout functions demonstrate how to perform user login and logout operations. These functions handle sending requests to the appropriate API endpoints (/api/auth/login and /api/auth/logout) and manage the user's authentication status in your SPA.

      
       axios.defaults.withCredentials = true;
      
       async function login(email, password) {
           try {
               await axios.get('/sanctum/csrf-cookie');
               await axios.post('/api/auth/login', {
                   email: email,
                   password: password
               });
      
           } catch (error) {
      
           }
       }
      
       async function logout() {
           try {
               await axios.post('/api/auth/logout');
      
           } catch (error) {
      
           }
       }
      

Conclusion
Laravel Sanctum emerges as the top choice for Single Page Applications (SPAs) seeking secure and streamlined authentication solutions. Unlike its counterpart Laravel Passport, Sanctum simplifies the complex process of API token management and offers effortless SPA authentication. By storing access tokens securely and employing cookie-based authentication, Sanctum ensures robust security measures, including CSRF protection and defense against cross-site scripting attacks. Its seamless integration capabilities make it a preferred option for developers, allowing them to focus on building user-friendly, secure SPAs without the complexities of intricate authentication systems. Sanctum’s simplicity, enhanced security, and seamless integration make it the go-to solution for modern SPAs in the ever-evolving landscape of web development.

As we all know Laravel has huge open-source packages to help in every situation, we have a package to help us in this situation also and the package is Laravel Pint. Laravel Pint is a zero-dependency PHP code style fixer for minimalists - built on top of PHP-CS-Fixer. For Laravel 9 and other latest versions, this package is included in the default installation of Laravel, for older versions you can install this by using the composer.

Automating code style checks and fixes based on a preset, making it effortless to ensure your code conforms to best practices. Let's dive into the world of Laravel Pint and see how it simplifies code styling by using some simple steps.

Installation

Install the package for the Larvel 8 and other older versions.

composer require laravel/pint --dev

Using Laravel Pint

As we have discussed earlier Laravel pint can be used without doing any configuration you can fix the code style issue of your application by just running the below command.

./vendor/bin/pint

No need to worry about configurations, presets or any other setup, Changes will be done according to the PSR-12 styling, and any issue will be automatically fixed. It will work like a magical command to keep your code clean and consistent!

Use case scenarios

1. Run the command to check and fix all the files of your application

    ./vendor/bin/pint
   

2. Run on a specific Folder

    ./vendor/bin/pint app/Models
   

3. Run on a specific File

    ./vendor/bin/pint app/Models/User.php
   

4. View the list of updated files by Pint

    ./vendor/bin/pint -v
   

5. Check the files without changing them

    ./vendor/bin/pint --test
   

6. Run the test only on the files with uncommitted changes

    ./vendor/bin/pint --dirty
   

Configuration

By default, we do not need any configuration to run the pint but we can change the configuration according to your need. You can change the preset rules and inspected folders by creating the pint.json file in your root directory.

1. Preset

   Preset defines a set of rules to fix the code style issue in the file.

   By default, the preset value is Laravel so it will follow the opinionated coding style of Laravel. You can change the value as per your needs in pint.json supported presets are laravel, per, psr12, and symfony.

    {
        "preset": "psr12"
    }
   

2. Rules

   As presets are already a set of predefined rules, probably you will not change the configuration files, however, there are options available to change the rules.

   As Pint is built on PHP-CS-Fixer you can use any of it's rules available for styling.

    {
        "preset": "psr12",
        "rules": {
            "simplified_null_return": true,
            "braces": false,
            "new_with_braces": {
                "anonymous_class": false,
                "named_class": false
            }
    }
   

3. Excluding Folders/Files

   Pint will check all the .php files except the vendor directory, you can exclude the files and folders you want

    {
        "exclude": [
            "my-specific/folder"
        ],
        "notName": [
            "*-my-file.php"
        ],
        "notPath": [
            "path/to/excluded-file.php"
        ]
    }
   

Conclusion

Laravel Pint is a must install tool for any PHP developer working on projects, packages, or anything else that involves writing PHP code. With its simplicity, zero-dependency approach, and flexibility in configuration, it's a powerful addition to your toolkit. Say goodbye to messy PHP arrays and complex rule configurations. Laravel Pint streamlines the process of maintaining a clean and consistent code style. Start using it in your projects today and experience the magic of effortless code styling. 🚀

In the ever-evolving world of software development, one key aspect that separates exceptional software from the mediocre is the thoughtful application of design patterns and principles. These invaluable tools provide a systematic approach to problem-solving, enabling developers to create well-structured, maintainable, and extensible codebases. In this blog, we will explore why it is crucial to embrace design patterns and principles in software development and how they can significantly impact the quality and efficiency of your projects.

1. Reusability and Maintainability:

   Design patterns offer a proven set of solutions to commonly occurring problems in software development. By utilizing these patterns, developers can tap into a wealth of knowledge and experience accumulated by the community. Design patterns promote code reuse, allowing you to leverage existing solutions rather than reinvent the wheel. This, in turn, reduces development time, enhances productivity, and facilitates the maintenance of codebases over time. By adhering to well-established patterns, future developers can easily understand and modify the code, leading to increased project longevity.

2. Scalability and Flexibility:

   As software applications grow in complexity, scalability becomes a critical consideration. Design patterns enable developers to build scalable software architectures that can adapt and evolve with changing requirements. Patterns like the Observer pattern facilitate loose coupling between components, allowing for easy integration of new features without impacting existing code. The use of design patterns ensures that your software can handle increased user loads, evolving business needs, and technological advancements without requiring a complete rewrite.

3. Enhancing Collaboration:

   Software development is rarely a solitary endeavor. Teams of developers collaborate to build innovative applications. Design patterns and principles provide a common language and set of guidelines that promote effective collaboration. When team members follow established patterns, it becomes easier to understand and reason about each other's code. Design patterns establish a shared vocabulary and a consistent approach to problem-solving, enhancing communication and teamwork. By adhering to principles such as the Single Responsibility Principle (SRP) and the Open-Closed Principle (OCP), codebases become more modular and comprehensible, enabling seamless collaboration among team members.

4. Testability and Quality Assurance:

   Testing and quality assurance are integral parts of the software development lifecycle. Applying design patterns and principles greatly improves testability. Patterns such as the Dependency Injection pattern enable the creation of modular, testable code by promoting loose coupling and separation of concerns. This allows for the isolation of components during unit testing, making it easier to detect and fix issues. By adhering to principles like the Interface Segregation Principle (ISP) and the Dependency Inversion Principle (DIP), software becomes more modular and easier to test. The result is increased code coverage, improved software quality, and reduced maintenance costs.

5. Future-Proofing and Knowledge Transfer:

   Technology is constantly evolving, and software projects have a long lifespan. Design patterns and principles provide a future-proof foundation for your applications. By adopting widely recognized patterns, you ensure that your codebase remains relevant and adaptable to new technologies and paradigms. Furthermore, design patterns and principles facilitate knowledge transfer among developers. When new team members join a project, having a well-documented and pattern-based codebase helps them quickly understand the system's architecture and design decisions, ensuring continuity and reducing the learning curve.

1. In Laravel, many patterns and structures are followed, making it easier for developers to create models, assign tables, and write controllers. By leveraging Laravel's conventions, we can save time and effort. Let's explore some shortcuts and methods to speed up development without worrying about naming conventions and patterns.

2. In Laravel, the model plays a central role in CRUD operations, with other files associated with it. To create a model class efficiently, use the artisan command, ensuring you follow the naming convention. Laravel will generate the remaining associated files automatically using additional parameters provided with the command. This approach streamlines the process and eliminates the need to create related files manually.

   php artisan make:model ModelName

   ---

   1. List of options available with make model command

      1. --migration or -m: This option creates a new migration file along with the model. It generates a database migration file with the appropriate schema for creating the corresponding table in the database. This is useful when you want to quickly create the model and its associated migration at the same time.

      2. --controller or -c: This option generates a new controller along with the model. It creates a controller class that can be used to handle the CRUD operations related to the model. The controller is generated with the appropriate naming convention and basic methods such as index, create, store, show, edit, update, and destroy.

      3. --factory or -f: This option generates a factory class for the model. A factory class allows you to define the blueprint for creating fake data for testing or seeding your database. It provides a convenient way to generate sample records that adhere to your model's structure.

      4. --resource or -r: This option generates a resource class for the model. A resource class helps in transforming your model data into a JSON representation. It is useful when building APIs or working with data that needs to be returned in a specific format.

      5. --seed or -s This option generated a seeder file for the model.

         A seeder file can help to seed dummy data for testing and also to seed some configurations in the database.

      6. --requests or -RThis option generates a form request class and uses them in the controller file for the request validation.

      7. --all: This option is a shorthand for generating the model, migration, seeder, factory, policy, resource controller, and form request classes for the model all at once. It saves time by generating all the necessary files for a complete CRUD operation in a single command.

         Example :

         1. php artisan make:model ModelName --all will create the below files.

            

1. Use case scenarios

   1. Certainly! To optimize the generation of classes using the available options, it's important to consider the specific requirements of your project. Here are some examples of how you can combine the options to generate classes more efficiently:

      1. Generating a Model, Migration, and Controller:

         This command generates a model class, a migration file, and a controller class, all in one go. This is useful when you need to quickly set up the basic components for a new resource.

          php artisan make:model ModelName -mcr
         

      2. Generating a Model, Migration, and API resource Controller:

         This command generates a model class, a migration file, and an API resource controller class, all in one go. This is useful when you need to quickly set up the basic CRUD components for API.

          php artisan make:model ModelName -mcr --api
         

      3. You can combine any of the options explained above to create the Class files required in your CRUD and you don't need to worry about the Naming Convention and file folder structure Laravel will do that for you.

Conclusion :

Laravel provides convenient and efficient ways to generate model classes and associated files using the php artisan make:model command. By utilizing the available options, such as migrations, controllers, factories, resources, and more, developers can streamline the process of creating CRUD functionality in their applications. This helps to save time, adhere to naming conventions, and maintain a consistent project structure. By leveraging Laravel's built-in tools and conventions, developers can focus more on implementing business logic and delivering high-quality applications.

• The model in Laravel represents a logical abstraction of a database table. It acts as an intermediary between the application and the database, Laravel follows the convention of one model per table, making it easy to organize and manage your application's data.

  As of now, we know that for every table, we have to create a mode and models are very powerful and have lots of properties and methods to make development easier, we will explore the model's property and their use cases in this blog.

Defining a Model

• To create a model in Laravel, you can use the artisan command-line tool or manually generate a new PHP class.

  Command to create a model php artisan make:model ModelName (Use PascalCase for the model name)

  I prefer to create a model using the artisan command as after that I don’t have to take care of the parent model class and there are other options also available to create files that will require to complete the feature like Controller, Migration, Seeder, Factory, Request, etc.

Model Properties

Let's explore some essential properties of Laravel models

1. Table Name

   By default, Laravel assumes that the table name corresponds to the snake case plural form of your model name.

   Example

   1. If you have a model named User Laravel Laravel will assume that the corresponding table name is users and for ProductCategory the table name will be product_categories.

   2. You can also override this and assign the custom table name of your choice to the model’s $table property.

      protected $table = 'your_table_name';

2. Primary Key

   Laravel assumes the primary key of a table to be an auto-incrementing integer column named id. You can customize this behavior by setting the protected $primaryKey property in your model.

3. Timestamps

   Laravel provides built-in support for maintaining CREATED_AT and UPDATED_AT timestamps on your model's records.

   By default, these columns are assumed to exist in your table. However, you can disable timestamps by setting public $timestamps = false them in your model.

   You can also override these column names by defining constants on your model,

   you need to define constants CREATED_AT or UPDATED_AT

4. Soft delete

   Soft deletion in Laravel is a feature that allows you to mark records as "deleted" without actually removing them from the database.

   By default, Laravel uses the ‘deleted_at` column (column is of type DateTime), you can override the column name by just defining a constant with the name ‘DELETED_AT` and assigning the custom column name.

5. Fillable and Gaurded

   To protect against mass assignment vulnerabilities, Laravel offers two approaches: fillable and guarded attributes.

   Fillable attributes define the fields that can be mass-assigned using the create() or update() methods, while guarded attributes protect fields that should not be mass-assigned.

6. Relationship Declarations

   Laravel simplifies working with relational databases by providing eloquent relationships.

   You can define relationships between models using methods like hasOne(), hasMany(), belongsTo(), belongsToMany(), and more.

   These relationships enhance data retrieval and simplify querying related data.

7. Model Events

   Laravel models allow you to define event callbacks for various actions, such as creating, updating, deleting, and retrieving records. These events provide hooks into the model's lifecycle and enable you to execute custom logic when specific actions occur.

8. Connection

   By default, Laravel assumes that a model will use the default database connection specified in the config/database.php configuration file.

   However, there are cases where you may need to connect to a different database or use a specific connection for a particular model. In such scenarios, you can set the $connection property within your model class to specify the desired database connection.

   protected $connection = 'your_connection_name';

9. Recently Created

   The public $wasRecentlyCreated property in Laravel is a flag that indicates whether a model instance was recently created and saved to the database.

10. Model exists

    The public $exists property in Laravel is a flag that indicates whether a model instance exists in the database.

    You may have a model instance that does not correspond to an actual record in the database. In such cases, you can manually set the $exists property to false to indicate that the model instance does not exist in the database.

11. Global Scope

    The protected static $globalScopes property in Laravel allows you to define global scopes for your Eloquent models.

    Global scopes are conditions that are automatically applied to all queries for a given model. They enable you to define common query constraints that should be applied to every database interaction for that model.

    The $globalScopes property is an array where you can define instances of your global scope classes. Each entry in the array represents a global scope that you want to apply to the model.

12. Pagination

    The protected $perPage property in Laravel allows you to specify the default number of items to be included in a paginated result set.

    When you retrieve a collection of models and paginate the results using Laravel's pagination feature, the $perPage property determines the number of items that will be displayed per page. By default the value per page value sets to 15, you can modify that on your model by protected $perPage = 30;

Conclusion

• Laravel models are the backbone of database interaction in your web applications. By leveraging the Eloquent ORM, developers can streamline database operations, define relationships between entities, and implement complex querying with ease. Understanding the various properties and features of Laravel models empowers developers to build robust and maintainable applications efficiently.

1. Basic Controllers:

   Basic Controllers are the simplest form of controllers in Laravel. They contain methods that handle various HTTP requests, such as GET, POST, PUT, and DELETE. These controllers are useful when you have a small number of routes and actions to manage. They provide a straightforward way to organize your application logic without any additional complexity. Basic Controllers are often used in smaller projects or when the logic for each route action is minimal.

   Command to create a basic controller: php artisan make:controller ControllerName

2. Resource Controllers:

   Resource Controllers are designed to handle the common CRUD (Create, Read, Update, Delete) operations for a specific resource. Laravel's resource routing feature allows you to define these controllers with a single line of code, which automatically generates the necessary routes for all the standard RESTful actions. Resource Controllers provide a clean and consistent way to handle data manipulation in your application. They are ideal for managing resources such as articles, users, or products.

   Command to create a resource controller: php artisan make:controller ControllerName -r(Resource)

3. API Controllers:

   API Controllers are specifically tailored for building APIs or web services. They typically return JSON or XML responses instead of rendering views. API Controllers are useful when you need to expose your application's functionality to other systems or integrate with mobile apps. These controllers often involve authentication, validation, and serialization of data. Laravel provides tools and middleware to simplify these tasks, making API development more streamlined.

   Command to create a resource controller: php artisan make:controller ControllerName --api

   Note: This will create a Resource controller for API and create and edit methods will be excluded as we don't need these methods in API.

4. Invokable Controllers:

   Invokable Controllers are a unique feature of Laravel that allows you to define a controller as a single, callable class. Instead of having multiple methods to handle different actions, an invokable controller has a single __invoke() method that handles the request. This approach provides a clean and concise way to define controller logic when you have a single action to perform. Invokable Controllers are particularly useful for tasks such as processing form submissions or executing a specific operation.

Command to create a resource controller: php artisan make:controller ControllerName -i

Conclusion:

Laravel's flexibility allows you to mix and match these controller types as your project evolves and grows in complexity. Stay mindful of the specific use cases for each type and adapt them accordingly to build scalable and efficient web applications.