@adonisjs/auth 8.0.12 → 8.2.1

package/build/adonis-typings/auth.d.ts

@@ -230,6 +230,28 @@ declare module '@ioc:Adonis/Addons/Auth' {
             default: DatabaseProviderUserBuilder;
         }>;
     };
+    /**
+     * Request data a guard client can set when making the
+     * testing request
+     */
+    export type ClientRequestData = {
+        session?: Record<string, any>;
+        headers?: Record<string, any>;
+        cookies?: Record<string, any>;
+    };
+    /**
+     * The authentication clients should follow this interface
+     */
+    export interface GuardClientContract<Provider extends keyof ProvidersList> {
+        /**
+         * Login a user
+         */
+        login(user: GetProviderRealUser<Provider>, ...args: any[]): Promise<ClientRequestData>;
+        /**
+         * Logout user
+         */
+        logout(user: GetProviderRealUser<Provider>): Promise<void>;
+    }
     export interface GuardContract<Provider extends keyof ProvidersList, Guard extends keyof GuardsList> {
         name: Guard;
         /**
@@ -345,6 +367,11 @@ declare module '@ioc:Adonis/Addons/Auth' {
          */
         logout(renewRememberToken?: boolean): Promise<void>;
     }
+    /**
+     * Session client to login users during tests
+     */
+    export interface SessionClientContract<Provider extends keyof ProvidersList> extends GuardClientContract<Provider> {
+    }
     /**
      * Shape of session driver config.
      */
@@ -365,6 +392,11 @@ declare module '@ioc:Adonis/Addons/Auth' {
      */
     export interface BasicAuthGuardContract<Provider extends keyof ProvidersList, Name extends keyof GuardsList> extends Omit<GuardContract<Provider, Name>, 'attempt' | 'login' | 'loginViaId' | 'logout'> {
     }
+    /**
+     * Basic auth client to login users during tests
+     */
+    export interface BasicAuthClientContract<Provider extends keyof ProvidersList> extends GuardClientContract<Provider> {
+    }
     /**
      * Shape of basic auth guard config.
      */
@@ -473,6 +505,12 @@ declare module '@ioc:Adonis/Addons/Auth' {
          */
         loginViaId(id: string | number, options?: OATLoginOptions): Promise<OpaqueTokenContract<GetProviderRealUser<Provider>>>;
     }
+    /**
+     * Oat guard to login users during tests
+     */
+    export interface OATClientContract<Provider extends keyof ProvidersList> extends GuardClientContract<Provider> {
+        login(user: GetProviderRealUser<Provider>, options?: OATLoginOptions): Promise<ClientRequestData>;
+    }
     /**
      * Shape of OAT guard config.
      */
@@ -517,6 +555,7 @@ declare module '@ioc:Adonis/Addons/Auth' {
      * session: {
      *   config: SessionGuardConfig<'lucid'>,
      *   implementation: SessionGuardContract<'lucid'>,
+     *   client: SessionClientContract<'lucid'>,
      * }
      *
      */
@@ -555,6 +594,11 @@ declare module '@ioc:Adonis/Addons/Auth' {
      * Shape of the callback accepted to add new guards
      */
     export type ExtendGuardCallback = (auth: AuthManagerContract, mapping: string, config: any, provider: UserProviderContract<any>, ctx: HttpContextContract) => GuardContract<keyof ProvidersList, keyof GuardsList>;
+    /**
+     * Shape of the callback accepted to add custom testing
+     * clients
+     */
+    export type ExtendClientCallback = (auth: AuthManagerContract, mapping: string, config: any, provider: UserProviderContract<any>) => GuardClientContract<keyof ProvidersList>;
     /**
      * Shape of the auth manager to register custom drivers and providers and
      * make instances of them
@@ -575,10 +619,16 @@ declare module '@ioc:Adonis/Addons/Auth' {
         makeMapping(ctx: HttpContextContract, mapping: string): GuardContract<keyof ProvidersList, keyof GuardsList>;
         makeMapping<K extends keyof GuardsList>(ctx: HttpContextContract, mapping: K): GuardsList[K]['implementation'];
         /**
-         * Extend by adding custom providers and guards
+         * Returns an instance of the auth client for a given
+         * mapping
+         */
+        client(mapping: string): GuardClientContract<keyof ProvidersList>;
+        /**
+         * Extend by adding custom providers, guards and client
          */
         extend(type: 'provider', provider: string, callback: ExtendProviderCallback): void;
         extend(type: 'guard', guard: string, callback: ExtendGuardCallback): void;
+        extend(type: 'client', guard: string, callback: ExtendClientCallback): void;
     }
     const AuthManager: AuthManagerContract;
     export default AuthManager;

package/build/adonis-typings/index.d.ts

@@ -2,3 +2,4 @@
 /// <reference path="context.d.ts" />
 /// <reference path="events.d.ts" />
 /// <reference path="container.d.ts" />
+/// <reference path="tests.d.ts" />

package/build/adonis-typings/index.js

@@ -10,3 +10,4 @@
 /// <reference path="./context.ts" />
 /// <reference path="./events.ts" />
 /// <reference path="./container.ts" />
+/// <reference path="./tests.ts" />

package/build/adonis-typings/tests.d.ts

@@ -0,0 +1,23 @@
+import '@japa/api-client';
+import { GuardsList, ProvidersList, AuthManagerContract, GetProviderRealUser } from '@ioc:Adonis/Addons/Auth';
+declare module '@japa/api-client' {
+    interface ApiRequest {
+        /**
+         * Auth manager reference
+         */
+        authManager: AuthManagerContract;
+        /**
+         * Switch guard to login during the request
+         */
+        guard<K extends keyof GuardsList, Self>(this: Self, guard: K): {
+            /**
+             * Login as a user
+             */
+            loginAs(...args: Parameters<GuardsList[K]['client']['login']>): Self;
+        };
+        /**
+         * Login as a user
+         */
+        loginAs(user: GetProviderRealUser<keyof ProvidersList>): this;
+    }
+}

package/build/adonis-typings/tests.js

@@ -0,0 +1,11 @@
+"use strict";
+/*
+ * @adonisjs/auth
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@japa/api-client");

package/build/providers/AuthProvider.d.ts

@@ -11,6 +11,18 @@ export default class AuthProvider {
      * Register auth binding
      */
     register(): void;
+    /**
+     * Sharing the auth object with HTTP context
+     */
+    protected registerAuthWithHttpContext(): void;
+    /**
+     * Sharing auth with all the templates
+     */
+    protected shareAuthWithViews(): void;
+    /**
+     * Register test bindings
+     */
+    protected registerTestBindings(): void;
     /**
      * Hook into boot to register auth macro
      */

package/build/providers/AuthProvider.js

@@ -28,20 +28,42 @@ class AuthProvider {
         });
     }
     /**
-     * Hook into boot to register auth macro
+     * Sharing the auth object with HTTP context
      */
