@adonisjs/auth 8.2.3 → 9.0.0-1

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

@@ -1,23 +0,0 @@
-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/instructions.js

@@ -1,338 +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 });
-const path_1 = require("path");
-const helpers_1 = require("@poppinss/utils/build/helpers");
-// const USER_MIGRATION_TIME_PREFIX = '1587988332388'
-// const TOKENS_MIGRATION_TIME_PREFIX = '1592489784670'
-/**
- * Base path to contract stub partials
- */
-const CONTRACTS_PARTIALS_BASE = './contract/partials';
-/**
- * Base path to config stub partials
- */
-const CONFIG_PARTIALS_BASE = './config/partials';
-/**
- * Prompt choices for the provider selection
- */
-const PROVIDER_PROMPT_CHOICES = [
-    {
-        name: 'lucid',
-        message: 'Lucid',
-        hint: ' (Uses Data Models)',
-    },
-    {
-        name: 'database',
-        message: 'Database',
-        hint: ' (Uses Database QueryBuilder)',
-    },
-];
-/**
- * Prompt choices for the guard selection
- */
-const GUARD_PROMPT_CHOICES = [
-    {
-        name: 'web',
-        message: 'Web',
-        hint: ' (Uses sessions for managing auth state)',
-    },
-    {
-        name: 'api',
-        message: 'API tokens',
-        hint: ' (Uses database backed opaque tokens)',
-    },
-    {
-        name: 'basic',
-        message: 'Basic Auth',
-        hint: ' (Uses HTTP Basic auth for authenticating requests)',
-    },
-];
-/**
- * Prompt choices for the tokens provider selection
- */
-const TOKENS_PROVIDER_PROMPT_CHOICES = [
-    {
-        name: 'database',
-        message: 'Database',
-        hint: ' (Uses SQL table for storing API tokens)',
-    },
-    {
-        name: 'redis',
-        message: 'Redis',
-        hint: ' (Uses Redis for storing API tokens)',
-    },
-];
-/**
- * Returns absolute path to the stub relative from the templates
- * directory
- */
-function getStub(...relativePaths) {
-    return (0, path_1.join)(__dirname, 'templates', ...relativePaths);
-}
-/**
- * Creates the model file
- */
-function makeModel(projectRoot, app, sink, state) {
-    const modelsDirectory = app.resolveNamespaceDirectory('models') || 'app/Models';
-    const modelPath = (0, path_1.join)(modelsDirectory, `${state.modelName}.ts`);
-    const template = new sink.files.MustacheFile(projectRoot, modelPath, getStub('model.txt'));
-    if (template.exists()) {
-        sink.logger.action('create').skipped(`${modelPath} file already exists`);
-        return;
-    }
-    template.apply(state).commit();
-    sink.logger.action('create').succeeded(modelPath);
-}
-/**
- * Create the migration file
- */
-function makeUsersMigration(projectRoot, app, sink, state) {
-    const migrationsDirectory = app.directoriesMap.get('migrations') || 'database';
-    const migrationPath = (0, path_1.join)(migrationsDirectory, `${Date.now()}_${state.usersTableName}.ts`);
-    const template = new sink.files.MustacheFile(projectRoot, migrationPath, getStub('migrations/auth.txt'));
-    if (template.exists()) {
-        sink.logger.action('create').skipped(`${migrationPath} file already exists`);
-        return;
-    }
-    template.apply(state).commit();
-    sink.logger.action('create').succeeded(migrationPath);
-}
-/**
- * Create the migration file
- */
-function makeTokensMigration(projectRoot, app, sink, state) {
-    const migrationsDirectory = app.directoriesMap.get('migrations') || 'database';
-    const migrationPath = (0, path_1.join)(migrationsDirectory, `${Date.now()}_${state.tokensTableName}.ts`);
-    const template = new sink.files.MustacheFile(projectRoot, migrationPath, getStub('migrations/api_tokens.txt'));
-    if (template.exists()) {
-        sink.logger.action('create').skipped(`${migrationPath} file already exists`);
-        return;
-    }
-    template.apply(state).commit();
-    sink.logger.action('create').succeeded(migrationPath);
-}
-/**
- * Create the middleware(s)
- */
-function makeMiddleware(projectRoot, app, sink, state) {
-    const middlewareDirectory = app.resolveNamespaceDirectory('middleware') || 'app/Middleware';
-    /**
-     * Auth middleware
-     */
-    const authPath = (0, path_1.join)(middlewareDirectory, 'Auth.ts');
-    const authTemplate = new sink.files.MustacheFile(projectRoot, authPath, getStub('middleware/Auth.txt'));
-    if (authTemplate.exists()) {
-        sink.logger.action('create').skipped(`${authPath} file already exists`);
-    }
-    else {
-        authTemplate.apply(state).commit();
-        sink.logger.action('create').succeeded(authPath);
-    }
-    /**
-     * Silent auth middleware
-     */
-    const silentAuthPath = (0, path_1.join)(middlewareDirectory, 'SilentAuth.ts');
-    const silentAuthTemplate = new sink.files.MustacheFile(projectRoot, silentAuthPath, getStub('middleware/SilentAuth.txt'));
-    if (silentAuthTemplate.exists()) {
-        sink.logger.action('create').skipped(`${silentAuthPath} file already exists`);
-    }
-    else {
-        silentAuthTemplate.apply(state).commit();
-        sink.logger.action('create').succeeded(silentAuthPath);
-    }
-}
-/**
- * Creates the contract file
- */
-function makeContract(projectRoot, app, sink, state) {
-    const contractsDirectory = app.directoriesMap.get('contracts') || 'contracts';
-    const contractPath = (0, path_1.join)(contractsDirectory, 'auth.ts');
-    const template = new sink.files.MustacheFile(projectRoot, contractPath, getStub('contract/auth.txt'));
-    template.overwrite = true;
-    const partials = {
-        provider: getStub(CONTRACTS_PARTIALS_BASE, `user-provider-${state.provider}.txt`),
-    };
-    state.guards.forEach((guard) => {
-        partials[`${guard}_guard`] = getStub(CONTRACTS_PARTIALS_BASE, `${guard}-guard.txt`);
-    });
-    template.apply(state).partials(partials).commit();
-    sink.logger.action('create').succeeded(contractPath);
-}
-/**
- * Makes the auth config file
- */
-function makeConfig(projectRoot, app, sink, state) {
-    const configDirectory = app.directoriesMap.get('config') || 'config';
-    const configPath = (0, path_1.join)(configDirectory, 'auth.ts');
-    const template = new sink.files.MustacheFile(projectRoot, configPath, getStub('config/auth.txt'));
-    template.overwrite = true;
-    const partials = {
-        provider: getStub(CONFIG_PARTIALS_BASE, `user-provider-${state.provider}.txt`),
-        token_provider: getStub(CONFIG_PARTIALS_BASE, `tokens-provider-${state.tokensProvider}.txt`),
-    };
-    state.guards.forEach((guard) => {
-        partials[`${guard}_guard`] = getStub(CONFIG_PARTIALS_BASE, `${guard}-guard.txt`);
-    });
-    template.apply(state).partials(partials).commit();
-    sink.logger.action('create').succeeded(configPath);
-}
-/**
- * Prompts user to select the provider
- */
-async function getProvider(sink) {
-    return sink.getPrompt().choice('Select provider for finding users', PROVIDER_PROMPT_CHOICES, {
-        validate(choice) {
-            return choice && choice.length ? true : 'Select the provider for finding users';
-        },
-    });
-}
-/**
- * Prompts user to select the tokens provider
- */
-async function getTokensProvider(sink) {
-    return sink
-        .getPrompt()
-        .choice('Select the provider for storing API tokens', TOKENS_PROVIDER_PROMPT_CHOICES, {
-        validate(choice) {
-            return choice && choice.length ? true : 'Select the provider for storing API tokens';
-        },
-    });
-}
-/**
- * Prompts user to select one or more guards
- */
-async function getGuard(sink) {
-    return sink
-        .getPrompt()
-        .multiple('Select which guard you need for authentication (select using space)', GUARD_PROMPT_CHOICES, {
-        validate(choices) {
-            return choices && choices.length
-                ? true
-                : 'Select one or more guards for authenticating users';
-        },
-    });
-}
-/**
- * Prompts user for the model name
- */
-async function getModelName(sink) {
-    return sink.getPrompt().ask('Enter model name to be used for authentication', {
-        validate(value) {
-            return !!value.trim().length;
-        },
-    });
-}
-/**
- * Prompts user for the table name
- */
-async function getTableName(sink) {
-    return sink.getPrompt().ask('Enter the database table name to look up users', {
-        validate(value) {
-            return !!value.trim().length;
-        },
-    });
-}
-/**
- * Prompts user for the table name
- */
-async function getMigrationConsent(sink, tableName) {
-    return sink
-        .getPrompt()
-        .confirm(`Create migration for the ${sink.logger.colors.underline(tableName)} table?`);
-}
-/**
- * Instructions to be executed when setting up the package.
- */
-async function instructions(projectRoot, app, sink) {
-    const state = {
-        usersTableName: '',
-        tokensTableName: 'api_tokens',
-        tokensSchemaName: 'ApiTokens',
-        usersSchemaName: '',
-        provider: 'lucid',
-        tokensProvider: 'database',
-        guards: [],
-        hasGuard: {
-            web: false,
-            api: false,
-            basic: false,
-        },
-    };
-    state.provider = await getProvider(sink);
-    state.guards = await getGuard(sink);
-    /**
-     * Need booleans for mustache templates
-     */
-    state.guards.forEach((guard) => (state.hasGuard[guard] = true));
-    /**
-     * Make model when provider is lucid otherwise prompt for the database
-     * table name
-     */
-    if (state.provider === 'lucid') {
-        const modelName = await getModelName(sink);
-        state.modelName = helpers_1.string.pascalCase(helpers_1.string.singularize(modelName.replace(/(\.ts|\.js)$/, '')));
-        state.usersTableName = helpers_1.string.pluralize(helpers_1.string.snakeCase(state.modelName));
-        state.modelReference = helpers_1.string.camelCase(helpers_1.string.singularize(state.modelName));
-        state.modelNamespace = `${app.namespacesMap.get('models') || 'App/Models'}/${state.modelName}`;
-    }
-    else {
-        state.usersTableName = await getTableName(sink);
-    }
-    const usersMigrationConsent = await getMigrationConsent(sink, state.usersTableName);
-    let tokensMigrationConsent = false;
-    /**
-     * Only ask for the consent when using the api guard
-     */
-    if (state.hasGuard.api) {
-        state.tokensProvider = await getTokensProvider(sink);
-        if (state.tokensProvider === 'database') {
-            tokensMigrationConsent = await getMigrationConsent(sink, state.tokensTableName);
-        }
-    }
-    /**
-     * Pascal case
-     */
-    const camelCaseSchemaName = helpers_1.string.camelCase(`${state.usersTableName}_schema`);
-    state.usersSchemaName = `${camelCaseSchemaName
-        .charAt(0)
-        .toUpperCase()}${camelCaseSchemaName.slice(1)}`;
-    /**
-     * Make model when prompted for it
-     */
-    if (state.modelName) {
-        makeModel(projectRoot, app, sink, state);
-    }
-    /**
-     * Make users migration file
-     */
-    if (usersMigrationConsent) {
-        makeUsersMigration(projectRoot, app, sink, state);
-    }
-    /**
-     * Make tokens migration file
-     */
-    if (tokensMigrationConsent) {
-        makeTokensMigration(projectRoot, app, sink, state);
-    }
-    /**
-     * Make contract file
-     */
-    makeContract(projectRoot, app, sink, state);
-    /**
-     * Make config file
-     */
-    makeConfig(projectRoot, app, sink, state);
-    /**
-     * Make middleware
-     */
-    makeMiddleware(projectRoot, app, sink, state);
-}
-exports.default = instructions;

