Isaac Earl

Important lessons to learn for publishing your own Laravel package

Sat, 19 Aug 2017 17:02:00 GMT

Over the last couple of years I’ve worked on several APIs, and during that time I’ve developed a set of tools that can be shared across multiple Laravel packages. One of these is a package which I lovingly called “Artisan API”. I recently posted this package up on Github for the world to use.

It’s a cool little package that gives you a friendly layer over Fractal so you can send out responses from your controller with things like this:

// respond with a collection
return $this->api->respondWithCollection($users, new UserTransformer());

// alot of simple helper functions for quick responses 
return $this->api->respondNotFound();

return $this->api->respondUnauthorized('Hey you can be here!');

return $this->api->respondOK();

// method chaining so you can send out custom responses

return $this->api
    ->setStatus(401)
    ->setResponseCode(ResponseCodes::UNAUTHORIZED)
    ->respondWithError('Not logged in');

It also came with a Facade if you like to do things that way instead

return API::respondWithItem($user, new UserTransformer());

it works with all the features of Fractal such as transformers and includes etc.

This is of course just a small glimpse of what can be done. For more information about fractal i suggest taking a look at http://fractal.thephpleague.com/ to get a better idea of all the capabilities.

Lesson 1: Project development workflow

I followed a fantastic guide here: https://medium.com/@tabacitu/creating-laravel-5-packages-for-dummies-ec6a4ded2e93, to help me understand a good development workflow. The best thing that I learned is that after you register your package with packagist.com (composer), you can still develop the package in your application after doing composer install by using the “–prefer-source” flag. If you do

composer install --prefer-source

This will install your dependencies so that when you navigate to the folder you can still use git and push changes to your package while using it! Makes it much easier then trying to develop the entire package separately.

Lesson 2: How to get the cool badges for your github package page

Most of the badges are very easy to get and use. They are simply a URL that you put in the readme file.

There is a terrific video tutorial here: https://egghead.io/lessons/javascript-how-to-write-a-javascript-library-adding-badges-to-your-readme To get you started on that.

My favorite badge for this project is the 100% code coverage badge. I used https://coveralls.io/ to get my badge. To get the code coverage recognized by coveralls I used this: https://github.com/satooshi/php-coveralls. It has relevant guides for travis-ci and many other automated build tools. What is great about coveralls is that it seems that is completely free for open source projects!

I wanted to make one important note about badges… It took many hours for my version badges to update. If you update the version of your package don’t be surprised if the badge shows the wrong version for a day. I made the mistake of trying to “fix” this issue that I thought I was having, but I realized eventually that I was just being impatient and the badge was cached.

Should I use this package? Probably not.

When I originally created it, there was not alot of great alternatives. It has served it’s purpose very well, and it will still be maintained as I have several projects which use the package.

BUT… I recently discovered Laravel Responder. A package which essentially does the same thing, except for it has some added bells and whistles for automatic includes on relations etc. It looks really fantastic and it has a decent following already and alot of interested users. This is good of course because it means it will most likely survive for a long time and continually improve over time.

TLDR

You can develop your package while using it in a project by using “composer install –prefer-dist”.
You can get badges by linking urls in your README.
Coveralls.io is cool because you can get the code coverage badge for free on open source projects
It takes forever for packagist to update your release version badges, so just be aware that they are cached and will eventually update.
Should you use this package? Nah, Laravel Responder is already a better and more mature option, however this package continues to serve me well on my older projects.

1 Day Laravel App twitchusernames.com

Sat, 05 Aug 2017 16:59:00 GMT

So a few months ago, Twitch.tv made a big announcement that they were going to start allowing username changes. You can find the announcement here: twitch.tv username change blog post

A big part of this announcement is that they were going to start releasing old and unused usernames, so that they could be claimed again.

“Inactive usernames will be recycled periodically and made available for new users in batches. Legacy justin.tv usernames will eventually be recycled as part of this process.” - Twitch.tv FAQ page

Twitch Username Checker

I was a bit bored at the time and I wanted a small project to do so I could learn a bit of VueJS. I decided to make an app that I could use to check the availability of usernames automatically and send notifications when names became available.

The result is here: https://twitchusernames.com

The concept is simple. Add a username, and the app emails you when it is available.

I set a goal for myself to make the app in a single day, so I sat down Saturday morning around 10 and worked on it throughout the day. At the end of the day I had something I was happy with. The biggest challenge was writing the frotnend VueJS stuff because it was my first time using it.

