@adonisjs/auth 9.0.0-9 → 9.0.0

package/build/src/core/user_providers/lucid.js

@@ -1,122 +0,0 @@
-/*
- * @adonisjs/auth
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { RuntimeException } from '@poppinss/utils';
-import debug from '../../auth/debug.js';
-import { GuardUser } from '../guard_user.js';
-import { PROVIDER_REAL_USER } from '../../auth/symbols.js';
-/**
- * Lucid user represents a guard user, used by authentication guards
- * to perform authentication.
- */
-class LucidUser extends GuardUser {
-    /**
-     * @inheritdoc
-     */
-    getId() {
-        const id = this.realUser.$primaryKeyValue;
-        /**
-         * Ensure id exists
-         */
-        if (!id) {
-            const model = this.realUser.constructor;
-            const modelName = model.name;
-            const primaryKey = model.primaryKey;
-            throw new RuntimeException(`Cannot use "${modelName}" model for authentication. The value of column "${primaryKey}" is undefined or null`);
-        }
-        return id;
-    }
-    /**
-     * @inheritdoc
-     */
-    async verifyPassword(plainTextPassword) {
-        return this.realUser.verifyPasswordForAuth(plainTextPassword);
-    }
-}
-/**
- * Lucid user provider is used to lookup user for authentication
- * using a Lucid model.
- */
-export class BaseLucidUserProvider {
-    options;
-    /**
-     * Reference to the lazily imported model
-     */
-    model;
-    constructor(
-    /**
-     * Lucid provider options
-     */
-    options) {
-        this.options = options;
-        debug('lucid_user_provider: options %O', options);
-    }
-    /**
-     * Imports the model from the provider, returns and caches it
-     * for further operations.
-     */
-    async getModel() {
-        if (this.model) {
-            return this.model;
-        }
-        const importedModel = await this.options.model();
-        this.model = importedModel.default;
-        debug('lucid_user_provider: using model %O', this.model);
-        return this.model;
-    }
-    /**
-     * Returns an instance of the query builder
-     */
-    getQueryBuilder(model) {
-        return model.query({
-            client: this.options.client,
-            connection: this.options.connection,
-        });
-    }
-    /**
-     * Returns an instance of the "LucidUser" that guards
-     * can use for authentication
-     */
-    async createUserForGuard(user) {
-        const model = await this.getModel();
-        if (user instanceof model === false) {
-            throw new RuntimeException(`Invalid user object. It must be an instance of the "${model.name}" model`);
-        }
-        debug('lucid_user_provider: converting user object to guard user %O', user);
-        return new LucidUser(user);
-    }
-    /**
-     * Finds a user by id using the configured model.
-     */
-    async findById(value) {
-        debug('lucid_user_provider: finding user by id %s', value);
-        const model = await this.getModel();
-        const user = await model.find(value, {
-            client: this.options.client,
-            connection: this.options.connection,
-        });
-        if (!user) {
-            return null;
-        }
-        return new LucidUser(user);
-    }
-    /**
-     * Finds a user using one of the pre-configured unique
-     * ids, via the configured model.
-     */
-    async findByUid(value) {
-        const query = this.getQueryBuilder(await this.getModel());
-        this.options.uids.forEach((uid) => query.orWhere(uid, value));
-        debug('lucid_user_provider: finding user by uids, uids: %O, value: %s', this.options.uids, value);
-        const user = await query.limit(1).first();
-        if (!user) {
-            return null;
-        }
-        return new LucidUser(user);
-    }
-}

package/build/src/guards/basic_auth/define_config.d.ts

@@ -1,16 +0,0 @@
-import type { HttpContext } from '@adonisjs/core/http';
-import type { ConfigProvider } from '@adonisjs/core/types';
-import type { GuardConfigProvider } from '../../auth/types.js';
-import type { UserProviderContract } from '../../core/types.js';
-import { BasicAuthGuard } from './guard.js';
-/**
- * Helper function to configure the basic auth guard for
- * authentication.
- *
- * This method returns a config builder, which internally
- * returns a factory function to construct a guard
- * during HTTP requests.
- */
-export declare function basicAuthGuard<UserProvider extends UserProviderContract<unknown>>(config: {
-    provider: ConfigProvider<UserProvider>;
-}): GuardConfigProvider<(ctx: HttpContext) => BasicAuthGuard<UserProvider>>;

package/build/src/guards/basic_auth/define_config.js

