# Laravel 5.8 - 21 important update you should care about.
**Laravel 5.8 is now released and this release has many many improvements, addition and some breaking changes.**


### I. Major Upgrade or Breaking Changes

1. Caching TTL
2. Deprecated Helper Functions
3. Dotenv 3.0
4. Carbon version 2
5. Notifications Package
7. Testing PHPUnit 8
8. Password Length

### II. Improvements

1. Error Page
2. Artisan Call Improvements
3. Email Validation
4. Eloquent Resource Key Preservation
5. Higher Order orWhere Eloquent Method
6. JSON in MYSQL
7. Correct Pluralisation
8. Mock / Spy Testing Helper Methods

### III. New Addition

1. Artisan Serve Improvements
2. Auto-Discovery Of Model Policies
3. HasOneThrough Relationship
4. Token Guard Token Hashing
5. Default Scheduler Timezone
6. Multiple Broadcast Authentication Guards


## Caching TTL
Caching in previous laravel versions was set with time in minutes.
So if you have given any integer to cache methods then that was considered as time in minutes.

With laravel 5.8, that is directly converted to seconds for more precise and concise setting of cache timing.
So make sure you will change that time from minutes to seconds.

```php
// Laravel 5.7 - Store item for 5 minutes...
Cache::put('foo', 'bar', 5);

// Laravel 5.8 - Store item for 5 seconds...
Cache::put('foo', 'bar', 5);
```

## Deprecated Helper Functions
All array_* and str_* global helpers have been deprecated.
This means from laravel 5.9 there will be no longer available.

But don't worry about this removal as for now you can easily use there functions using `Illuminate\Support\Arr` and `Illuminate\Support\Str` methods directly.

And after laravel 5.8 they will be packed in a separate package.

## Dotenv 3.0
Laravel 5.8 is now ships with PHP dotenv 3.0 which includes the many new features.

1. No trimming of values from .env file, you get them exactly as-is now. so spaced are also considered.
2. Support for multi-line variables.
3. Accept a list of paths to try in order looking for the dotenv file, rather than a single path.
4. Stronger validation of variable names to avoid silent failures or obscure errors