Over the next couple of days I pushed a few more updates to the site, but they were mainly small improvements etc, and nothing that I spent more then a combined 2 or 3 hours on. To be honest the code is still a bit crude, and I’m not necessarily extremely proud of the VueJS code (it should probably be refactored a bit), but the goal of the challenge was to create an app in a day, and focus on productivity rather then perfect code.

You can find the code here if you want to take a look: https://github.com/isaackearl/twitchnames

Learning Result

I really like Vue, and I’m going to be trying to learn more and become more proficient with it. My first attempt here I did as a SPA (single page application), but in the future I might create a view component or do something a bit more modular with my code.

On the backend I typically will create a service layer for all of my work, but since the API was very small and simple (4 endpoints) , I was able to just use Eloquent in the controller to get my work done without feeling to gross about it.

Learning Vietnamese Part 1 - Overcoming Roadblocks

Mon, 24 Jul 2017 17:02:00 GMT

For the past 10 years I’ve been wanting to learn Vietnamese. It was mainly a fleeting interest that would pop up occasionally, but I would never pursue it fully. Everytime I started to try, there were little things that would get in the way of fully investing myself… and I would give up! I believe that many of the roadblocks that I faced in my journey to START learning, are common roadblocks that can be avoided by others. So I wanted to make a post with my tips of how to successfully start learning!

Note: Skip to the bottom TLDR section if you don’t care about the backstory and just want to know about good learning resources etc for Vietnamese.

Why?

Why learn Vietnamese? Well for me it is because my in-laws are Vietnamese. My wife was born and raised in the USA, but speaks Vietnamese pretty well. Ever since I met her I’ve been interested in the culture, and the more I see of it the more I want to learn. I have this dream/vision of one day being able to talk with people in her family in Vietnam. Plus I need more hobbies!

Failed Attempts at learning

So for the past 10 years I would occassionaly “start” learning only to give up after about 2 days. My dad was very supportive of the idea and he even bought me Rosetta Stone as a gift one year. Typically I would say “I’m going to learn now for sure!” and I would start doing Rosetta Stone… then I would say a few of the words I was learning to my wife… and she never understood me! I would then try and say some things to my mother in law and she would just shake her head and explain that I’m not saying anything.

I would get very frustrated with my lack of progress and determine it was futile…

This happened several times. Always I would go back to Rosetta Stone because I figured it was the best way to learn, and always I wouldn’t learn anything useful or anything that my Vietnamese mother-in-law could understand. I decided it must be that my accent was just to bad.

What I realized (Vietnamese dialects)

This past year I finally went to Vietnam for the first time, and met alot of Linh’s extended family there. This gave me the boost in motivation that I needed to pursue learning more seriously.

When I finally forced myself to do some research about the Vietnamese language, I learned that there are several major dialects that are spoken in different regions of Vietnam. This ended up being the critical piece of understanding I needed in order to make a breakthrough in my learning.

So it ends up that my family speaks a Southern dialect of Vietnamese. Rosetta Stone teaches a very proper Northern dialect of Vietnamese that sounds quite a bit different… and even has it’s own words for many common things. Everytime I went to learn I would start learning the northern dialect, and my mother and wife couldn’t understand me. Typically people in the north and south of Vietnam don’t have that much trouble communicating… However with the different accent/dialect coupled with my own American accent, it made it really hard for my family to understand me when I spoke the words I was learning. This compounded my frustration and made it very easy to give up.

I think Rosetta Stone kinda sucks

So I had this EXPENSIVE resource Rosetta Stone that had already been paid for… and I was somewhat determined to use it. However I eventually realized that it wasn’t for me. It attempts to jump right into the language instead of teachings basics about grammer and pronunciation first. I think this is a big mistake because it left me with more questions then answers everytime I tried to study.

I started doing some research about learning languages in general… and I found resource after resource from personal blogs etc, of people talking about how Rosetta Stone doesn’t work very well. One of them asked the question “Have you ever heard of a fluent speaker of that learned from Rosetta Stone?”… I started searching for reviews, and realized that the answer is basically No. I can’t find many references to those who have actually learned a language through Rosetta Stone.

To top it off, Rosetta Stone strictly taught only the Northern dialect, which isn’t what I needed.

Finally finding the right resources

Once I realized my problem… the prospect of learning vietnamese became much easier AND much more difficult at the same time! Why? Because I soon learned that there are very few resources online for learning the Southern Dialect of Vietnamese. I spent a couple of weeks trying different tools/apps/websites etc, trying to find some good resources, and it was pretty difficult to find anything other then northern Vietnamese.

