@adonisjs/auth 8.2.3 → 9.0.0-1

package/build/src/Auth/index.js

@@ -1,155 +0,0 @@
-"use strict";
-/*
- * @adonisjs/auth
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * 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.Auth = void 0;
-/**
- * Auth class exposes the API to obtain guard instances for a given
- * HTTP request.
- */
-class Auth {
-    constructor(manager, ctx) {
-        this.manager = manager;
-        this.ctx = ctx;
-        /**
-         * We keep a per request singleton instances for each instantiated mapping
-         */
-        this.mappingsCache = new Map();
-        /**
-         * The default guard is always the one defined inside the config, until
-         * manually overwritten by the user
-         */
-        this.defaultGuard = this.manager.defaultGuard;
-    }
-    /**
-     * Returns an instance of a named or the default mapping
-     */
-    use(mapping) {
-        mapping = mapping || this.defaultGuard;
-        if (!this.mappingsCache.has(mapping)) {
-            this.ctx.logger.trace('instantiating auth mapping', { name: mapping });
-            this.mappingsCache.set(mapping, this.manager.makeMapping(this.ctx, mapping));
-        }
-        return this.mappingsCache.get(mapping);
-    }
-    /**
-     * Guard name for the default mapping
-     */
-    get name() {
-        return this.use().name;
-    }
-    /**
-     * Reference to the logged in user
-     */
-    get user() {
-        return this.use().user;
-    }
-    /**
-     * Reference to the default guard config
-     */
-    get config() {
-        return this.use().config;
-    }
-    /**
-     * Find if the user has been logged out in the current request
-     */
-    get isLoggedOut() {
-        return this.use().isLoggedOut;
-    }
-    /**
-     * A boolean to know if user is a guest or not. It is
-     * always opposite of [[isLoggedIn]]
-     */
-    get isGuest() {
-        return this.use().isGuest;
-    }
-    /**
-     * A boolean to know if user is logged in or not
-     */
-    get isLoggedIn() {
-        return this.use().isLoggedIn;
-    }
-    /**
-     * A boolean to know if user is retrieved by authenticating
-     * the current request or not.
-     */
-    get isAuthenticated() {
-        return this.use().isAuthenticated;
-    }
-    /**
-     * Whether or not the authentication has been attempted
-     * for the current request
-     */
-    get authenticationAttempted() {
-        return this.use().authenticationAttempted;
-    }
-    /**
-     * Reference to the provider for looking up the user
-     */
-    get provider() {
-        return this.use().provider;
-    }
-    /**
-     * Verify user credentials.
-     */
-    async verifyCredentials(uid, password) {
-        return this.use().verifyCredentials(uid, password);
-    }
-    /**
-     * Attempt to verify user credentials and perform login
-     */
-    async attempt(uid, password, ...args) {
-        return this.use().attempt(uid, password, ...args);
-    }
-    /**
-     * Login a user without any verification
-     */
-    async login(user, ...args) {
-        return this.use().login(user, ...args);
-    }
-    /**
-     * Login a user using their id
-     */
-    async loginViaId(id, ...args) {
-        return this.use().loginViaId(id, ...args);
-    }
-    /**
-     * Attempts to authenticate the user for the current HTTP request. An exception
-     * is raised when unable to do so
-     */
-    async authenticate() {
-        return this.use().authenticate();
-    }
-    /**
-     * Attempts to authenticate the user for the current HTTP request and supresses
-     * exceptions raised by the [[authenticate]] method and returns a boolean
-     */
-    async check() {
-        return this.use().check();
-    }
-    /**
-     * Logout user
-     */
-    async logout(...args) {
-        return this.use().logout(...args);
-    }
-    /**
-     * Serialize toJSON
-     */
-    toJSON() {
-        return {
-            defaultGuard: this.defaultGuard,
-            guards: [...this.mappingsCache.keys()].reduce((result, key) => {
-                result[key] = this.mappingsCache.get(key).toJSON();
-                return result;
-            }, {}),
-        };
-    }
-}
-exports.Auth = Auth;

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