Check out [PHP dotenv 3.0](https://github.com/vlucas/phpdotenv/releases/tag/v3.0.0) github release notes.

## Notifications Package
This is a major change to be considered. 
With laravel 5.8, slack notification and nexmo notification is now moved to dedicated first-party package and no longer is a part of laravel core component.
Now you need to install these via composer.

```php 
composer require laravel/nexmo-notification-channel
composer require laravel/slack-notification-channel
```

## Testing PHPUnit 8
By default, Laravel 5.8 uses PHPUnit 7. 
However, you may optionally upgrade to PHPUnit 8, which requires PHP >= 7.2. 
To this change, The setUp and tearDown methods now require a void return type:

```php
protected function setUp(): void
protected function tearDown(): void
```

## Carbon version 2
Laravel 5.8 can able to use either Carbon v1 or Carbon v2, including the ability to use CarbonImmutable, and even make CarbonImmutable the default. 
Localization has changed quite a bit in Carbon v2, with much better internationalization support offered than v1. 
Learn more about [Carbon 2.0](https://carbon.nesbot.com/docs/#api-carbon-2)


## New Default Password Length
The required password length when choosing or resetting a password was changed to at least [eight characters](https://github.com/laravel/framework/pull/25957).


## Mock/Spy Testing Helper Methods
Mocking any class in laravel is now even more simpler. check this demo.

```php
// Laravel 5.7
$this->instance(Stripe::class, Mockery::mock(Stripe::class, function ($mock) {
    $mock->shouldReceive('charge')->once();
}));

// Laravel 5.8
$this->mock(Stripe::class, function ($mock) {
    $mock->shouldReceive('charge')->once();
});
```

## Artisan Serve Improvements
Until now with laravel previous versions,
Artisan's serve command would serve your application on port  8000.
So, if another serve command to start a server started, an attempt to serve a second application via serve would fail. 
But now in Laravel 5.8, serve will now scan for available ports up to port 8002 and will serve multiple applications at once.



## Auto-Discovery Of Model Policies
Now with laravel 5.8, you don't have to register your Policies untill they are at their conventional directory which is `aap/policies`.
In addition, the policy name must match the model name and have a `Policy` suffix. So, a `Product` model would correspond to a `ProductPolicy` class.


## HasOneThrough Relationship
ELoquent now support a new type of relationship which is `hasOneThrough` relationship type.

Imagine a scenario when a user has a `Product` model and that product has a `ProductDetail` model,
now with this relationship you can easily get user's product details via `Product` model.

```php
/**
 * Get the product details of user.
 */
public function productDetails()
{
    return $this->hasOneThrough(ProductDetail::class, Product::class);
}
```

## Token Guard Token Hashing
Now with laravel 5.8, you can easily setup your API token system on laravel itself and can store token with SHA-256 hash.
This means you don't have to specifically use laravel passport just for authentication or any jwt package. But if you wish to use any package you are totally free as passport package is there to user.
Learn more at [API authentication documentation.](https://laravel.com/docs/5.8/api-authentication)

## Default Scheduler Timezone
Yes with laravel you can define your timezone for a scheduled task. but if you have many scheduled tasks running and all are using same timezone then it will be repetitive and pain to define same timezone for each scheduled task.

Now comes laravel 5.8 `default scheduler timezone`, 
you may now define a scheduleTimezone method in your `app/Console/Kernel.php` file.

This timezone defined in Kernel file will be attached to every scheduler you have.
In your `app/Console/Kernel.php` 
```php
/**
 * Get the timezone that should be used by default for scheduled events.
 *
 * @return \DateTimeZone|string|null
 */
protected function scheduleTimezone()
{
    return 'Asia/Kolkata';
}
```


## Multiple Broadcast Authentication Guards
Now authenticate private or presence channels with different middlewares, other than the default middleware of the project.

```php
Broadcast::channel('channel'Name, function() {
    // ...
}, ['guards' => ['web', 'admin']])
```

## Artisan Call Improvements
If you want to programmatically call Artisan command then you generally use `Artisan::call` method.
But what if you need to pass some options to the command. Here is a simple way to do so.
```php 
Artisan::call('migrate:install', ['database' => 'foo']);
```

But with laravel 5.8, its just like a command you write on console/terminal. Super easy to define options inline to command.

```php
Artisan::call('migrate:install --database=foo');
```

## Email Validation
Improvement in email validation is added to laravel 5.8.
Previously the email like example@naïve.com was considered as invalid, but now it will pass the email validation and thanks to adoption of `egulias/email-validator` package.


## Higher Order orWhere Eloquent Method
Previously, combining various scoped query with `or` query require a closure to be defined.
```php
// scopeActive and scopeEmailVerified methods defined on the User model...
$users = App\User::emailVerified()->orWhere(function (Builder $query) {
    $query->active();
})->get();
```

But now with laravel 5.8 you don't need that closure anymore.
```php
$users = App\User::emailVerified()->orWhere->active()->get();
```

## Correct Pluralisation
A fix for pluralisation of your Models is corrected in laravel 5.8

in Laravel 5.7,
app\Advice.php will be pluralized as advice only
but app\Customer_advice will be pluralized as customer_advices, which is incorrect.

In laravel 5.8
app\Advice.php will be pluralized as advice only
but app\Customer_advice will be pluralized as customer_advice, which is correct.

## JSON in MYSQL
This is a fix from previous versions where when you store any json data in your database, then query builder will return quoted string `'"hello"'`.
But with laravel 5.8, they will be unquoted which means simple string is returned `'hello'`.


## Eloquent Resource Key Preservation
Previously When we use `eloquent resource collection`, then it will reset the collection's key and simple order will be returned.

But now you can set `preserveKeys` property to your resource class to preserve the keys of your collection.
```php

<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class User extends JsonResource
{
    /**
     * Indicates if the resource's collection keys should be preserved.
     *
     * @var bool
     */
    public $preserveKeys = true;
}
```




## Error Page
Now the error page is looking more modern, minimalistic and cool.

Laravel 5.7 also had nice error pages but that was not suitable for every situation.
A simple error page can be used everywhere.

Sarthak

What's new in Laravel 5.8

# What the Heck is ReSTful API ?

Why you need Api and why you need Rest concept to create API.

![](https://api.bitfumes.app/storage/blog-content/TD4at6foq0CBRiHy3CPtF98BwgVjJItWF2tXCSoX.png)

What is Restful api.
If this is your questions then you are on correct article.

## Why need API

We are living in a world of Internet and we have many devices to access internet, which ranging from Desktop, Tables and Mobile.

Mobile is now becoming our new world, and this world (internet) works on a protocol called [HTTP (Hypertext Transfer Protocol).](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol)

Think about protocol as the Rules with which our internet work.


Initially Internet was design to share information between any two computer situated apart, but we are living in 2017 this means we want our Machines to talk to other Machine.

## Why need Machine talking

We know that[ IoT ](https://en.wikipedia.org/wiki/Internet_of_things) is the Future.But if you don’t know what is[ IoT](https://en.wikipedia.org/wiki/Internet_of_things), it means [Internet of Things](https://en.wikipedia.org/wiki/Internet_of_things).

Let me simplify this,

In future you will have your house that can communicate with any other thing, this means you can remotely open or close your house’s door/window or even start or stop AC/Geezer. Even a simple toaster can be included in IoT.

All this means every machine need to share data with other machines and this is exactly we want.

**But how we make machines to talk ?**

## Here Comes our Friend API

We know that *soul* of every machine is its software, this means we need *softwares* to talk to each other and to do so we need API


# [API stands for Application Programming Interface.](https://en.wikipedia.org/wiki/Application_programming_interface)

I think you know what Interface means, this means connecting two things and this is our main purpose

## But what an API can do for us.

API allows two software programs to communicate with each other and this is cool.

## What are the types of API

There are basically three types of API

Local

Web

Programe

But lets only focus on *Web API*.

## What WEB API can do for use ?

Suppose you have an Mobile App and you want your user to have weather information, but obviously your phone does’t have a sensor to sense weather information.

But even if they have, they can only sense the weather information of place where your mobile is situated, but not for every city in the world.

For this you can find many websites which provide weather information of every city of the world, but the problem is how we can get data from that website to our App.

This awesome work can only done by using Web Api.


This website gives weather of London, but its totally human readable, but how can a machine ( or App ) can get this data.

For this you need to get data via API. Here is the data looks like for a Web Api.


Think about API as a waiter who takes order from you and go to kitchen and come back with whatever you have requested.

Similarly, Web API takes request from one Machine and go to server and come back with the data in a JSON format just like this.



### But how can we start

Actually we know that there are many developer in this world with knowledge of lots of languages, so we need an structural way to create WEB API for machines so that there will be a standard or a system that every one can follow. So here comes our another Friend called “REST”.

### What is REST ?

It stands for REpresentational State Transfer. But what it is ? So firstly, its not a Web Service. Its a concept, design or simply an Architecture.


## What is Architecture ?


The word Architecture means :

The art or practice of designing and constructing buildings.
So with Rest is also TRUE, we are going to build our API in an structural or Proper way.

It defines how you have to create an API and what will be its structure. When a machine request something from a server, the Server return data in various formats like XML, JSON etc. (but most famous is JSON )

JSON is JavaScript Object Notation, in which you provide data in object format which any language can easily parse and retrieve information.



### REST Basics

In a restful way you have to provide data with various request methods.

Like, to read information you send GET request, like wise for write POST, for editing PUT, and to destroy DELETE.

All these request transfer via the same platform called HTTP, this exactly means that the way human interact with machines via Browsers, that same way is used by machines and which results in reducing the work of creating a new platform for transferring data between machines.


### Web Service

I have told you that REST is not a web Service, but what exactly a web service means.

Web Service is the Collection of protocols and standards used for exchanging data between any platform
So all this means an API created by using ReST architecture is called “ *ReSTful API* “

Thus a *Restful API is a WebService*


## Conclusion


1. To have communication between machines we need API
2. Web API are the machine readable form of your webpage ( even many websites are consuming their own API )
3. They need a standard which we call “ ReST ”

Thanks for reading, Keep Learning.

Subscribe to my [Youtube Channel ](http://youtube.com/bitfumes)or like on [Facebook](http://facebook.com/bitfumes)

What the Heck is ReSTful API ?

[Middleware](https://laravel.com/docs/5.5/middleware) do the task as its name suggest. Its in between of your request and your response to do some task in between these two things.


# Lets take an example.


Suppose you have a link called 'profile' and you clicked on that to get user profile.

This sounds good but where middleware comes in this picture.



Obviously, you want to show profile only when user is logged in and want to redirect to somewhere else when not logged in.

This means there have to be anything which have eagle eye on requests.


# Here is our Hero Middleware

So to protect every request for authentication you create Middleware.
Here is the middleware looks like for this same task.

```php
public function handle($request, Closure $next, $guard = null)
 {
   if (Auth::guard($guard)->check()) {
   return redirect('/');
 }

   return $next($request);
 }
```

This middleware comes into play when you attached it on any route.

`Route::get('/profile','UserController@profile')->middleware('auth');`

**Now lets see this in details.**

When you click on a link which has this profile route, then instead of directly going to UserController's profile function, this route has to first verify via auth middleware, 

This middleware then check if requested user is a guest or not, if user is a guest( not logged in) then it redirect to home page ( route('/') ) but if user is authenticated ( not a guest ) then it allow user to go to requested page and then profile function executes on that.


In this way middleware protect the request for every route where you have defined it.


# Can I create custom middleware?

Of course, you can easily create your own custom middleware so that you can protect your route according to your need. You just have to use this artisan command

`php artisan make:middleware CustomMiddleware`


This will create a middleware like this

```php
namespace App\Http\Middleware;

use Closure;

class CustomMiddleware
{
  /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
   return $next($request);
 }
}
```


Now you have to write your own check here in this CustomMiddleware but before using this middleware you have to register it on kernel.php file on your app/Http/Kernel.php

```php
protected $routeMiddleware = [
  'auth' => \Illuminate\Auth\Middleware\Authenticate::class,
  'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
  'bindings' => \Illuminate\Routing\Middleware\SubstituteBindings::class,
  'can' => \Illuminate\Auth\Middleware\Authorize::class,
  'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
  'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
  'CustomName' => \App\Http\Middleware\CustomMiddleware::class
];
```


This part is important as it allows middleware to used by laravel.

You can do anything you want, like you can increment views count here, you can check if user can have permission or not, there is no limit to use middleware. It all depends upon your way of coding.

You can learn more about middleware in laravel official documentation.

# Conclusion

Middleware is very useful to have checking of anything in between your request and response.

Think about Middleware like a gatekeeper which allows or deny anyone to enter from gate.

What is Laravel middleware & why use it?

One of my friend called me and said, Hey Sarthak I need your help, I could't find out the problem in my code. Then I go through the codes and found that he was using `get method` ( to get data from database via model) and that was the mistake, I just changed `get` to `first` .

But the question arise, what is the difference between these two and why that code was not working with get but worked perfectly with first.

# Take Some Example
Now consider these two codes and their results

First is for get() method
![](https://api.bitfumes.app/storage/blog-content/t4lcyPMLTywJ7QUd9UwuwR2Kf2frIcgmL1tGNeqY.jpeg)

This one below is for first() method

![](https://api.bitfumes.app/storage/blog-content/pV76xOpBo1dHOhv7rQx3bItLXsLr4ffJ6sZQBEAq.jpeg)
At first look you did't get the difference, but look closely there is a great difference. 

`get method`  give a collection and `first method` give you a model instance.



When we have to use `get()` and when `first()`


When you want to get collection of data means, lots of results then use get but if you want to retrieve only one result then use first.

# What else first can do.

Ya this gives you only one result from the ocean of data but as the name suggest it will give the first result.

Suppose you have two results from your query then which one will return by this function, so the answer is the first one.

Whatever laravel get at first, it suddenly return that and this is very cool.



You have may Eloquent collection methods, for example you `exists() method` will return you boolean, if the database has query part or not.



# Conclusión

Get() is for lots of data and first() is for single data.

If you have any question then please comment me or email me on sarthak@bitfumes.com



adiós

Laravel

What's new in Laravel 5.8

Laravel

What the Heck is ReSTful API ?

Laravel

What is Laravel middleware & why use it?

Laravel

Laravel get() vs first() methods