-    async boot() {
+    registerAuthWithHttpContext() {
         this.application.container.withBindings(['Adonis/Core/HttpContext', 'Adonis/Addons/Auth'], (HttpContext, Auth) => {
             HttpContext.getter('auth', function auth() {
                 return Auth.getAuthForRequest(this);
             }, true);
         });
+    }
+    /**
+     * Sharing auth with all the templates
+     */
+    shareAuthWithViews() {
         this.application.container.withBindings(['Adonis/Core/Server', 'Adonis/Core/View'], (Server) => {
             Server.hooks.before(async (ctx) => {
                 ctx['view'].share({ auth: ctx.auth });
             });
         });
     }
+    /**
+     * Register test bindings
+     */
+    registerTestBindings() {
+        this.application.container.withBindings(['Japa/Preset/ApiRequest', 'Japa/Preset/ApiClient', 'Adonis/Addons/Auth'], (ApiRequest, ApiClient, Auth) => {
+            const { defineTestsBindings } = require('../src/Bindings/Tests');
+            return defineTestsBindings(ApiRequest, ApiClient, Auth);
+        });
+    }
+    /**
+     * Hook into boot to register auth macro
+     */
+    async boot() {
+        this.registerAuthWithHttpContext();
+        this.shareAuthWithViews();
+        this.registerTestBindings();
+    }
 }
 exports.default = AuthProvider;
 AuthProvider.needsApplication = true;