@@ -1,38 +0,0 @@
-/*
- * @adonisjs/auth
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { configProvider } from '@adonisjs/core';
-import { RuntimeException } from '@poppinss/utils';
-import { BasicAuthGuard } from './guard.js';
-/**
- * Helper function to configure the basic auth guard for
- * authentication.
- *
- * This method returns a config builder, which internally
- * returns a factory function to construct a guard
- * during HTTP requests.
- */
-export function basicAuthGuard(config) {
-    return {
-        async resolver(guardName, app) {
-            const provider = await configProvider.resolve(app, config.provider);
-            if (!provider) {
-                throw new RuntimeException(`Invalid user provider defined on "${guardName}" guard`);
-            }
-            const emitter = await app.container.make('emitter');
-            /**
-             * Factory function needed by Authenticator to switch
-             * between guards and perform authentication
-             */
-            return (ctx) => {
-                const guard = new BasicAuthGuard(guardName, ctx, provider);
-                return guard.withEmitter(emitter);
-            };
-        },
-    };
-}

package/build/src/guards/basic_auth/guard.d.ts

@@ -1,70 +0,0 @@
-import type { Emitter } from '@adonisjs/core/events';
-import type { HttpContext } from '@adonisjs/core/http';
-import type { BasicAuthGuardEvents } from './types.js';
-import type { GuardContract } from '../../auth/types.js';
-import type { UserProviderContract } from '../../core/types.js';
-import { PROVIDER_REAL_USER, GUARD_KNOWN_EVENTS } from '../../auth/symbols.js';
-/**
- * Implementation of basic auth as an authentication guard
- */
-export declare class BasicAuthGuard<UserProvider extends UserProviderContract<unknown>> implements GuardContract<UserProvider[typeof PROVIDER_REAL_USER]> {
-    #private;
-    [GUARD_KNOWN_EVENTS]: BasicAuthGuardEvents<UserProvider[typeof PROVIDER_REAL_USER]>;
-    /**
-     * Driver name of the guard
-     */
-    driverName: 'basic_auth';
-    /**
-     * Whether or not the authentication has been attempted
-     * during the current request
-     */
-    authenticationAttempted: boolean;
-    /**
-     * A boolean to know if the current request has
-     * been authenticated
-     */
-    isAuthenticated: boolean;
-    /**
-     * Reference to an instance of the authenticated or logged-in
-     * user. The value only exists after calling one of the
-     * following methods.
-     *
-     * - authenticate
-     *
-     * You can use the "getUserOrFail" method to throw an exception if
-     * the request is not authenticated.
-     */
-    user?: UserProvider[typeof PROVIDER_REAL_USER];
-    constructor(name: string, ctx: HttpContext, userProvider: UserProvider);
-    /**
-     * Register an event emitter to listen for global events for
-     * authentication lifecycle.
-     */
-    withEmitter(emitter: Emitter<any>): this;
-    /**
-     * Returns an instance of the authenticated user. Or throws
-     * an exception if the request is not authenticated.
-     */
-    getUserOrFail(): UserProvider[typeof PROVIDER_REAL_USER];
-    /**
-     * Verifies user credentials and returns an instance of
-     * the user or throws "E_INVALID_BASIC_AUTH_CREDENTIALS" exception.
-     */
-    verifyCredentials(uid: string, password: string): Promise<UserProvider[typeof PROVIDER_REAL_USER]>;
-    /**
-     * Authenticates the current HTTP request for basic
-     * auth credentials
-     */
-    authenticate(): Promise<UserProvider[typeof PROVIDER_REAL_USER]>;
-    /**
-     * Silently attempt to authenticate the user.
-     *
-     * The method returns a boolean indicating if the authentication
-     * succeeded or failed.
-     */
-    check(): Promise<boolean>;
-    /**
-     * Not support
-     */
-    authenticateAsClient(_: UserProvider[typeof PROVIDER_REAL_USER]): Promise<never>;
-}

package/build/src/guards/basic_auth/guard.js