Eventually I found a few and found a learning approach that works for me. I paid for some of mine, but I also use some free resources. I will list them below because they might help someone else trying to do the same thing as me!

TLDR

There are many Vietnamese dialects and unfortunately most resources online for learning Vietnamese only teach the Northern dialect, even though the Southern dialect is very popular and spoken by more Vietnamese people living outside of Vietnam. Below are listed some of the resources for learning the Southern dialect that I have found that have been effective for me.

Free resources

The Learn vietnamese with annie youtube channel, has several playlists that can teach you the basics of pronunciation and so forth. They teach the Southern Dialect and are based out of Ho Chi Minh. Their website learnvietnamesewithannie.com has a ton of other free resources too like blog posts that explain important concepts etc.
Another great youtube channel/resource is Learn Vietnamese for foreigners. This channel is essential because they make new videos all the time of real world scenarios. They also speak mainly in the southern dialect, and they have great example videos that show the difference between northern and southern for various words/topics. I feel like listening to these videos helps my listening comprehension. They also have a website with more resources. I believe you can purchase lessons etc from them as well, however I cannot comment on this because I have yet to do so (but may in the future).
Duolingo is another great resource. It is a free app for your phone (or you can go there on your computer), that has a great vietnamese course. Unfortunately just like most other online resources, it focuses on the northern dialect, but I’ve found that it is still very useful for learning new vocabulary. Also in the app there is the ability to ask questions about every single word or phrase. I often find myself asking questions like “Is this phrase/word used in the southern dialect as well?” and I often get very good responses that help clear up my confusion.
https://forvo.com/ is an amazing website that has real recordings of people speaking nearly every language. There are thousands of recordings for Vietnamese words and phrases, and it is really nice to hear a native speaker say them, rather then always having to resort to the google translate. The only downside is that it doesn’t specify the dialect that a word is spoken in. Most of the recordings are in the northern dialect, but it is still a great tool for learning, and is especially useful once you’ve already learned to recognize north vs south accents.

Paid resources

Learn Vietnamese with Annie has alot of great PAID resources as well. I am a subscriber to their weekly podcast, which helps immensely with hearing comprehension and also helps introduce words into my vocabulary. They also have tutoring services where you can take a course online over skype (or in person if you happen to be in Ho Chi Minh). I’ve found the prices to be totally reasonable and well worth the price.
Udemy has some learning Vietnamese courses that are worth taking a look at… unfortunately they are very expensive. Occasionally Udemy offers massive discounts (80%-90%), and if that happens then it could be worth picking up this one: https://www.udemy.com/learn-to-speak-vietnamese-like-a-native/. I repeat this is only worth it if it goes on a big sale. I got it for $30 when it is usually listed for $195. This particular course was helpful becuase it is taught by a person who is not a native speaker and therefore learned the language later in life. He gives a unique perspective on pronouncing Vietnamese words coming from speaking English.

I can’t recommend any other paid services because I haven’t used any others ther then Rosetta Stone… which you can see from my words above I was not a big fan of. Duolingo has a similar methodolgy and product to Rosetta stone except for it’s totally free and funner to use.

Other Notes/Tips

You can type in vietnamese on Windows, Linux, or Mac by downloading Unikey. There is a different setup depending on your computer, however if you google “Setting up unikey for Mac” etc, then you can find good guides for getting your keyboard setup to do Vietnamese accents etc.

Conclusion

Learning Vietnamese is proving to be really fun and rewarding! I recommend taking the plunge to anybody who is on the fence about learning. I’ve found that I’m enjoying it much more as an adult then I ever did trying to learn a language in high school etc. Once I gain some proficiency I plan on choosing a new language to learn!

Stateless Social Authentication with Socialite

Mon, 24 Jul 2017 17:01:00 GMT

Update: An updated guide is available at vicamconsulting.com/blog/stateless-social-authentication-with-socialite.

A couple years ago I was working on a Laravel API that had social authentication features. I was using the laravel/socialite package to handle these authentication features, but ran into issues because our app was stateless. We were using JWT for handling authentication between our frontend client and our backend Laravel api, and therefore didn’t have need of sessions so we had stripped it all out. At the time there was no workaround for our issue, and it results in this pull request: https://github.com/laravel/socialite/pull/68

Nowadays this is a common usecase for the socialite package and you can find a reference to the stateless() method in the Socialite documentation here: https://github.com/laravel/socialite#stateless-authentication