@@ -1,117 +0,0 @@
-/// <reference types="@adonisjs/application/build/adonis-typings/application" />
-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';
-/**
- * Auth manager to manage guards and providers object. The extend API can
- * be used to add custom guards and providers
- */
-export declare class AuthManager implements AuthManagerContract {
-    application: ApplicationContract;
-    private config;
-    /**
-     * Extended set of testing clients
-     */
-    private extendedClients;
-    /**
-     * Extended set of providers
-     */
-    private extendedProviders;
-    /**
-     * Extend set of guards
-     */
-    private extendedGuards;
-    /**
-     * Reference to the default guard
-     */
-    defaultGuard: keyof GuardsList;
-    constructor(application: ApplicationContract, config: AuthConfig);
-    /**
-     * Verifies and returns an instance of the event emitter
-     */
-    private getEmitter;
-    /**
-     * Lazily makes an instance of the lucid provider
-     */
-    private makeLucidProvider;
-    /**
-     * Lazily makes an instance of the database provider
-     */
-    private makeDatabaseProvider;
-    /**
-     * Returns an instance of the extended provider
-     */
-    private makeExtendedProvider;
-    /**
-     * Lazily makes an instance of the token database provider
-     */
-    private makeTokenDatabaseProvider;
-    /**
-     * Lazily makes an instance of the token redis provider
-     */
-    private makeTokenRedisProvider;
-    /**
-     * Returns an instance of the session guard
-     */
-    private makeSessionGuard;
-    /**
-     * Returns an instance of the session guard
-     */
-    private makeOatGuard;
-    /**
-     * Returns an instance of the basic auth guard
-     */
-    private makeBasicAuthGuard;
-    /**
-     * 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
-     */
-    private makeUserProviderInstance;
-    /**
-     * Makes instance of a provider based upon the driver value
-     */
-    private makeTokenProviderInstance;
-    /**
-     * Makes guard instance for the defined driver inside the
-     * mapping config.
-     */
-    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
-     */
-    getAuthForRequest(ctx: HttpContextContract): any;
-    /**
-     * Extend auth by adding custom providers and guards
-     */
-    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

@@ -1,262 +0,0 @@
-"use strict";
-/*
- * @adonisjs/auth
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * 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.AuthManager = void 0;
-const utils_1 = require("@poppinss/utils");
-const Auth_1 = require("../Auth");
-/**
- * Auth manager to manage guards and providers object. The extend API can
- * be used to add custom guards and providers
- */
-class AuthManager {
-    constructor(application, config) {
-        this.application = application;
-        this.config = config;
-        /**
-         * Extended set of testing clients
-         */
-        this.extendedClients = new Map();
-        /**
-         * Extended set of providers
-         */
-        this.extendedProviders = new Map();
-        /**
-         * Extend set of guards
-         */
-        this.extendedGuards = new Map();
-        /**
-         * Reference to the default guard
-         */
-        this.defaultGuard = this.config.guard;
-        const validator = new utils_1.ManagerConfigValidator(config, 'auth', 'config/auth');
-        validator.validateDefault('guard');
-        validator.validateList('guards', 'guard');
-    }
-    /**
-     * Verifies and returns an instance of the event emitter
-     */
-    getEmitter() {
-        const hasEmitter = this.application.container.hasBinding('Adonis/Core/Event');
-        if (!hasEmitter) {
-            throw new utils_1.Exception('"Adonis/Core/Event" is required by the auth provider');
-        }
-        return this.application.container.use('Adonis/Core/Event');
-    }
-    /**
-     * Lazily makes an instance of the lucid provider
-     */
-    makeLucidProvider(config) {
-        return new (require('../UserProviders/Lucid').LucidProvider)(this.application, config);
-    }
-    /**
-     * Lazily makes an instance of the database provider
-     */
-    makeDatabaseProvider(config) {
-        const Database = this.application.container.use('Adonis/Lucid/Database');
-        return new (require('../UserProviders/Database').DatabaseProvider)(this.application, config, Database);
-    }
-    /**
-     * Returns an instance of the extended provider
-     */
-    makeExtendedProvider(mapping, config) {
-        const providerCallback = this.extendedProviders.get(config.driver);
-        if (!providerCallback) {
-            throw new utils_1.Exception(`Invalid provider "${config.driver}"`);
-        }
-        return providerCallback(this, mapping, config);
-    }
-    /**
-     * Lazily makes an instance of the token database provider
-     */
-    makeTokenDatabaseProvider(config) {
-        const Database = this.application.container.use('Adonis/Lucid/Database');
-        return new (require('../TokenProviders/Database').TokenDatabaseProvider)(config, Database);
-    }
-    /**
-     * Lazily makes an instance of the token redis provider
-     */
-    makeTokenRedisProvider(config) {
-        if (!this.application.container.hasBinding('Adonis/Addons/Redis')) {
-            throw new utils_1.Exception('"@adonisjs/redis" is required to use the "redis" token provider');
-        }
-        const Redis = this.application.container.use('Adonis/Addons/Redis');
-        return new (require('../TokenProviders/Redis').TokenRedisProvider)(config, Redis);
-    }
-    /**
-     * Returns an instance of the session guard
-     */
-    makeSessionGuard(mapping, config, provider, ctx) {
-        const { SessionGuard } = require('../Guards/Session');
-        return new SessionGuard(mapping, config, this.getEmitter(), provider, ctx);
-    }
-    /**
-     * Returns an instance of the session guard
-     */
-    makeOatGuard(mapping, config, provider, ctx) {
-        const { OATGuard } = require('../Guards/Oat');
-        const tokenProvider = this.makeTokenProviderInstance(config.tokenProvider);
-        return new OATGuard(mapping, config, this.getEmitter(), provider, ctx, tokenProvider);
-    }
-    /**
-     * Returns an instance of the basic auth guard
-     */
-    makeBasicAuthGuard(mapping, config, provider, ctx) {
-        const { BasicAuthGuard } = require('../Guards/BasicAuth');
-        return new BasicAuthGuard(mapping, config, this.getEmitter(), provider, ctx);
-    }
-    /**
-     * Returns an instance of the extended guard
-     */
-    makeExtendedGuard(mapping, config, provider, ctx) {
-        const guardCallback = this.extendedGuards.get(config.driver);
-        if (!guardCallback) {
-            throw new utils_1.Exception(`Invalid guard driver "${config.driver}" property`);
-        }
-        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
-     */
-    makeUserProviderInstance(mapping, providerConfig) {
-        if (!providerConfig || !providerConfig.driver) {
-            throw new utils_1.Exception('Invalid auth config, missing "provider" or "provider.driver" property');
-        }
-        switch (providerConfig.driver) {
-            case 'lucid':
-                return this.makeLucidProvider(providerConfig);
-            case 'database':
-                return this.makeDatabaseProvider(providerConfig);
-            default:
-                return this.makeExtendedProvider(mapping, providerConfig);
-        }
-    }
-    /**
-     * Makes instance of a provider based upon the driver value
-     */
-    makeTokenProviderInstance(providerConfig) {
-        if (!providerConfig || !providerConfig.driver) {
-            throw new utils_1.Exception('Invalid auth config, missing "tokenProvider" or "tokenProvider.driver" property');
-        }
-        switch (providerConfig.driver) {
-            case 'database':
-                return this.makeTokenDatabaseProvider(providerConfig);
-            case 'redis':
-                return this.makeTokenRedisProvider(providerConfig);
-            default:
-                throw new utils_1.Exception(`Invalid token provider "${providerConfig.driver}"`);
-        }
-    }
-    /**
-     * Makes guard instance for the defined driver inside the
-     * mapping config.
-     */
-    makeGuardInstance(mapping, mappingConfig, provider, ctx) {
-        if (!mappingConfig || !mappingConfig.driver) {
-            throw new utils_1.Exception('Invalid auth config, missing "driver" property');
-        }
-        switch (mappingConfig.driver) {
-            case 'session':
-                return this.makeSessionGuard(mapping, mappingConfig, provider, ctx);
-            case 'oat':
-                return this.makeOatGuard(mapping, mappingConfig, provider, ctx);
-            case 'basic':
-                return this.makeBasicAuthGuard(mapping, mappingConfig, provider, ctx);
-            default:
-                return this.makeExtendedGuard(mapping, mappingConfig, provider, ctx);
-        }
-    }
-    /**
-     * Make an instance of a given mapping for the current HTTP request.
-     */
-    makeMapping(ctx, 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.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
-     */
-    getAuthForRequest(ctx) {
-        return new Auth_1.Auth(this, ctx);
-    }
-    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;
-        }
-    }
-}
-exports.AuthManager = AuthManager;

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

@@ -1,6 +0,0 @@
-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

@@ -1,69 +0,0 @@
-"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

@@ -1,50 +0,0 @@
-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>;
-}