package/build/providers/AuthProvider.d.ts

@@ -1,30 +0,0 @@
-/// <reference types="@adonisjs/application/build/adonis-typings/application" />
-import { ApplicationContract } from '@ioc:Adonis/Core/Application';
-/**
- * Auth provider to register the auth binding
- */
-export default class AuthProvider {
-    protected application: ApplicationContract;
-    constructor(application: ApplicationContract);
-    static needsApplication: boolean;
-    /**
-     * 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
-     */
-    boot(): Promise<void>;
-}

package/build/providers/AuthProvider.js

@@ -1,69 +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 });
-/**
- * Auth provider to register the auth binding
- */
-class AuthProvider {
-    constructor(application) {
-        this.application = application;
-    }
-    /**
-     * Register auth binding
-     */
-    register() {
-        this.application.container.singleton('Adonis/Addons/Auth', () => {
-            const authConfig = this.application.container
-                .resolveBinding('Adonis/Core/Config')
-                .get('auth', {});
-            const { AuthManager } = require('../src/AuthManager');
-            return new AuthManager(this.application, authConfig);
-        });
-    }
-    /**
-     * Sharing the auth object with HTTP context
-     */
-    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/Auth/index.d.ts

@@ -1,97 +0,0 @@
-import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-import { AuthContract, AuthManagerContract } from '@ioc:Adonis/Addons/Auth';
-/**
- * Auth class exposes the API to obtain guard instances for a given
- * HTTP request.
- */
-export declare class Auth implements AuthContract {
-    private manager;
-    private ctx;
-    /**
-     * We keep a per request singleton instances for each instantiated mapping
-     */
-    private mappingsCache;
-    /**
-     * The default guard is always the one defined inside the config, until
-     * manually overwritten by the user
-     */
-    defaultGuard: string;
-    constructor(manager: AuthManagerContract, ctx: HttpContextContract);
-    /**
-     * Returns an instance of a named or the default mapping
-     */
-    use(mapping?: string): any;
-    /**
-     * Guard name for the default mapping
-     */
-    get name(): any;
-    /**
-     * Reference to the logged in user
-     */
-    get user(): any;
-    /**
-     * Reference to the default guard config
-     */
-    get config(): any;
-    /**
-     * Find if the user has been logged out in the current request
-     */
-    get isLoggedOut(): any;
-    /**
-     * A boolean to know if user is a guest or not. It is
-     * always opposite of [[isLoggedIn]]
-     */
-    get isGuest(): any;
-    /**
-     * A boolean to know if user is logged in or not
-     */
-    get isLoggedIn(): any;
-    /**
-     * A boolean to know if user is retrieved by authenticating
-     * the current request or not.
-     */
-    get isAuthenticated(): any;
-    /**
-     * Whether or not the authentication has been attempted
-     * for the current request
-     */
-    get authenticationAttempted(): any;
-    /**
-     * Reference to the provider for looking up the user
-     */
-    get provider(): any;
-    /**
-     * Verify user credentials.
-     */
-    verifyCredentials(uid: string, password: string): Promise<any>;
-    /**
-     * Attempt to verify user credentials and perform login
-     */
-    attempt(uid: string, password: string, ...args: any[]): Promise<any>;
-    /**
-     * Login a user without any verification
-     */
-    login(user: any, ...args: any[]): Promise<any>;
-    /**
-     * Login a user using their id
-     */
-    loginViaId(id: string | number, ...args: any[]): Promise<any>;
-    /**
-     * Attempts to authenticate the user for the current HTTP request. An exception
-     * is raised when unable to do so
-     */
-    authenticate(): Promise<any>;
-    /**
-     * Attempts to authenticate the user for the current HTTP request and supresses
-     * exceptions raised by the [[authenticate]] method and returns a boolean
-     */
-    check(): Promise<any>;
-    /**
-     * Logout user
-     */
-    logout(...args: any[]): Promise<any>;
-    /**
-     * Serialize toJSON
-     */
-    toJSON(): any;
-}