Ever since that time, I have recieved messages asking me questions about how to implement this functionality into Laravel and Lumen apps. There are many applications where it might be useful to have stateless functionality with Socialite. I’m going to discuss that briefly.

Two common scenarios

APIs that don’t use session at all, and you still want to handle social authentication on the backend (Lumen etc).
You want to handle the redirect and athorization part of social authentication from your client application. For example maybe you are using Angular and you use a popular social authentication plugin like Satellizer. But maybe you still want to handle the Callback on your API side.

How it looks

Socialite makes social authentication crazy easy! I will post a few code samples below to show you what it looks like in action. For my examples I will be using Lumen and I will setup a generic endpoint that does social authentication using facebook. If you want to support multiple providers this can be easily done by passing in the provider name to your endpoint, but I’ll just be hardcoding ‘facebook’ in my examples.

Note: Please keep in mind that you will still need to implement an authenticaiton system to send to send a token to a client or something after you successfully authenticate using Socialite. The code samples below show the social authentication portion, but you will still need to implement JWT, Oauth (passport) or some other authentication method. If there is some interest I can add a guide for this as well.

/**
 * Redirect the user to the Facebook authentication page.
 *
 * @return Response
 */
public function redirectToProvider()
{
    return Socialite::driver('facebook')->stateless()->redirect();
}

The redirect method looks VERY simple. I think in many scenarios this method is optional. I’ve seen many implementations where the “redirect to provider” functionality is provided the front end client application. However I like to have my frontend client apps call this backend endpoint to start the authorization process. just don’t forget to include the “stateless()” function.

/**
 * Obtain the user information from Facebook.
 *
 * @return JsonResponse
 */
public function handleProviderCallback()
{
    // this user we get back is not our user model, but a special user object that has all the information we need
    $providerUser = Socialite::driver('facebook')->stateless()->user();

    // we have successfully authenticated via facebook at this point and can use the provider user to log us in.

    // for example we might do something like... Check if a user exists with the email and if so, log them in.
    $user = User::query()->firstOrNew(['email' => $providerUser->getEmail()]);

    // maybe we can set all the values on our user model if it is new... right now we only have name
    // but you could set other things like avatar or gender
    if (!$user->exists) {
        $user->name = $providerUser->getName();
        $user->save(); 
    }


    /**
     * At this point we done.  You can use whatever you are using for authentication here...
     * for example you might do something like this if you were using JWT
     */
      
    $token = JWTAuth::fromUser($user);
     
    return new JsonResponse([
        'token' => $token
    ]);
}

This is a very basic example and I have included some comments in my code sample to explain a few things. However the basic idea is this: When you configure your facebook integration, or integration with any other platform… you will have to setup a “callback url”. Which is basically just the endpoint it hits after you successfully authorize the app. In this method we can take the provider user that socialite gives us and we can build our real user and save the information down to our database. You can then use whatever authentication you like to create a token etc and send it back to the user.

We need the stateless functionality here because our app isn’t going to remember the state, and it is an optional parameter for oauth. It doesn’t matter what we used to authorize as long as the callback url hits this endpoint and we use the stateless method.

Resources and Conclusion

I’ve setup a repo withe a basic Lumen application and Socialite integration. You can find it here: https://github.com/isaackearl/socialite-lumen-demo. Let me know if you have questions or thoughts.

Setting up Laravel with Doctrine and Passport

Sun, 23 Jul 2017 17:02:00 GMT

Our goal will be to scaffold out a basic app that uses doctrine on the backend… and then get passport installed to handle authentication. This is a cool setup because then you have all you need to create an app that also has an api.

Doctrine

http://www.laraveldoctrine.org/. Laraveldoctrine is a full integration of Doctrine 2 for Laravel, that has great documentation and some really cool extra features and packages that make it something anybody who loves Laravel should take a look at. I wanted to make a guide featuring this package because I believe it is a great alternative to Eloquent with some nice advantages for large projects. It also suites my coding style a bit better. I will not be writing about the differences between Doctrine and Eloquent in this particular guide, but I will say that both are great database abstraction layers.

Passport

Passport is a great Laravel package that allows you to setup an oauth 2 server. https://github.com/laravel/passport

PART 1, Laravel + Doctrine + authentication

start a new Laravel project

laravel new doctrine-passport-demo

Setup your .env file to point to a new database you create etc… For my purposes I created a database called ‘demo’ (using mysql).

Doctrine setup prerequisites

