@adonisjs/auth 9.0.0-0 → 9.0.0-10

package/build/configure.js

@@ -6,36 +6,15 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-/**
- * Configures the user provider to use for finding
- * users
- */
-async function configureProvider(command) {
-    const provider = await command.prompt.choice('Select the user provider you want to use', [
-        {
-            name: 'lucid',
-            message: 'Lucid models',
-        },
-        {
-            name: 'db',
-            message: 'Database query builder',
-        },
-    ]);
-    /**
-     * Publish config file
-     */
-    await command.publishStub('config.stub', { provider });
-}
+import { presetAuth } from '@adonisjs/presets/auth';
 /**
  * Configures the auth package
  */
 export async function configure(command) {
-    await configureProvider(command);
     const codemods = await command.createCodemods();
-    /**
-     * Register provider
-     */
-    await codemods.updateRcFile((rcFile) => {
-        rcFile.addProvider('@adonisjs/auth/auth_provider');
+    // let guard: string | undefined = command.parsedFlags.guard
+    await presetAuth(codemods, command.app, {
+        guard: 'session',
+        userProvider: 'lucid',
     });
 }

package/build/factories/basic_auth_guard_factory.d.ts

@@ -0,0 +1,12 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import { FactoryUser, TestLucidUserProvider } from './lucid_user_provider.js';
+import { BasicAuthGuard } from '../src/guards/basic_auth/guard.js';
+import type { UserProviderContract } from '../src/core/types.js';
+/**
+ * Exposes the API to create a basic auth guard for testing. Under
+ * the hood configures Lucid models for looking up users
+ */
+export declare class BasicAuthGuardFactory {
+    merge(): this;
+    create<UserProvider extends UserProviderContract<unknown> = TestLucidUserProvider<typeof FactoryUser>>(ctx: HttpContext, provider?: UserProvider): BasicAuthGuard<TestLucidUserProvider<typeof FactoryUser> | UserProvider>;
+}

package/build/factories/basic_auth_guard_factory.js

@@ -0,0 +1,22 @@
+/*
+ * @adonisjs/auth
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { LucidUserProviderFactory, } from './lucid_user_provider.js';
+import { BasicAuthGuard } from '../src/guards/basic_auth/guard.js';
+/**
+ * Exposes the API to create a basic auth guard for testing. Under
+ * the hood configures Lucid models for looking up users
+ */
+export class BasicAuthGuardFactory {
+    merge() {
+        return this;
+    }
+    create(ctx, provider) {
+        return new BasicAuthGuard('basic', ctx, provider || new LucidUserProviderFactory().create());
+    }
+}

package/build/index.d.ts

@@ -1,7 +1,6 @@
 export { configure } from './configure.js';
-export { stubsRoot } from './stubs/main.js';
-export * as errors from './src/auth/errors.js';
 export * as symbols from './src/auth/symbols.js';
 export { AuthManager } from './src/auth/auth_manager.js';
 export { Authenticator } from './src/auth/authenticator.js';
 export { defineConfig, providers } from './src/auth/define_config.js';
+export { AuthenticationException, InvalidCredentialsException } from './src/auth/errors.js';

package/build/index.js

@@ -7,9 +7,8 @@
  * file that was distributed with this source code.
  */
 export { configure } from './configure.js';
-export { stubsRoot } from './stubs/main.js';
-export * as errors from './src/auth/errors.js';
 export * as symbols from './src/auth/symbols.js';
 export { AuthManager } from './src/auth/auth_manager.js';
 export { Authenticator } from './src/auth/authenticator.js';
 export { defineConfig, providers } from './src/auth/define_config.js';
+export { AuthenticationException, InvalidCredentialsException } from './src/auth/errors.js';

package/build/src/auth/auth_manager.d.ts

@@ -1,12 +1,17 @@
 import type { HttpContext } from '@adonisjs/core/http';
 import type { GuardFactory } from './types.js';
 import { Authenticator } from './authenticator.js';
+import { AuthenticatorClient } from './authenticator_client.js';
 /**
  * Auth manager exposes the API to register and manage authentication
  * guards from the config
  */
 export declare class AuthManager<KnownGuards extends Record<string, GuardFactory>> {
     #private;
+    /**
+     * Name of the default guard
+     */
+    get defaultGuard(): keyof KnownGuards;
     constructor(config: {
         default: keyof KnownGuards;
         guards: KnownGuards;
@@ -15,4 +20,8 @@ export declare class AuthManager<KnownGuards extends Record<string, GuardFactory
      * Create an authenticator for a given HTTP request
      */
     createAuthenticator(ctx: HttpContext): Authenticator<KnownGuards>;
+    /**
+     * Creates an instance of the authenticator client
+     */
+    createAuthenticatorClient(): AuthenticatorClient<KnownGuards>;
 }

package/build/src/auth/auth_manager.js

@@ -7,6 +7,7 @@
  * file that was distributed with this source code.
  */
 import { Authenticator } from './authenticator.js';
+import { AuthenticatorClient } from './authenticator_client.js';
 /**
  * Auth manager exposes the API to register and manage authentication
  * guards from the config
@@ -16,6 +17,12 @@ export class AuthManager {
      * Registered guards
      */
     #config;
+    /**
+     * Name of the default guard
+     */
+    get defaultGuard() {
+        return this.#config.default;
+    }
     constructor(config) {
         this.#config = config;
     }
@@ -25,4 +32,10 @@ export class AuthManager {
     createAuthenticator(ctx) {
         return new Authenticator(ctx, this.#config);
     }
+    /**
+     * Creates an instance of the authenticator client
+     */
+    createAuthenticatorClient() {
+        return new AuthenticatorClient(this.#config);
+    }
 }

package/build/src/auth/authenticator.d.ts

@@ -6,13 +6,58 @@ import type { GuardFactory } from './types.js';
  */
 export declare class Authenticator<KnownGuards extends Record<string, GuardFactory>> {
     #private;
+    /**
+     * Name of the default guard
+     */
+    get defaultGuard(): keyof KnownGuards;
+    /**
+     * Reference to the guard using which the current
+     * request has been authenticated.
+     */
+    get authenticatedViaGuard(): keyof KnownGuards | undefined;
+    /**
+     * A boolean to know if the current request has
+     * been authenticated
+     */
+    get isAuthenticated(): boolean;
+    /**
+     * Reference to the currently authenticated user
+     */
+    get user(): {
+        [K in keyof KnownGuards]: ReturnType<KnownGuards[K]>['user'];
+    }[keyof KnownGuards];
+    /**
+     * Whether or not the authentication has been attempted
+     * during the current request
+     */
+    get authenticationAttempted(): boolean;
     constructor(ctx: HttpContext, config: {
         default: keyof KnownGuards;
         guards: KnownGuards;
     });
+    /**
+     * Returns an instance of the logged-in user or throws an
+     * exception
+     */
+    getUserOrFail(): {
+        [K in keyof KnownGuards]: ReturnType<ReturnType<KnownGuards[K]>['getUserOrFail']>;
+    }[keyof KnownGuards];
     /**
      * Returns an instance of a known guard. Guards instances are
      * cached during the lifecycle of an HTTP request.
      */
     use<Guard extends keyof KnownGuards>(guard?: Guard): ReturnType<KnownGuards[Guard]>;
+    /**
+     * Authenticate the request using all of the mentioned
+     * guards or the default guard.
+     *
+     * The authentication process will stop after any of the
+     * mentioned guards is able to authenticate the request
+     * successfully.
+     *
+     * Otherwise, "AuthenticationException" will be raised.
+     */
+    authenticateUsing(guards?: (keyof KnownGuards)[], options?: {
+        loginRoute?: string;
+    }): Promise<boolean>;
 }

package/build/src/auth/authenticator.js

@@ -7,11 +7,17 @@
  * file that was distributed with this source code.
  */
 import debug from './debug.js';
+import { AuthenticationException } from './errors.js';
 /**
  * Authenticator is an HTTP request specific implementation for using
  * guards to login users and authenticate requests.
  */
 export class Authenticator {
+    /**
+     * Name of the guard using which the request has
+     * been authenticated
+     */
+    #authenticatedViaGuard;
     /**
      * Reference to HTTP context
      */
@@ -24,11 +30,51 @@ export class Authenticator {
      * Cache of guards created during the HTTP request
      */
     #guardsCache = {};
+    /**
+     * Name of the default guard
+     */
+    get defaultGuard() {
+        return this.#config.default;
+    }
+    /**
+     * Reference to the guard using which the current
+     * request has been authenticated.
+     */
+    get authenticatedViaGuard() {
+        return this.#authenticatedViaGuard;
+    }
+    /**
+     * A boolean to know if the current request has
+     * been authenticated
+     */
+    get isAuthenticated() {
+        return this.use(this.#authenticatedViaGuard || this.defaultGuard).isAuthenticated;
+    }
+    /**
+     * Reference to the currently authenticated user
+     */
+    get user() {
+        return this.use(this.#authenticatedViaGuard || this.defaultGuard).user;
+    }
+    /**
+     * Whether or not the authentication has been attempted
+     * during the current request
+     */
+    get authenticationAttempted() {
+        return this.use(this.#authenticatedViaGuard || this.defaultGuard).authenticationAttempted;
+    }
     constructor(ctx, config) {
         this.#ctx = ctx;
         this.#config = config;
         debug('creating authenticator. config %O', this.#config);
     }
+    /**
+     * Returns an instance of the logged-in user or throws an
+     * exception
+     */
+    getUserOrFail() {
+        return this.use(this.#authenticatedViaGuard || this.defaultGuard).getUserOrFail();
+    }
     /**
      * Returns an instance of a known guard. Guards instances are
      * cached during the lifecycle of an HTTP request.
@@ -52,4 +98,32 @@ export class Authenticator {
         this.#guardsCache[guardToUse] = guardInstance;
         return guardInstance;
     }
+    /**
+     * Authenticate the request using all of the mentioned
+     * guards or the default guard.
+     *
+     * The authentication process will stop after any of the
+     * mentioned guards is able to authenticate the request
+     * successfully.
+     *
+     * Otherwise, "AuthenticationException" will be raised.
+     */
+    async authenticateUsing(guards, options) {
+        const guardsToUse = guards || [this.defaultGuard];
+        let lastUsedGuardDriver;
+        for (let guardName of guardsToUse) {
+            debug('attempting to authenticate using guard "%s"', guardName);
+            const guard = this.use(guardName);
+            lastUsedGuardDriver = guard.driverName;
+            if (await guard.check()) {
+                this.#authenticatedViaGuard = guardName;
+                return true;
+            }
+        }
+        throw new AuthenticationException('Unauthorized access', {
+            code: 'E_UNAUTHORIZED_ACCESS',
+            guardDriverName: lastUsedGuardDriver,
+            redirectTo: options?.loginRoute,
+        });
+    }
 }

package/build/src/auth/authenticator_client.d.ts

@@ -0,0 +1,23 @@
+import type { GuardFactory } from './types.js';
+/**
+ * Authenticator client is used to create guard instances for
+ * testing. It passes a fake HTTPContext to the guards, so
+ * make sure to not call server side APIs that might be
+ * relying on a real HTTPContext instance
+ */
+export declare class AuthenticatorClient<KnownGuards extends Record<string, GuardFactory>> {
+    #private;
+    /**
+     * Name of the default guard
+     */
+    get defaultGuard(): keyof KnownGuards;
+    constructor(config: {
+        default: keyof KnownGuards;
+        guards: KnownGuards;
+    });
+    /**
+     * Returns an instance of a known guard. Guards instances are
+     * cached during the lifecycle of an HTTP request.
+     */
+    use<Guard extends keyof KnownGuards>(guard?: Guard): ReturnType<KnownGuards[Guard]>;
+}

package/build/src/auth/authenticator_client.js

@@ -0,0 +1,59 @@
+/*
+ * @adonisjs/auth
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import debug from './debug.js';
+import { HttpContextFactory } from '@adonisjs/core/factories/http';
+/**
+ * Authenticator client is used to create guard instances for
+ * testing. It passes a fake HTTPContext to the guards, so
+ * make sure to not call server side APIs that might be
+ * relying on a real HTTPContext instance
+ */
+export class AuthenticatorClient {
+    /**
+     * Registered guards
+     */
+    #config;
+    /**
+     * Cache of guards
+     */
+    #guardsCache = {};
+    /**
+     * Name of the default guard
+     */
+    get defaultGuard() {
+        return this.#config.default;
+    }
+    constructor(config) {
+        this.#config = config;
+        debug('creating authenticator client. config %O', this.#config);
+    }
+    /**
+     * Returns an instance of a known guard. Guards instances are
+     * cached during the lifecycle of an HTTP request.
+     */
+    use(guard) {
+        const guardToUse = guard || this.#config.default;
+        /**
+         * Use cached copy if exists
+         */
+        const cachedGuard = this.#guardsCache[guardToUse];
+        if (cachedGuard) {
+            debug('using guard from cache. name: "%s"', guardToUse);
+            return cachedGuard;
+        }
+        const guardFactory = this.#config.guards[guardToUse];
+        /**
+         * Construct guard and cache it
+         */
+        debug('creating guard. name: "%s"', guardToUse);
+        const guardInstance = guardFactory(new HttpContextFactory().create());
+        this.#guardsCache[guardToUse] = guardInstance;
+        return guardInstance;
+    }
+}

package/build/src/auth/errors.d.ts

@@ -1,8 +1,90 @@
+import { Exception } from '@poppinss/utils';
+import { HttpContext } from '@adonisjs/core/http';
 /**
- * Invalid token provided
+ * Authentication exception is raised when an attempt is
+ * made to authenticate an HTTP request
  */
-export declare const E_INVALID_AUTH_TOKEN: new (args?: any, options?: ErrorOptions | undefined) => import("@poppinss/utils").Exception;
+export declare class AuthenticationException extends Exception {
+    static status?: number | undefined;
+    static code?: string | undefined;
+    /**
+     * Raises authentication exception when session guard
+     * is unable to authenticate the request
+     */
+    static E_INVALID_AUTH_SESSION(): AuthenticationException;
+    /**
+     * Raises authentication exception when session guard
+     * is unable to authenticate the request
+     */
+    static E_INVALID_BASIC_AUTH_CREDENTIALS(): AuthenticationException;
+    guardDriverName: string;
+    redirectTo?: string;
+    identifier: string;
+    constructor(message: string, options: ErrorOptions & {
+        guardDriverName: string;
+        redirectTo?: string;
+        code?: string;
+        status?: number;
+    });
+    /**
+     * Returns the message to be sent in the HTTP response.
+     * Feel free to override this method and return a custom
+     * response.
+     */
+    getResponseMessage(error: AuthenticationException, ctx: HttpContext): string;
+    /**
+     * A collection of authentication exception
+     * renderers to render the exception to a
+     * response.
+     *
+     * The collection is a key-value pair, where the
+     * key is the guard driver name and value is
+     * a factory function to respond to the
+     * request.
+     */
+    renderers: Record<string, (message: string, error: AuthenticationException, ctx: HttpContext) => Promise<void> | void>;
+    /**
+     * Self handles the auth exception and converts it to an
+     * HTTP response
+     */
+    handle(error: AuthenticationException, ctx: HttpContext): Promise<void>;
+}
 /**
- * The user session is invalid
+ * Invalid credentials exception is raised when unable
+ * to verify user credentials during login
  */
-export declare const E_INVALID_AUTH_SESSION: new (args?: any, options?: ErrorOptions | undefined) => import("@poppinss/utils").Exception;
+export declare class InvalidCredentialsException extends Exception {
+    static message: string;
+    static code: string;
+    static status?: number | undefined;
+    static E_INVALID_CREDENTIALS(guardDriverName: string): InvalidCredentialsException;
+    guardDriverName: string;
+    identifier: string;
+    constructor(message: string, options: ErrorOptions & {
+        guardDriverName: string;
+        code?: string;
+        status?: number;
+    });
+    /**
+     * Returns the message to be sent in the HTTP response.
+     * Feel free to override this method and return a custom
+     * response.
+     */
+    getResponseMessage(error: InvalidCredentialsException, ctx: HttpContext): string;
+    /**
+     * A collection of authentication exception
+     * renderers to render the exception to a
+     * response.
+     *
+     * The collection is a key-value pair, where the
+     * key is the guard driver name and value is
+     * a factory function to respond to the
+     * request.
+     */
+    renderers: Record<string, (message: string, error: InvalidCredentialsException, ctx: HttpContext) => Promise<void> | void>;
+    /**
+     * Self handles the auth exception and converts it to an
+     * HTTP response
+     */
+    handle(error: InvalidCredentialsException, ctx: HttpContext): Promise<void>;
+}