Laravel - Armazenamento de sessão não definido a pedido

Recentemente criei um novo projeto Laravel e estava seguindo o guia de Autenticação. Quando visito minha rota de login ou registro, recebo o seguinte erro:

ErrorException in Request.php line 775:
Session store not set on request. (View: C:\Users\Matthew\Documents\test\resources\views\auth\register.blade.php)

Eu não editei nenhum arquivo principal do Laravel, apenas criei as visualizações e adicionei as rotas ao meu arquivo routes.php

// Authentication routes
Route::get('auth/login', ['uses' => 'Auth\AuthController@getLogin', 'as' => 'login']);
Route::post('auth/login', ['uses' => 'Auth\AuthController@postLogin', 'as' => 'login']);
Route::get('auth/logout', ['uses' => 'Auth\AuthController@getLogout', 'as' => 'logout']);

// Registration routes
Route::get('auth/register', ['uses' => 'Auth\AuthController@getRegister', 'as' => 'register']);
Route::post('auth/register', ['uses' => 'Auth\AuthController@postRegister', 'as' => 'login']);

Não tenho muita experiência com o Laravel, então desculpe minha ignorância. Estou ciente de que há outra pergunta fazendo a mesma coisa, mas nenhuma das respostas parece funcionar para mim. Obrigado por ler!

Editar:

Aqui está meu register.blade.php conforme solicitado.

@extends('partials.main')

@section('title', 'Test | Register')

@section('content')
    <form method="POST" action="/auth/register">
        {!! csrf_field() !!}
        <div class="ui input">
          <input type="text" name="name" value="{{ old('name') }}" placeholder="Username">
        </div>
        <div class="ui input">
          <input type="email" name="email" value="{{ old('email') }}" placeholder="Email">
        </div>
        <div class="ui input">
          <input type="password" name="password" placeholder="Password">
        </div>
        <div class="ui input">
          <input type="password" name="password_confirmation"placeholder="Confirm Password">
        </div>
        <div>
            <button class="ui primary button" type="submit">Register</button>
        </div>
    </form>
@endsection

Você precisará usar o middleware da web se precisar de estado de sessão, proteção CSRF e muito mais.

Route::group(['middleware' => ['web']], function () {
    // your routes here
});

Se adicionar o seu routesdentro do web middlewarenão trabalho por qualquer motivo, em seguida, tente adicionar isso $middlewareemKernel.php

protected $middleware = [
        //...
        \Illuminate\Session\Middleware\StartSession::class,
        \Illuminate\View\Middleware\ShareErrorsFromSession::class,
];

No meu caso (usando o Laravel 5.3) adicionar apenas os 2 seguintes middleware me permitiu acessar os dados da sessão em minhas rotas de API:

• \App\Http\Middleware\EncryptCookies::class
• \Illuminate\Session\Middleware\StartSession::class

Declaração completa ( $middlewareGroupsem Kernel.php):

'api' => [
            \App\Http\Middleware\EncryptCookies::class,
            \Illuminate\Session\Middleware\StartSession::class,
            'throttle:60,1',
            'bindings',
        ],

Se a resposta de Cas Bloem não se aplica (ou seja, você definitivamente tem o webmiddleware na rota aplicável), você pode querer verificar a ordem dos middlewares em seu kernel HTTP.

A ordem padrão Kernel.phpé esta:

$middlewareGroups = [
    'web' => [
        \App\Http\Middleware\EncryptCookies::class,
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        \Illuminate\View\Middleware\ShareErrorsFromSession::class,
        \App\Http\Middleware\VerifyCsrfToken::class,
    ],
];

Observe que VerifyCsrfTokenvem depois StartSession. Se você os tiver em uma ordem diferente, a dependência entre eles também pode levar à Session store not set on request.exceção.

Um problema pode ser que você tente acessar sua sessão dentro da __constructor()função de seu controlador .

A partir do Laravel 5.3+, isso não é mais possível porque não foi projetado para funcionar de qualquer maneira, conforme declarado no guia de atualização .

Nas versões anteriores do Laravel, você podia acessar variáveis ​​de sessão ou o usuário autenticado no construtor de seu controlador. Isso nunca teve a intenção de ser uma característica explícita da estrutura. No Laravel 5.3, você não pode acessar a sessão ou usuário autenticado no construtor do seu controlador porque o middleware ainda não rodou.

Para obter mais informações básicas, leia também a resposta de Taylor .

Gambiarra

Se ainda quiser usar isso, você pode criar dinamicamente um middleware e executá-lo no construtor, conforme descrito no guia de upgrade:

Como alternativa, você pode definir um middleware baseado em Closure diretamente no construtor de seu controlador. Antes de usar este recurso, certifique-se de que seu aplicativo está executando o Laravel 5.3.4 ou superior:

<?php

namespace App\Http\Controllers;

use App\User;
use Illuminate\Support\Facades\Auth;
use App\Http\Controllers\Controller;

class ProjectController extends Controller
{
    /**
     * All of the current user's projects.
     */
    protected $projects;

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware(function ($request, $next) {
            $this->projects = Auth::user()->projects;

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

Laravel [5.4]

Minha solução foi usar o helper de sessão global: session ()

Sua funcionalidade é um pouco mais difícil do que $ request-> session () .

escrevendo :

session(['key'=>'value']);

empurrando :

session()->push('key', $notification);

recuperando :

session('key');

No meu caso, adicionei as seguintes 4 linhas a $ middlewareGroups (em app / Http / Kernel.php):

'api' => [
    \App\Http\Middleware\EncryptCookies::class,
    \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
    \Illuminate\Session\Middleware\StartSession::class,
    \App\Http\Middleware\VerifyCsrfToken::class,
    'throttle:60,1',
    'bindings',
],

IMPORTANTE: As 4 novas linhas devem ser adicionadas ANTES de 'throttle' e 'bindings'!

Caso contrário, aparecerá um erro "token CSRF não correspondente". Lutei nisso por várias horas só para descobrir que a ordem é importante.

Isso me permitiu acessar a sessão em minha API. Também adicionei VerifyCsrfToken, pois quando cookies / sessões estão envolvidos, CSRF precisa ser cuidado.

Você pode usar ->stateless()antes do ->redirect(). Então você não precisa mais da sessão.

no meu caso era só colocar retorno; no final da função onde eu configurei a sessão

Se você estiver usando CSRF, digite 'before'=>'csrf'

No seu caso Route::get('auth/login', ['before'=>'csrf','uses' => 'Auth\AuthController@getLogin', 'as' => 'login']);

Para mais detalhes veja Laravel 5 Documentação Segurança Protegendo Rotas

Não está na documentação do laravel, levei uma hora para conseguir isso:

Minha sessão não persistiu até que usei o método "salvar" ...

$request->session()->put('lang','en_EN');
$request->session()->save();

O grupo de middleware da web do Laravel 5.3+ é automaticamente aplicado ao seu arquivo routes / web.php pelo RouteServiceProvider.

A menos que você modifique o array $ middlewareGroups do kernel em uma ordem não suportada, provavelmente você está tentando injetar solicitações como uma dependência regular do construtor.

Use a solicitação como

public function show(Request $request){

}

ao invés de

public function __construct(Request $request){

}

Eu estava recebendo este erro com o Laravel Sanctum. Corrigi isso adicionando \Illuminate\Session\Middleware\StartSession::class,ao apigrupo de middleware em Kernel.php, mas depois descobri que isso "funcionou" porque minhas rotas de autenticação foram adicionadas ao api.phpinvés de web.php, então o Laravel estava usando o protetor de autenticação errado.

Mudei essas rotas aqui para web.phpe então elas começaram a funcionar corretamente com a AuthenticatesUsers.phpcaracterística:

Route::group(['middleware' => ['guest', 'throttle:10,5']], function () {
    Route::post('register', 'Auth\RegisterController@register')->name('register');
    Route::post('login', 'Auth\LoginController@login')->name('login');

    Route::post('password/email', 'Auth\ForgotPasswordController@sendResetLinkEmail');
    Route::post('password/reset', 'Auth\ResetPasswordController@reset');

    Route::post('email/verify/{user}', 'Auth\VerificationController@verify')->name('verification.verify');
    Route::post('email/resend', 'Auth\VerificationController@resend');

    Route::post('oauth/{driver}', 'Auth\OAuthController@redirectToProvider')->name('oauth.redirect');
    Route::get('oauth/{driver}/callback', 'Auth\OAuthController@handleProviderCallback')->name('oauth.callback');
});

Route::post('logout', 'Auth\LoginController@logout')->name('logout');

Eu descobri o problema depois de receber outro erro estranho sobre RequestGuard::logout()não existe.

Isso me fez perceber que minhas rotas de autenticação personalizadas são métodos de chamada do traço AuthenticatesUsers, mas eu não estava usando Auth::routes()para fazer isso. Então percebi que o Laravel usa o web guard por padrão e isso significa que as rotas devem estar ativadas routes/web.php.

É assim que minhas configurações parecem agora com Sanctum e um aplicativo Vue SPA desacoplado:

Kernel.php

protected $middlewareGroups = [
    'web' => [
        \App\Http\Middleware\EncryptCookies::class,
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        // \Illuminate\Session\Middleware\AuthenticateSession::class,
        \Illuminate\View\Middleware\ShareErrorsFromSession::class,
        \App\Http\Middleware\VerifyCsrfToken::class,
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],

    'api' => [
        EnsureFrontendRequestsAreStateful::class,
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
        'throttle:60,1',
    ],
];

Nota: Com o Laravel Sanctum e Vue SPA de mesmo domínio, você usa cookies httpOnly para cookie de sessão e cookie de lembrar-me, e cookie inseguro para CSRF, então você usa a webproteção para autenticação e todas as outras rotas de retorno JSON protegidas devem usar auth:sanctummiddleware.

config / auth.php

'defaults' => [
    'guard' => 'web',
    'passwords' => 'users',
],

...

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

    'api' => [
        'driver' => 'token',
        'provider' => 'users',
        'hash' => false,
    ],
],

Então você pode ter testes de unidade como esta, onde criticamente, Auth::check(), Auth::user(), e Auth::logout()funcionam como esperado com configuração mínima e uso máximo de AuthenticatesUserse RegistersUserstraços.

Aqui estão alguns dos meus testes de unidade de login:

TestCase.php

/**
 * Creates and/or returns the designated regular user for unit testing
 *
 * @return \App\User
 */
public function user() : User
{
    $user = User::query()->firstWhere('email', 'test-user@example.com');

    if ($user) {
        return $user;
    }

    // User::generate() is just a wrapper around User::create()
    $user = User::generate('Test User', 'test-user@example.com', self::AUTH_PASSWORD);

    return $user;
}

/**
 * Resets AuthManager state by logging out the user from all auth guards.
 * This is used between unit tests to wipe cached auth state.
 *
 * @param array $guards
 * @return void
 */
protected function resetAuth(array $guards = null) : void
{
    $guards = $guards ?: array_keys(config('auth.guards'));

    foreach ($guards as $guard) {
        $guard = $this->app['auth']->guard($guard);

        if ($guard instanceof SessionGuard) {
            $guard->logout();
        }
    }

    $protectedProperty = new \ReflectionProperty($this->app['auth'], 'guards');
    $protectedProperty->setAccessible(true);
    $protectedProperty->setValue($this->app['auth'], []);
}

LoginTest.php

protected $auth_guard = 'web';

/** @test */
public function it_can_login()
{
    $user = $this->user();

    $this->postJson(route('login'), ['email' => $user->email, 'password' => TestCase::AUTH_PASSWORD])
        ->assertStatus(200)
        ->assertJsonStructure([
            'user' => [
                ...expectedUserFields,
            ],
        ]);

    $this->assertEquals(Auth::check(), true);
    $this->assertEquals(Auth::user()->email, $user->email);
    $this->assertAuthenticated($this->auth_guard);
    $this->assertAuthenticatedAs($user, $this->auth_guard);

    $this->resetAuth();
}

/** @test */
public function it_can_logout()
{
    $this->actingAs($this->user())
        ->postJson(route('logout'))
        ->assertStatus(204);

    $this->assertGuest($this->auth_guard);

    $this->resetAuth();
}

Eu substituí os métodos registerede authenticatednas características de autenticação do Laravel para que eles retornem o objeto do usuário em vez de apenas as 204 OPÇÕES:

public function authenticated(Request $request, User $user)
{
    return response()->json([
        'user' => $user,
    ]);
}

protected function registered(Request $request, User $user)
{
    return response()->json([
        'user' => $user,
    ]);
}

Observe o código do fornecedor para as características de autenticação. Você pode usá-los intactos, além dos dois métodos acima.

• vendor / laravel / ui / auth-backend / RegistersUsers.php
• vendor / laravel / ui / auth-backend / AuthenticatesUsers.php

Aqui estão as ações do Vuex do Vue SPA para login:

async login({ commit }, credentials) {
    try {
        const { data } = await axios.post(route('login'), {
            ...credentials,
            remember: credentials.remember || undefined,
        });

        commit(FETCH_USER_SUCCESS, { user: data.user });
        commit(LOGIN);

        return commit(CLEAR_INTENDED_URL);
    } catch (err) {
        commit(LOGOUT);
        throw new Error(`auth/login# Problem logging user in: ${err}.`);
    }
},

async logout({ commit }) {
    try {
        await axios.post(route('logout'));

        return commit(LOGOUT);
    } catch (err) {
        commit(LOGOUT);

        throw new Error(`auth/logout# Problem logging user out: ${err}.`);
    }
},

Levei mais de uma semana para fazer com que os testes de unidade Laravel Sanctum + Vue SPA + auth de mesmo domínio funcionassem de acordo com o meu padrão, então espero que minha resposta aqui possa ajudar outros a economizar tempo no futuro.