Follow the steps here: http://www.laraveldoctrine.org/docs/1.3/orm/installation

And here: http://www.laraveldoctrine.org/docs/1.3/migrations/installation

And lastly we’ll need some of the extensions to make life easier: http://www.laraveldoctrine.org/docs/1.3/extensions/installation

install the laravel-doctrine/extensions package and the gedmo one. We don’t need the Beberlei extension.

Setup!

Our next goal is to get basic login/logout and registration functionality.

For this demo, I’m going to use Doctrine annotations, and I am going to create a User entity to use for logins, and I’m going to stick it into an Entity folder.

Setup a basic user entity that has 4 traits: Authenticatable, CanResetPassword, Notifiable and Timestamps. Make sure to use the Doctrine specific traits and interface etc. I’ll include my basic user here as an example

<?php

namespace App\Entities;

use Doctrine\ORM\Mapping as ORM;
use Illuminate\Auth\Passwords\CanResetPassword;
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
use Illuminate\Contracts\Auth\CanResetPassword as CanResetPasswordContract;
use LaravelDoctrine\ORM\Auth\Authenticatable;
use LaravelDoctrine\Extensions\Timestamps\Timestamps;
use LaravelDoctrine\ORM\Notifications\Notifiable;

/**
 * @ORM\Entity
 * @ORM\Table(name="users")
 */
class User implements AuthenticatableContract, CanResetPasswordContract
{

    use Authenticatable, CanResetPassword, Timestamps, Notifiable;

    /**
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="IDENTITY")
     * @ORM\Column(type="integer")
     */
    protected $id;

    /**
     * @var string
     * @ORM\Column(type="string")
     */
    protected $email;

    /**
     * @var string
     * @ORM\Column(type="string",nullable=false)
     */
    protected $name;

}

Configuration

in your doctrine.php file… (if you don’t have this you need publish the config files for doctrine)

fix the namespace and paths to point at where you put your Entities…

    'namespaces' => [
            'App\Entities'
    ],
    'paths' => [
            base_path('app/Entities')
    ],

Uncomment the Timestampable extension as well as another other you might want to use.

'extensions' => [
        //LaravelDoctrine\ORM\Extensions\TablePrefix\TablePrefixExtension::class,
        LaravelDoctrine\Extensions\Timestamps\TimestampableExtension::class,
        LaravelDoctrine\Extensions\SoftDeletes\SoftDeleteableExtension::class,
        //LaravelDoctrine\Extensions\Sluggable\SluggableExtension::class,
        //LaravelDoctrine\Extensions\Sortable\SortableExtension::class,
        //LaravelDoctrine\Extensions\Tree\TreeExtension::class,
        //LaravelDoctrine\Extensions\Loggable\LoggableExtension::class,
        //LaravelDoctrine\Extensions\Blameable\BlameableExtension::class,
        //LaravelDoctrine\Extensions\IpTraceable\IpTraceableExtension::class,
        //LaravelDoctrine\Extensions\Translatable\TranslatableExtension::class
],

Now go to your auth.php file

change the providers section to use your entity and the doctrine driver.

    'providers' => [
        'users' => [
            'driver' => 'doctrine',
            'model' => App\Entities\User::class,
        ],

        // 'users' => [
        //     'driver' => 'database',
        //     'table' => 'users',
        // ],
    ],

OK, so at this point in time your composer.json file should have these entries:

    "require": {
        "php": ">=5.6.4",
        "gedmo/doctrine-extensions": "^2.4", // we installed this
        "laravel-doctrine/extensions": "^1.0", // we installed this
        "laravel-doctrine/migrations": "^1.1", // we installed this
        "laravel-doctrine/orm": "^1.3", // we installed this
        "laravel/framework": "5.4.*",
        "laravel/tinker": "~1.0"
    },

And your app.php should have this stuff if you followed the setup guides etc listed above:

        LaravelDoctrine\ORM\DoctrineServiceProvider::class,
        LaravelDoctrine\Extensions\GedmoExtensionsServiceProvider::class,
        LaravelDoctrine\Migrations\MigrationsServiceProvider::class,

Finally, go ahead and replace the PasswordResetServiceProvider provided by Laravel, with the one provided by laravel-doctrine in the app.php file as well.

//        Illuminate\Auth\Passwords\PasswordResetServiceProvider::class,
        \LaravelDoctrine\ORM\Auth\Passwords\PasswordResetServiceProvider::class,

Using Laravel’s quick authentication setup

Now we are ready to scaffold out the authentication stuff. Run the make auth command:

php artisan make:auth

Go ahead and delete the 2 migrations that get created with this command in the migrations/ folder. After you delete them, then we’ll generate our own migration for our user entity.

php artisan doctrine:migrations:diff

then migrate it

php artisan doctrine:migrations:migrate

Note: you’ll notice we don’t create a migration or entity for the password_resets table. We don’t actually need one, Doctrine will magically create one when it tries to use it for the first time.

Now you just have to make a few more modificaitons to the generated controllers to gether everything to work. Go to the RegisterController and modify the validator function. You must use the unique rule slightly different with laravel doctrine.. you can find documentation for it here: http://www.laraveldoctrine.org/docs/1.3/orm/validation

It should look like this (change the reference to the users table to your User entity)

    protected function validator(array $data)
    {
        return Validator::make($data, [
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|max:255|unique:App\Entities\User',
            'password' => 'required|string|min:6|confirmed',
        ]);
    }

Change the create() function so it uses the new entity to create the user (you’ll have to create some getters/setters for your properties on the entity)

   protected function create(array $data)
    {

        $user = new User();
        $user->setEmail($data['email']);
        $user->setName($data['name']);
        $user->setPassword(bcrypt($data['password']));

        \EntityManager::persist($user);
        \EntityManager::flush();

        return $user;
    }

Then in the ResetPasswordController override the resetPassword function by adding this function to the controller:

    protected function resetPassword($user, $password)
    {
        $user->setPassword(bcrypt($password));
        $user->setRememberToken(Str::random(60));

        EntityManager::persist($user);
        EntityManager::flush();

        $this->guard()->login($user);
    }

Lastly… fix the app.blade.php file so it uses the getter for your name.

   <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-expanded="false">
           {{ Auth::user()->getName() }} <span class="caret"></span>
   </a>

Go ahead and test it, that should be it!

Part 2 Setting up Passport

Initial steps

install the composer package…

composer require laravel/passport

Add the service provider to app.php

Laravel\Passport\PassportServiceProvider::class,

open AppServiceProvder.php and add a line to ignore the migrations to the register function.

    public function register()
    {
        Passport::ignoreMigrations();
    }

Entities

Now we need to be able to generate all the proper tables for passport. I created Entities with annotations to represent the tables. Entities aren’t really needed since we won’t use them to actually manipulate the data, so you can create the tables/mappings some other way if you prefer. I will include the entities I created here:

OauthAccessToken

<?php

namespace App\Entities;

use Doctrine\ORM\Mapping as ORM;

/**
 * Class OauthAccessTokens
 * @package App\Entities
 * @ORM\Entity
 * @ORM\Table(name="oauth_access_tokens", indexes={@ORM\Index(name="user_id_token_index", columns={"user_id"})})
 */
class OauthAccessToken
{

    /**
     * @var string
     * @ORM\Id
     * @ORM\Column(type="string", length=100)
     */
    protected $id;

    /**
     * @var int
     * @ORM\Column(name="user_id", type="integer", nullable=true)
     */
    protected $userId;

    /**
     * @var int
     * @ORM\Column(name="client_id", type="integer")
     */
    protected $clientId;


    /**
     * @var string
     * @ORM\Column(type="string", nullable=true)
     */
    protected $name;

    /**
     * @var string
     * @ORM\Column(type="text", nullable=true)
     */
    protected $scopes;

    /**
     * @var boolean
     * @ORM\Column(type="boolean")
     */
    protected $revoked;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     */
    protected $createdAt;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     */
    protected $updatedAt;

    /**
     * @ORM\Column(name="expires_at", type="datetime", nullable=true)
     */
    protected $expiresAt;

}

OauthAuthCode

<?php

namespace App\Entities;


use Doctrine\ORM\Mapping as ORM;

/**
 *
 *
 * Class OauthAuthCode
 * @package App\Entities
 * @ORM\Entity
 * @ORM\Table(name="oauth_auth_codes")
 */
class OauthAuthCode
{

    /**
     * @var string
     * @ORM\Id
     * @ORM\Column(type="string", length=100)
     */
    protected $id;

    /**
     * @var int
     * @ORM\Column(name="user_id", type="integer")
     */
    protected $userId;

    /**
     * @var int
     * @ORM\Column(name="client_id", type="integer")
     */
    protected $clientId;

    /**
     * @var string
     * @ORM\Column(type="text", nullable=true)
     */
    protected $scopes;

    /**
     * @var boolean
     * @ORM\Column(type="boolean")
     */
    protected $revoked;