@@ -1,190 +0,0 @@
-/*
- * @adonisjs/auth
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import auth from 'basic-auth';
-import { RuntimeException } from '@poppinss/utils';
-import debug from '../../auth/debug.js';
-import { AuthenticationException } from '../../auth/errors.js';
-import { GUARD_KNOWN_EVENTS } from '../../auth/symbols.js';
-/**
- * Implementation of basic auth as an authentication guard
- */
-export class BasicAuthGuard {
-    /**
-     * A unique name for the guard. It is used while
-     * emitting events
-     */
-    #name;
-    /**
-     * Reference to the current HTTP context
-     */
-    #ctx;
-    /**
-     * Provider to lookup user details
-     */
-    #userProvider;
-    /**
-     * Emitter to emit events
-     */
-    #emitter;
-    /**
-     * Driver name of the guard
-     */
-    driverName = 'basic_auth';
-    /**
-     * Whether or not the authentication has been attempted
-     * during the current request
-     */
-    authenticationAttempted = false;
-    /**
-     * A boolean to know if the current request has
-     * been authenticated
-     */
-    isAuthenticated = false;
-    /**
-     * Reference to an instance of the authenticated or logged-in
-     * user. The value only exists after calling one of the
-     * following methods.
-     *
-     * - authenticate
-     *
-     * You can use the "getUserOrFail" method to throw an exception if
-     * the request is not authenticated.
-     */
-    user;
-    constructor(name, ctx, userProvider) {
-        this.#ctx = ctx;
-        this.#name = name;
-        this.#userProvider = userProvider;
-    }
-    /**
-     * Notifies about authentication failure and throws the exception
-     */
-    #authenticationFailed(error) {
-        if (this.#emitter) {
-            this.#emitter.emit('basic_auth:authentication_failed', {
-                guardName: this.#name,
-                error,
-            });
-        }
-        throw error;
-    }
-    /**
-     * Register an event emitter to listen for global events for
-     * authentication lifecycle.
-     */
-    withEmitter(emitter) {
-        this.#emitter = emitter;
-        return this;
-    }
-    /**
-     * Returns an instance of the authenticated user. Or throws
-     * an exception if the request is not authenticated.
-     */
-    getUserOrFail() {
-        if (!this.user) {
-            throw AuthenticationException.E_INVALID_BASIC_AUTH_CREDENTIALS();
-        }
-        return this.user;
-    }
-    /**
-     * Verifies user credentials and returns an instance of
-     * the user or throws "E_INVALID_BASIC_AUTH_CREDENTIALS" exception.
-     */
-    async verifyCredentials(uid, password) {
-        debug('basic_auth_guard: attempting to verify credentials for uid "%s"', uid);
-        /**
-         * Attempt to find a user by the uid and raise
-         * error when unable to find one
-         */
-        const providerUser = await this.#userProvider.findByUid(uid);
-        if (!providerUser) {
-            this.#authenticationFailed(AuthenticationException.E_INVALID_BASIC_AUTH_CREDENTIALS());
-        }
-        /**
-         * Raise error when unable to verify password
-         */
-        const user = providerUser.getOriginal();
-        /**
-         * Raise error when unable to verify password
-         */
-        if (!(await providerUser.verifyPassword(password))) {
-            this.#authenticationFailed(AuthenticationException.E_INVALID_BASIC_AUTH_CREDENTIALS());
-        }
-        return user;
-    }
-    /**
-     * Authenticates the current HTTP request for basic
-     * auth credentials
-     */
-    async authenticate() {
-        /**
-         * Avoid re-authenticating when already authenticated
-         */
-        if (this.authenticationAttempted) {
-            return this.getUserOrFail();
-        }
-        /**
-         * Beginning authentication attempt
-         */
-        this.authenticationAttempted = true;
-        if (this.#emitter) {
-            this.#emitter.emit('basic_auth:authentication_attempted', {
-                guardName: this.#name,
-            });
-        }
-        /**
-         * Fetch credentials from the header
-         */
-        const credentials = auth(this.#ctx.request.request);
-        if (!credentials) {
-            this.#authenticationFailed(AuthenticationException.E_INVALID_BASIC_AUTH_CREDENTIALS());
-        }
-        debug('basic_auth_guard: authenticating user using credentials');
-        /**
-         * Verifying user credentials
-         */
-        this.user = await this.verifyCredentials(credentials.name, credentials.pass);
-        this.isAuthenticated = true;
-        debug('basic_auth_guard: marking user as authenticated');
-        if (this.#emitter) {
-            this.#emitter.emit('basic_auth:authentication_succeeded', {
-                guardName: this.#name,
-                user: this.user,
-            });
-        }
-        /**
-         * Return user
-         */
-        return this.getUserOrFail();
-    }
-    /**
-     * Silently attempt to authenticate the user.
-     *
-     * The method returns a boolean indicating if the authentication
-     * succeeded or failed.
-     */
-    async check() {
-        try {
-            await this.authenticate();
-            return true;
-        }
-        catch (error) {
-            if (error instanceof AuthenticationException) {
-                return false;
-            }
-            throw error;
-        }
-    }
-    /**
-     * Not support
-     */
-    async authenticateAsClient(_) {
-        throw new RuntimeException('Cannot authenticate as a client when using basic auth');
-    }
-}