package/build/src/AuthManager/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="@adonisjs/application/build/adonis-typings/application" />
-import { AuthConfig, GuardsList, AuthManagerContract, ExtendGuardCallback, UserProviderContract, ExtendProviderCallback } from '@ioc:Adonis/Addons/Auth';
+import { AuthConfig, GuardsList, AuthManagerContract, ExtendGuardCallback, ExtendProviderCallback, ExtendClientCallback } from '@ioc:Adonis/Addons/Auth';
 import { ApplicationContract } from '@ioc:Adonis/Core/Application';
 import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
 /**
@@ -9,6 +9,10 @@ import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
 export declare class AuthManager implements AuthManagerContract {
     application: ApplicationContract;
     private config;
+    /**
+     * Extended set of testing clients
+     */
+    private extendedClients;
     /**
      * Extended set of providers
      */
@@ -62,23 +66,44 @@ export declare class AuthManager implements AuthManagerContract {
      * Returns an instance of the extended guard
      */
     private makeExtendedGuard;
+    /**
+     * Returns an instance of the session client
+     */
+    private makeSessionClient;
+    /**
+     * Returns an instance of the session client
+     */
+    private makeOatClient;
+    /**
+     * Returns an instance of the extended client
+     */
+    private makeExtendedClient;
+    /**
+     * Makes client instance for the defined driver inside the
+     * mapping config.
+     */
+    private makeClientInstance;
     /**
      * Makes instance of a provider based upon the driver value
      */
-    makeUserProviderInstance(mapping: string, providerConfig: any): any;
+    private makeUserProviderInstance;
     /**
      * Makes instance of a provider based upon the driver value
      */
-    makeTokenProviderInstance(providerConfig: any): any;
+    private makeTokenProviderInstance;
     /**
      * Makes guard instance for the defined driver inside the
      * mapping config.
      */
-    makeGuardInstance(mapping: string, mappingConfig: any, provider: UserProviderContract<any>, ctx: HttpContextContract): any;
+    private makeGuardInstance;
     /**
      * Make an instance of a given mapping for the current HTTP request.
      */
     makeMapping(ctx: HttpContextContract, mapping: keyof GuardsList): any;
+    /**
+     * Returns an instance of the testing
+     */
+    client(mapping: keyof GuardsList): any;
     /**
      * Returns an instance of the auth class for the current request
      */
@@ -88,4 +113,5 @@ export declare class AuthManager implements AuthManagerContract {
      */
     extend(type: 'provider', name: string, callback: ExtendProviderCallback): void;
     extend(type: 'guard', name: string, callback: ExtendGuardCallback): void;
+    extend(type: 'client', name: string, callback: ExtendClientCallback): void;
 }

package/build/src/AuthManager/index.js

@@ -19,6 +19,10 @@ class AuthManager {
     constructor(application, config) {
         this.application = application;
         this.config = config;
+        /**
+         * Extended set of testing clients
+         */
+        this.extendedClients = new Map();
         /**
          * Extended set of providers
          */
@@ -117,6 +121,50 @@ class AuthManager {
         }
         return guardCallback(this, mapping, config, provider, ctx);
     }
+    /**
+     * Returns an instance of the session client
+     */
+    makeSessionClient(mapping, config, provider) {
+        const { SessionClient } = require('../Clients/Session');
+        return new SessionClient(mapping, config, provider);
+    }
+    /**
+     * Returns an instance of the session client
+     */
+    makeOatClient(mapping, config, provider) {
+        const { OATClient } = require('../Clients/Oat');
+        const tokenProvider = this.makeTokenProviderInstance(config.tokenProvider);
+        return new OATClient(mapping, config, provider, tokenProvider);
+    }
+    /**
+     * Returns an instance of the extended client
+     */
+    makeExtendedClient(mapping, config, provider) {
+        const clientCallback = this.extendedClients.get(config.driver);
+        if (!clientCallback) {
+            throw new utils_1.Exception(`Invalid guard driver "${config.driver}" property`);
+        }
+        return clientCallback(this, mapping, config, provider);
+    }
+    /**
+     * Makes client instance for the defined driver inside the
+     * mapping config.
+     */
+    makeClientInstance(mapping, mappingConfig, provider) {
+        if (!mappingConfig || !mappingConfig.driver) {
+            throw new utils_1.Exception('Invalid auth config, missing "driver" property');
+        }
+        switch (mappingConfig.driver) {
+            case 'session':
+                return this.makeSessionClient(mapping, mappingConfig, provider);
+            case 'oat':
+                return this.makeOatClient(mapping, mappingConfig, provider);
+            case 'basic':
+                throw new utils_1.Exception('There is no testing client for basic auth. Use "request.basicAuth" method instead');
+            default:
+                return this.makeExtendedClient(mapping, mappingConfig, provider);
+        }
+    }
     /**
      * Makes instance of a provider based upon the driver value
      */
@@ -179,6 +227,17 @@ class AuthManager {
         const provider = this.makeUserProviderInstance(mapping, mappingConfig.provider);
         return this.makeGuardInstance(mapping, mappingConfig, provider, ctx);
     }
+    /**
+     * Returns an instance of the testing
+     */
+    client(mapping) {
+        const mappingConfig = this.config.guards[mapping];
+        if (mappingConfig === undefined) {
+            throw new utils_1.Exception(`Invalid guard "${mapping}". Make sure the guard is defined inside the config/auth file`);
+        }
+        const provider = this.makeUserProviderInstance(mapping, mappingConfig.provider);
+        return this.makeClientInstance(mapping, mappingConfig, provider);
+    }
     /**
      * Returns an instance of the auth class for the current request
      */
@@ -188,9 +247,15 @@ class AuthManager {
     extend(type, name, callback) {
         if (type === 'provider') {
             this.extendedProviders.set(name, callback);
+            return;
+        }
+        if (type === 'client') {
+            this.extendedClients.set(name, callback);
+            return;
         }
         if (type === 'guard') {
             this.extendedGuards.set(name, callback);
+            return;
         }
     }
 }

package/build/src/Bindings/Tests.d.ts

@@ -0,0 +1,6 @@
+import { AuthManagerContract } from '@ioc:Adonis/Addons/Auth';
+import { ContainerBindings } from '@ioc:Adonis/Core/Application';
+/**
+ * Define test bindings
+ */
+export declare function defineTestsBindings(ApiRequest: ContainerBindings['Japa/Preset/ApiRequest'], ApiClient: ContainerBindings['Japa/Preset/ApiClient'], AuthManager: AuthManagerContract): void;

package/build/src/Bindings/Tests.js

@@ -0,0 +1,69 @@
+"use strict";
+/*
+ * @adonisjs/auth
+ *
+ * (c) AdonisJS Auth
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTestsBindings = void 0;
+/**
+ * Define test bindings
+ */
+function defineTestsBindings(ApiRequest, ApiClient, AuthManager) {
+    /**
+     * Set "sessionClient" on the api request
+     */
+    ApiRequest.getter('authManager', function () {
+        return AuthManager;
+    }, true);
+    /**
+     * Login user using the default guard
+     */
+    ApiRequest.macro('loginAs', function (user) {
+        this['authData'] = {
+            client: this.authManager.client(this.authManager.defaultGuard),
+            args: [user],
+        };
+        return this;
+    });
+    /**
+     * Login user using a custom guard
+     */
+    ApiRequest.macro('guard', function (mapping) {
+        return {
+            loginAs: (...args) => {
+                this['authData'] = {
+                    client: this.authManager.client(mapping),
+                    args,
+                };
+                return this;
+            },
+        };
+    });
+    /**
+     * Hook into the request and login the user
+     */
+    ApiClient.setup(async (request) => {
+        const authData = request['authData'];
+        if (!authData) {
+            return;
+        }
+        const requestData = await authData.client.login(...authData.args);
+        if (requestData.headers) {
+            request.headers(requestData.headers);
+        }
+        if (requestData.session) {
+            request.session(requestData.session);
+        }
+        if (requestData.cookies) {
+            request.cookies(requestData.cookies);
+        }
+        return async () => {
+            await authData.client.logout(...authData.args);
+        };
+    });
+}
+exports.defineTestsBindings = defineTestsBindings;

package/build/src/Clients/Oat/index.d.ts

@@ -0,0 +1,50 @@
+import { OATGuardConfig, OATLoginOptions, OATClientContract, UserProviderContract, ClientRequestData } from '@ioc:Adonis/Addons/Auth';
+import { TokenProviderContract } from '@ioc:Adonis/Addons/Auth';
+/**
+ * OAT client to login a user during tests using the
+ * opaque tokens guard
+ */
+export declare class OATClient implements OATClientContract<any> {
+    name: string;
+    config: OATGuardConfig<any>;
+    private provider;
+    tokenProvider: TokenProviderContract;
+    constructor(name: string, config: OATGuardConfig<any>, provider: UserProviderContract<any>, tokenProvider: TokenProviderContract);
+    /**
+     * Token generated during the login call
+     */
+    private tokenId?;
+    /**
+     * Length of the raw token. The hash length will vary
+     */
+    private tokenLength;
+    /**
+     * Token type for the persistance store
+     */
+    private tokenType;
+    /**
+     * Returns the provider user instance from the regular user details. Raises
+     * exception when id is missing
+     */
+    private getUserForLogin;
+    /**
+     * Converts value to a sha256 hash
+     */
+    private generateHash;
+    /**
+     * Converts expiry duration to an absolute date/time value
+     */
+    private getExpiresAtDate;
+    /**
+     * Generates a new token + hash for the persistance
+     */
+    private generateTokenForPersistance;
+    /**
+     * Returns the request data to mark user as logged in
+     */
+    login(user: any, options?: OATLoginOptions): Promise<ClientRequestData>;
+    /**
+     * Logout user
+     */
+    logout(): Promise<void>;
+}

package/build/src/Clients/Oat/index.js

@@ -0,0 +1,123 @@
+"use strict";
+/*
+ * @adonisjs/auth
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OATClient = void 0;
+const luxon_1 = require("luxon");
+const crypto_1 = require("crypto");
+const utils_1 = require("@poppinss/utils");
+const helpers_1 = require("@poppinss/utils/build/helpers");
+const ProviderToken_1 = require("../../Tokens/ProviderToken");
+/**
+ * OAT client to login a user during tests using the
+ * opaque tokens guard
+ */
+class OATClient {
+    constructor(name, config, provider, tokenProvider) {
+        this.name = name;
+        this.config = config;
+        this.provider = provider;
+        this.tokenProvider = tokenProvider;
+        /**
+         * Length of the raw token. The hash length will vary
+         */
+        this.tokenLength = 60;
+        /**
+         * Token type for the persistance store
+         */
+        this.tokenType = this.config.tokenProvider.type || 'opaque_token';
+    }
+    /**
+     * Returns the provider user instance from the regular user details. Raises
+     * exception when id is missing
+     */
+    async getUserForLogin(user, identifierKey) {
+        const providerUser = await this.provider.getUserFor(user);
+        /**
+         * Ensure id exists on the user
+         */
+        const id = providerUser.getId();
+        if (!id) {
+            throw new utils_1.Exception(`Cannot login user. Value of "${identifierKey}" is not defined`);
+        }
+        return providerUser;
+    }
+    /**
+     * Converts value to a sha256 hash
+     */
+    generateHash(token) {
+        return (0, crypto_1.createHash)('sha256').update(token).digest('hex');
+    }
+    /**
+     * Converts expiry duration to an absolute date/time value
+     */
+    getExpiresAtDate(expiresIn) {
+        if (!expiresIn) {
+            return;
+        }
+        const milliseconds = typeof expiresIn === 'string' ? helpers_1.string.toMs(expiresIn) : expiresIn;
+        return luxon_1.DateTime.local().plus({ milliseconds });
+    }
+    /**
+     * Generates a new token + hash for the persistance
+     */
+    generateTokenForPersistance(expiresIn) {
+        const token = helpers_1.string.generateRandom(this.tokenLength);
+        return {
+            token,
+            hash: this.generateHash(token),
+            expiresAt: this.getExpiresAtDate(expiresIn),
+        };
+    }
+    /**
+     * Returns the request data to mark user as logged in
+     */
+    async login(user, options) {
+        /**
+         * Normalize options with defaults
+         */
+        const { expiresIn, name, ...meta } = Object.assign({
+            name: 'Opaque Access Token',
+        }, options);
+        /**
+         * Since the login method is not exposed to the end user, we cannot expect
+         * them to instantiate and pass an instance of provider user, so we
+         * create one manually.
+         */
+        const providerUser = await this.getUserForLogin(user, this.config.provider.identifierKey);
+        /**
+         * "getUserForLogin" raises exception when id is missing, so we can
+         * safely assume it is defined
+         */
+        const id = providerUser.getId();
+        const token = this.generateTokenForPersistance(expiresIn);
+        /**
+         * Persist token to the database. Make sure that we are always
+         * passing the hash to the storage driver
+         */
+        const providerToken = new ProviderToken_1.ProviderToken(name, token.hash, id, this.tokenType);
+        providerToken.expiresAt = token.expiresAt;
+        providerToken.meta = meta;
+        this.tokenId = await this.tokenProvider.write(providerToken);
+        return {
+            headers: {
+                Authorization: `Bearer ${helpers_1.base64.urlEncode(this.tokenId)}.${token.token}`,
+            },
+        };
+    }
+    /**
+     * Logout user
+     */
+    async logout() {
+        if (this.tokenId) {
+            await this.tokenProvider.destroy(this.tokenId, this.tokenType);
+        }
+    }
+}
+exports.OATClient = OATClient;

package/build/src/Clients/Session/index.d.ts

@@ -0,0 +1,34 @@
+import { SessionGuardConfig, GuardClientContract, UserProviderContract, ProviderUserContract } from '@ioc:Adonis/Addons/Auth';
+/**
+ * Session client to login a user during tests using the
+ * sessions guard
+ */
+export declare class SessionClient implements GuardClientContract<any> {
+    name: string;
+    private config;
+    private provider;
+    constructor(name: string, config: SessionGuardConfig<any>, provider: UserProviderContract<any>);
+    /**
+     * The name of the session key name
+     */
+    get sessionKeyName(): string;
+    /**
+     * Returns the provider user instance from the regular user details. Raises
+     * exception when id is missing
+     */
+    protected getUserForLogin(user: any, identifierKey: string): Promise<ProviderUserContract<any>>;
+    /**
+     * Returns the request data to mark user as logged in
+     */
+    login(user: any): Promise<{
+        session: {
+            [x: string]: string | number;
+        };
+    }>;
+    /**
+     * No need to logout when using session client.
+     * Session data is persisted within memory and will
+     * be cleared after each test
+     */
+    logout(): Promise<void>;
+}

package/build/src/Clients/Session/index.js

@@ -0,0 +1,72 @@
+"use strict";
+/*
+ * @adonisjs/auth
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionClient = void 0;
+const utils_1 = require("@poppinss/utils");
+/**
+ * Session client to login a user during tests using the
+ * sessions guard
+ */
+class SessionClient {
+    constructor(name, config, provider) {
+        this.name = name;
+        this.config = config;
+        this.provider = provider;
+    }
+    /**
+     * The name of the session key name
+     */
+    get sessionKeyName() {
+        return `auth_${this.name}`;
+    }
+    /**
+     * Returns the provider user instance from the regular user details. Raises
+     * exception when id is missing
+     */
+    async getUserForLogin(user, identifierKey) {
+        const providerUser = await this.provider.getUserFor(user);
+        /**
+         * Ensure id exists on the user
+         */
+        const id = providerUser.getId();
+        if (!id) {
+            throw new utils_1.Exception(`Cannot login user. Value of "${identifierKey}" is not defined`);
+        }
+        return providerUser;
+    }
+    /**
+     * Returns the request data to mark user as logged in
+     */
+    async login(user) {
+        /**
+         * Since the login method is exposed to the end user, we cannot expect
+         * them to instantiate and return an instance of authenticatable, so
+         * we create one manually.
+         */
+        const providerUser = await this.getUserForLogin(user, this.config.provider.identifierKey);
+        /**
+         * getUserForLogin raises exception when id is missing, so we can
+         * safely assume it is defined
+         */
+        const id = providerUser.getId();
+        return {
+            session: {
+                [this.sessionKeyName]: id,
+            },
+        };
+    }
+    /**
+     * No need to logout when using session client.
+     * Session data is persisted within memory and will
+     * be cleared after each test
+     */
+    async logout() { }
+}
+exports.SessionClient = SessionClient;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/auth",
-  "version": "8.0.12",
-  "description": "Offical authentication provider for Adonis framework",
+  "version": "8.2.1",
+  "description": "Official authentication provider for Adonis framework",
   "types": "build/adonis-typings/index.d.ts",
   "main": "build/providers/AuthProvider.js",
   "files": [
@@ -46,41 +46,42 @@
     "url": "https://github.com/adonisjs/auth/issues"
   },
   "devDependencies": {
-    "@adonisjs/core": "^5.5.0",
-    "@adonisjs/i18n": "^1.5.4",
-    "@adonisjs/lucid": "^17.0.0",
-    "@adonisjs/mrm-preset": "^5.0.2",
-    "@adonisjs/redis": "^7.1.1",
-    "@adonisjs/repl": "^3.1.8",
-    "@adonisjs/require-ts": "^2.0.10",
-    "@adonisjs/session": "^6.1.4",
-    "@adonisjs/sink": "^5.2.2",
-    "@japa/assert": "^1.2.3",
-    "@japa/run-failed-tests": "^1.0.3",
-    "@japa/runner": "^1.2.0",
-    "@japa/spec-reporter": "^1.1.7",
-    "@poppinss/dev-utils": "^2.0.2",
-    "@types/node": "^17.0.21",
-    "@types/supertest": "^2.0.11",
-    "@vscode/sqlite3": "^5.0.7",
+    "@adonisjs/core": "^5.8.2",
+    "@adonisjs/i18n": "^1.5.5",
+    "@adonisjs/lucid": "^18.0.0",
+    "@adonisjs/mrm-preset": "^5.0.3",
+    "@adonisjs/redis": "^7.3.0",
+    "@adonisjs/repl": "^3.1.10",
+    "@adonisjs/require-ts": "^2.0.11",
+    "@adonisjs/session": "^6.4.0",
+    "@adonisjs/sink": "^5.3.1",
+    "@japa/assert": "^1.3.4",
+    "@japa/preset-adonis": "^1.0.16",
+    "@japa/run-failed-tests": "^1.0.6",
+    "@japa/runner": "^2.0.8",
+    "@japa/spec-reporter": "^1.1.11",
+    "@poppinss/dev-utils": "^2.0.3",
+    "@types/node": "^17.0.35",
+    "@types/supertest": "^2.0.12",
     "copyfiles": "^2.4.1",
     "del-cli": "^4.0.1",
-    "eslint": "^8.10.0",
-    "eslint-config-prettier": "^8.4.0",
+    "eslint": "^8.16.0",
+    "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-adonis": "^2.1.0",
     "eslint-plugin-prettier": "^4.0.0",
-    "github-label-sync": "^2.0.2",
-    "husky": "^7.0.4",
-    "mrm": "^3.0.10",
-    "np": "^7.6.0",
+    "github-label-sync": "^2.2.0",
+    "husky": "^8.0.1",
+    "mrm": "^4.0.0",
+    "np": "^7.6.1",
     "phc-bcrypt": "^1.0.7",
-    "pino-pretty": "^7.5.1",
-    "prettier": "^2.5.1",
+    "pino-pretty": "^7.6.1",
+    "prettier": "^2.6.2",
     "reflect-metadata": "^0.1.13",
     "set-cookie-parser": "^2.4.8",
-    "supertest": "^6.2.2",
+    "sqlite3": "^5.0.8",
+    "supertest": "^6.2.3",
     "ts-essentials": "^9.1.2",
-    "typescript": "^4.6.2"
+    "typescript": "^4.6.4"
   },
   "nyc": {
     "exclude": [
@@ -100,16 +101,16 @@
     "anyBranch": false
   },
   "dependencies": {
-    "@poppinss/hooks": "^5.0.2",
-    "@poppinss/utils": "^4.0.2",
-    "luxon": "^2.3.1"
+    "@poppinss/hooks": "^5.0.3",
+    "@poppinss/utils": "^4.0.4",
+    "luxon": "^2.4.0"
   },
   "peerDependencies": {
-    "@adonisjs/core": "^5.1.1",
-    "@adonisjs/i18n": "^1.3.1",
-    "@adonisjs/lucid": "^17.0.0",
-    "@adonisjs/redis": "^7.0.0",
-    "@adonisjs/session": "^6.0.0"
+    "@adonisjs/core": "^5.7.1",
+    "@adonisjs/i18n": "^1.5.0",
+    "@adonisjs/lucid": "^18.0.0",
+    "@adonisjs/redis": "^7.2.0",
+    "@adonisjs/session": "^6.2.0"
   },
   "peerDependenciesMeta": {
     "@adonisjs/i18n": {