    /**
     * @ORM\Column(name="expires_at", type="datetime", nullable=true)
     */
    protected $expiresAt;

}

OauthClients

<?php

namespace App\Entities;


use Doctrine\ORM\Mapping as ORM;
use Gedmo\Timestampable\Traits\Timestampable;

/**
 * OauthClients
 * @package App\Entities
 * @ORM\Entity
 * @ORM\Table(name="oauth_clients", indexes={@ORM\Index(name="user_id_client_index", columns={"user_id"})})
 */
class OauthClients
{

    /**
     * @var int
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="IDENTITY")
     * @ORM\Column(type="integer")
     */
    protected $id;

    /**
     * @var int
     * @ORM\Column(name="user_id", type="integer", nullable=true)
     */
    protected $userId;

    /**
     * @var string
     * @ORM\Column(type="string")
     */
    protected $name;

    /**
     * @var string
     * @ORM\Column(name="secret", type="string", length=100)
     */
    protected $secret;

    /**
     * @var string
     * @ORM\Column(type="text")
     */
    protected $redirect;

    /**
     * @var boolean
     * @ORM\Column(name="personal_access_client", type="boolean")
     */
    protected $personalAccessClient;

    /**
     * @var boolean
     * @ORM\Column(name="password_client", type="boolean")
     */
    protected $passwordClient;

    /**
     * @var boolean
     * @ORM\Column(type="boolean")
     */
    protected $revoked;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     */
    protected $createdAt;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     */
    protected $updatedAt;
}

OauthPersonalAccessClient

<?php

namespace App\Entities;


use Doctrine\ORM\Mapping as ORM;

/**
 * Class OauthPersonalAccessClient
 * @package App\Entities
 * @ORM\Entity
 * @ORM\Table(name="oauth_personal_access_clients", indexes={@ORM\Index(name="client_id_index", columns={"client_id"})})
 */
class OauthPersonalAccessClient
{

    /**
     * @var int
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="IDENTITY")
     * @ORM\Column(type="integer")
     */
    protected $id;

    /**
     * @var int
     * @ORM\Column(name="client_id", type="integer")
     */
    protected $clientId;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     */
    protected $createdAt;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     */
    protected $updatedAt;
}

OauthRefreshToken

<?php

namespace App\Entities;


use Doctrine\ORM\Mapping as ORM;

/**
 * OauthRefreshToken
 * @package App\Entities
 * @ORM\Entity
 * @ORM\Table(name="oauth_refresh_tokens", indexes={@ORM\Index(name="access_token_index", columns={"access_token_id"})})
 */
class OauthRefreshToken
{

    /**
     * @var string
     * @ORM\Id
     * @ORM\Column(type="string", length=100)
     */
    protected $id;

    /**
     * @var int
     * @ORM\Column(name="access_token_id", type="string", length=100)
     */
    protected $accessTokenId;

    /**
     * @var boolean
     * @ORM\Column(type="boolean")
     */
    protected $revoked;

    /**
     * @ORM\Column(name="expires_at", type="datetime", nullable=true)
     */
    protected $expiresAt;

}