package/build/src/guards/basic_auth/main.d.ts

@@ -1,2 +0,0 @@
-export { BasicAuthGuard } from './guard.js';
-export { basicAuthGuard } from './define_config.js';

package/build/src/guards/basic_auth/main.js

@@ -1,10 +0,0 @@
-/*
- * @adonisjs/auth
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export { BasicAuthGuard } from './guard.js';
-export { basicAuthGuard } from './define_config.js';

package/build/src/guards/basic_auth/types.d.ts

@@ -1,35 +0,0 @@
-import { Exception } from '@poppinss/utils';
-/**
- * Events emitted by the basic auth guard
- */
-export type BasicAuthGuardEvents<User> = {
-    /**
-     * The event is emitted when the user credentials
-     * have been verified successfully.
-     */
-    'basic_auth:credentials_verified': {
-        guardName: string;
-        uid: string;
-        user: User;
-    };
-    /**
-     * Attempting to authenticate the user
-     */
-    'basic_auth:authentication_attempted': {
-        guardName: string;
-    };
-    /**
-     * Authentication was successful
-     */
-    'basic_auth:authentication_succeeded': {
-        guardName: string;
-        user: User;
-    };
-    /**
-     * Authentication failed
-     */
-    'basic_auth:authentication_failed': {
-        guardName: string;
-        error: Exception;
-    };
-};

package/build/src/guards/basic_auth/types.js

@@ -1,9 +0,0 @@
-/*
- * @adonisjs/auth
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export {};

package/build/src/guards/session/define_config.d.ts

@@ -1,23 +0,0 @@
-import type { HttpContext } from '@adonisjs/core/http';
-import type { ConfigProvider } from '@adonisjs/core/types';
-import { SessionGuard } from './guard.js';
-import type { GuardConfigProvider } from '../../auth/types.js';
-import type { SessionGuardConfig, RememberMeProviderContract, SessionUserProviderContract, DatabaseRememberMeProviderOptions } from './types.js';
-/**
- * Helper function to configure the session guard for
- * authentication.
- *
- * This method returns a config builder, which internally
- * returns a factory function to construct a guard
- * during HTTP requests.
- */
-export declare function sessionGuard<UserProvider extends SessionUserProviderContract<unknown>>(config: SessionGuardConfig & {
-    provider: ConfigProvider<UserProvider>;
-    tokens?: ConfigProvider<RememberMeProviderContract>;
-}): GuardConfigProvider<(ctx: HttpContext) => SessionGuard<UserProvider>>;
-/**
- * Tokens provider helper to store remember me tokens
- */
-export declare const tokensProvider: {
-    db: (config: DatabaseRememberMeProviderOptions) => ConfigProvider<RememberMeProviderContract>;
-};

package/build/src/guards/session/define_config.js

@@ -1,56 +0,0 @@
-/*
- * @adonisjs/auth
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { configProvider } from '@adonisjs/core';
-import { RuntimeException } from '@poppinss/utils';
-import { SessionGuard } from './guard.js';
-/**
- * Helper function to configure the session guard for
- * authentication.
- *
- * This method returns a config builder, which internally
- * returns a factory function to construct a guard
- * during HTTP requests.
- */
-export function sessionGuard(config) {
-    return {
-        async resolver(guardName, app) {
-            const provider = await configProvider.resolve(app, config.provider);
-            if (!provider) {
-                throw new RuntimeException(`Invalid user provider defined on "${guardName}" guard`);
-            }
-            const emitter = await app.container.make('emitter');
-            const tokensProvider = config.tokens
-                ? await configProvider.resolve(app, config.tokens)
-                : undefined;
-            /**
-             * Factory function needed by Authenticator to switch
-             * between guards and perform authentication
-             */
-            return (ctx) => {
-                const guard = new SessionGuard(guardName, config, ctx, provider);
-                if (tokensProvider) {
-                    guard.withRememberMeTokens(tokensProvider);
-                }
-                return guard.withEmitter(emitter);
-            };
-        },
-    };
-}
-/**
- * Tokens provider helper to store remember me tokens
- */
-export const tokensProvider = {
-    db(config) {
-        return configProvider.create(async (app) => {
-            const db = await app.container.make('lucid.db');
-            const { DatabaseRememberTokenProvider } = await import('./token_providers/main.js');
-            return new DatabaseRememberTokenProvider(db, config);
-        });
-    },
-};