You can then run the diff command to generate a migration. It should create something like this:

    /**
     * @param Schema $schema
     */
    public function up(Schema $schema)
    {
        $this->abortIf($this->connection->getDatabasePlatform()->getName() != 'mysql', 'Migration can only be executed safely on \'mysql\'.');

        $this->addSql('CREATE TABLE oauth_access_tokens (id VARCHAR(100) NOT NULL, user_id INT DEFAULT NULL, client_id INT NOT NULL, name VARCHAR(255) DEFAULT NULL, scopes LONGTEXT DEFAULT NULL, revoked TINYINT(1) NOT NULL, created_at DATETIME DEFAULT NULL, updated_at DATETIME DEFAULT NULL, expires_at DATETIME DEFAULT NULL, INDEX user_id_token_index (user_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = InnoDB');
        $this->addSql('CREATE TABLE oauth_auth_codes (id VARCHAR(100) NOT NULL, user_id INT NOT NULL, client_id INT NOT NULL, scopes LONGTEXT DEFAULT NULL, revoked TINYINT(1) NOT NULL, expires_at DATETIME DEFAULT NULL, PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = InnoDB');
        $this->addSql('CREATE TABLE oauth_clients (id INT AUTO_INCREMENT NOT NULL, user_id INT DEFAULT NULL, name VARCHAR(255) NOT NULL, secret VARCHAR(100) NOT NULL, redirect LONGTEXT NOT NULL, personal_access_client TINYINT(1) NOT NULL, password_client TINYINT(1) NOT NULL, revoked TINYINT(1) NOT NULL, created_at DATETIME DEFAULT NULL, updated_at DATETIME DEFAULT NULL, INDEX user_id_client_index (user_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = InnoDB');
        $this->addSql('CREATE TABLE oauth_personal_access_clients (id INT AUTO_INCREMENT NOT NULL, client_id INT NOT NULL, created_at DATETIME DEFAULT NULL, updated_at DATETIME DEFAULT NULL, INDEX client_id_index (client_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = InnoDB');
        $this->addSql('CREATE TABLE oauth_refresh_tokens (id VARCHAR(100) NOT NULL, access_token_id VARCHAR(100) NOT NULL, revoked TINYINT(1) NOT NULL, expires_at DATETIME DEFAULT NULL, INDEX access_token_index (access_token_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = InnoDB');
    }

    /**
     * @param Schema $schema
     */
    public function down(Schema $schema)
    {
        $this->abortIf($this->connection->getDatabasePlatform()->getName() != 'mysql', 'Migration can only be executed safely on \'mysql\'.');

        $this->addSql('DROP TABLE oauth_access_tokens');
        $this->addSql('DROP TABLE oauth_auth_codes');
        $this->addSql('DROP TABLE oauth_clients');
        $this->addSql('DROP TABLE oauth_personal_access_clients');
        $this->addSql('DROP TABLE oauth_refresh_tokens');
    }

Run the migration…

Run the passport install command

php artisan passport:install

Add the HasApiTokens trait to your user entity. It should now look something like this:

class User implements AuthenticatableContract, CanResetPasswordContract
{

    use Authenticatable, CanResetPassword, Timestamps, Notifiable, HasApiTokens;

Call the passport routes from your AuthServiceProvider in the boot method

    public function boot()
    {
        $this->registerPolicies();

        Passport::routes();
    }

Configuration

Next go to the auth.php file and setup the configuration to use passport.

    'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],

        'api' => [
            'driver' => 'passport',
            'provider' => 'users',
        ],
    ],

Frontend

publish the built in frontend pages

php artisan vendor:publish --tag=passport-components

The published components will be placed in your resources/assets/js/components directory. Once the components have been published, you should register them in your resources/assets/js/app.js file (I replace the example vue component):

Vue.component(
    'passport-clients',
    require('./components/passport/Clients.vue')
);

Vue.component(
    'passport-authorized-clients',
    require('./components/passport/AuthorizedClients.vue')
);

Vue.component(
    'passport-personal-access-tokens',
    require('./components/passport/PersonalAccessTokens.vue')
);

Run npm install in your project directory

npm install

Then recompile your assets by running

npm run dev

Now edit your home.blade.php file and replace “You are now logged in!” with the vue components

@extends('layouts.app')

@section('content')
<div class="container">
    <div class="row">
        <div class="col-md-8 col-md-offset-2">
            <div class="panel panel-default">
                <div class="panel-heading">Dashboard</div>

                <div class="panel-body">
                    <passport-clients></passport-clients>
                    <passport-authorized-clients></passport-authorized-clients>
                    <passport-personal-access-tokens></passport-personal-access-tokens>                </div>
            </div>
        </div>
    </div>
</div>
@endsection

Making it work!

If you were to try it now, things will still break because passport won’t work straight out of the box with Doctrine… so there are still a few things to do.

add a getKey method on your user entity

   public function getKey() {
        return $this->getId();
    }

Last but not least… fix the API method they have for you to test in api.php so it returns something we can actually get…

Route::middleware('auth:api')->get('/user', function (Request $request) {
    return $request->user()->getName();
});

BOOM! it should all work now.

I used Postman to test my oauth2 setup

successful get request to API endpoint

Note: If you want to get password grants to work there is a bit of additional setup. Add a trait that looks like this to your user entity and you should be good to go:

trait UsesPasswordGrant
{

    /**
     * @param string $userIdentifier
     * @return User
     */
    public function findForPassport($userIdentifier)
    {
        $userRepository = EntityManager::getRepository(get_class($this));
        return $userRepository->findOneByEmail($userIdentifier);
    }

}

So that is essentially it… I tried to be as detailed as possible. If you have any questions let me know below and I might be able to help. You can download this demo project at https://github.com/isaackearl/doctrine-passport-demo if you want to skip the setup!